Mercurial > hg > truffle
annotate src/share/vm/opto/doCall.cpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | 1419657ed891 |
| children | fdad2932c73f |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17467
55fb97c4c58d
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12966
diff
changeset
|
2 * Copyright (c) 1998, 2013, 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:
1344
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1344
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:
1344
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "ci/ciCallSite.hpp" | |
| 27 #include "ci/ciMethodHandle.hpp" | |
| 28 #include "classfile/vmSymbols.hpp" | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
1972
diff
changeset
|
29 #include "compiler/compileBroker.hpp" |
| 1972 | 30 #include "compiler/compileLog.hpp" |
| 31 #include "interpreter/linkResolver.hpp" | |
| 32 #include "opto/addnode.hpp" | |
| 33 #include "opto/callGenerator.hpp" | |
| 34 #include "opto/cfgnode.hpp" | |
| 35 #include "opto/mulnode.hpp" | |
| 36 #include "opto/parse.hpp" | |
| 37 #include "opto/rootnode.hpp" | |
| 38 #include "opto/runtime.hpp" | |
| 39 #include "opto/subnode.hpp" | |
| 40 #include "prims/nativeLookup.hpp" | |
| 41 #include "runtime/sharedRuntime.hpp" | |
| 0 | 42 |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
43 void trace_type_profile(Compile* C, ciMethod *method, int depth, int bci, ciMethod *prof_method, ciKlass *prof_klass, int site_count, int receiver_count) { |
| 12295 | 44 if (TraceTypeProfile || C->print_inlining()) { |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
45 outputStream* out = tty; |
| 12295 | 46 if (!C->print_inlining()) { |
| 6793 | 47 if (NOT_PRODUCT(!PrintOpto &&) !PrintCompilation) { |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
1972
diff
changeset
|
48 method->print_short_name(); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
1972
diff
changeset
|
49 tty->cr(); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
1972
diff
changeset
|
50 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
1972
diff
changeset
|
51 CompileTask::print_inlining(prof_method, depth, bci); |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
52 } else { |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
53 out = C->print_inlining_stream(); |
| 0 | 54 } |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
55 CompileTask::print_inline_indent(depth, out); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
56 out->print(" \\-> TypeProfile (%d/%d counts) = ", receiver_count, site_count); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
57 stringStream ss; |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
58 prof_klass->name()->print_symbol_on(&ss); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
59 out->print(ss.as_string()); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
60 out->cr(); |
| 0 | 61 } |
| 62 } | |
| 63 | |
| 7478 | 64 CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool call_does_dispatch, |
|
1157
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
65 JVMState* jvms, bool allow_inline, |
| 12966 | 66 float prof_factor, ciKlass* speculative_receiver_type, |
| 67 bool allow_intrinsics, bool delayed_forbidden) { | |
|
3371
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
3366
diff
changeset
|
68 ciMethod* caller = jvms->method(); |
|
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
3366
diff
changeset
|
69 int bci = jvms->bci(); |
|
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
3366
diff
changeset
|
70 Bytecodes::Code bytecode = caller->java_code_at_bci(bci); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
71 guarantee(callee != NULL, "failed method resolution"); |
| 0 | 72 |
| 73 // Dtrace currently doesn't work unless all calls are vanilla | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
726
diff
changeset
|
74 if (env()->dtrace_method_probes()) { |
| 0 | 75 allow_inline = false; |
| 76 } | |
| 77 | |
| 78 // Note: When we get profiling during stage-1 compiles, we want to pull | |
| 79 // from more specific profile data which pertains to this inlining. | |
| 80 // Right now, ignore the information in jvms->caller(), and do method[bci]. | |
|
3371
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
3366
diff
changeset
|
81 ciCallProfile profile = caller->call_profile_at_bci(bci); |
| 0 | 82 |
| 83 // See how many times this site has been invoked. | |
| 84 int site_count = profile.count(); | |
| 85 int receiver_count = -1; | |
| 7478 | 86 if (call_does_dispatch && UseTypeProfile && profile.has_receiver(0)) { |
| 0 | 87 // Receivers in the profile structure are ordered by call counts |
| 88 // so that the most called (major) receiver is profile.receiver(0). | |
| 89 receiver_count = profile.receiver_count(0); | |
| 90 } | |
| 91 | |
| 92 CompileLog* log = this->log(); | |
| 93 if (log != NULL) { | |
| 94 int rid = (receiver_count >= 0)? log->identify(profile.receiver(0)): -1; | |
|
1251
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
95 int r2id = (rid != -1 && profile.has_receiver(1))? log->identify(profile.receiver(1)):-1; |
| 0 | 96 log->begin_elem("call method='%d' count='%d' prof_factor='%g'", |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
97 log->identify(callee), site_count, prof_factor); |
| 7478 | 98 if (call_does_dispatch) log->print(" virtual='1'"); |
| 0 | 99 if (allow_inline) log->print(" inline='1'"); |
| 100 if (receiver_count >= 0) { | |
| 101 log->print(" receiver='%d' receiver_count='%d'", rid, receiver_count); | |
| 102 if (profile.has_receiver(1)) { | |
| 103 log->print(" receiver2='%d' receiver2_count='%d'", r2id, profile.receiver_count(1)); | |
| 104 } | |
| 105 } | |
| 106 log->end_elem(); | |
| 107 } | |
| 108 | |
| 109 // Special case the handling of certain common, profitable library | |
| 110 // methods. If these methods are replaced with specialized code, | |
| 111 // then we return it as the inlined version of the call. | |
| 112 // We do this before the strict f.p. check below because the | |
| 113 // intrinsics handle strict f.p. correctly. | |
|
12330
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
114 CallGenerator* cg_intrinsic = NULL; |
|
5927
b40ac3579043
6658428: C2 doesn't inline java method if corresponding intrinsic failed to inline.
never
parents:
4117
diff
changeset
|
115 if (allow_inline && allow_intrinsics) { |
| 7478 | 116 CallGenerator* cg = find_intrinsic(callee, call_does_dispatch); |
| 6894 | 117 if (cg != NULL) { |
| 118 if (cg->is_predicted()) { | |
| 119 // Code without intrinsic but, hopefully, inlined. | |
| 120 CallGenerator* inline_cg = this->call_generator(callee, | |
| 12966 | 121 vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, speculative_receiver_type, false); |
| 6894 | 122 if (inline_cg != NULL) { |
| 123 cg = CallGenerator::for_predicted_intrinsic(cg, inline_cg); | |
| 124 } | |
| 125 } | |
|
12330
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
126 |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
127 // If intrinsic does the virtual dispatch, we try to use the type profile |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
128 // first, and hopefully inline it as the regular virtual call below. |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
129 // We will retry the intrinsic if nothing had claimed it afterwards. |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
130 if (cg->does_virtual_dispatch()) { |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
131 cg_intrinsic = cg; |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
132 cg = NULL; |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
133 } else { |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
134 return cg; |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
135 } |
| 6894 | 136 } |
| 0 | 137 } |
| 138 | |
|
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3784
diff
changeset
|
139 // Do method handle calls. |
|
1823
8aa5fd5d2046
6987634: JSR 292 assert(start_bci() >= 0 && start_bci() < code_size()) failed: correct osr_bci argument
twisti
parents:
1645
diff
changeset
|
140 // NOTE: This must happen before normal inlining logic below since |
|
8aa5fd5d2046
6987634: JSR 292 assert(start_bci() >= 0 && start_bci() < code_size()) failed: correct osr_bci argument
twisti
parents:
1645
diff
changeset
|
141 // MethodHandle.invoke* are native methods which obviously don't |
|
8aa5fd5d2046
6987634: JSR 292 assert(start_bci() >= 0 && start_bci() < code_size()) failed: correct osr_bci argument
twisti
parents:
1645
diff
changeset
|
142 // have bytecodes and so normal inlining fails. |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
143 if (callee->is_method_handle_intrinsic()) { |
| 7473 | 144 CallGenerator* cg = CallGenerator::for_method_handle_call(jvms, caller, callee, delayed_forbidden); |
| 7478 | 145 assert(cg == NULL || !delayed_forbidden || !cg->is_late_inline() || cg->is_mh_late_inline(), "unexpected CallGenerator"); |
| 7473 | 146 return cg; |
|
1823
8aa5fd5d2046
6987634: JSR 292 assert(start_bci() >= 0 && start_bci() < code_size()) failed: correct osr_bci argument
twisti
parents:
1645
diff
changeset
|
147 } |
|
8aa5fd5d2046
6987634: JSR 292 assert(start_bci() >= 0 && start_bci() < code_size()) failed: correct osr_bci argument
twisti
parents:
1645
diff
changeset
|
148 |
| 0 | 149 // Do not inline strict fp into non-strict code, or the reverse |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
150 if (caller->is_strict() ^ callee->is_strict()) { |
| 0 | 151 allow_inline = false; |
| 152 } | |
| 153 | |
| 154 // Attempt to inline... | |
| 155 if (allow_inline) { | |
| 156 // The profile data is only partly attributable to this caller, | |
| 157 // scale back the call site information. | |
| 158 float past_uses = jvms->method()->scale_count(site_count, prof_factor); | |
| 159 // This is the number of times we expect the call code to be used. | |
| 160 float expected_uses = past_uses; | |
| 161 | |
| 162 // Try inlining a bytecoded method: | |
| 7478 | 163 if (!call_does_dispatch) { |
| 17672 | 164 InlineTree* ilt = InlineTree::find_subtree_from_root(this->ilt(), jvms->caller(), jvms->method()); |
| 0 | 165 WarmCallInfo scratch_ci; |
| 7473 | 166 bool should_delay = false; |
| 167 WarmCallInfo* ci = ilt->ok_to_inline(callee, jvms, profile, &scratch_ci, should_delay); | |
| 0 | 168 assert(ci != &scratch_ci, "do not let this pointer escape"); |
| 169 bool allow_inline = (ci != NULL && !ci->is_cold()); | |
| 170 bool require_inline = (allow_inline && ci->is_hot()); | |
| 171 | |
| 172 if (allow_inline) { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
173 CallGenerator* cg = CallGenerator::for_inline(callee, expected_uses); |
| 7473 | 174 |
| 175 if (require_inline && cg != NULL) { | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
176 // Delay the inlining of this method to give us the |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
177 // opportunity to perform some high level optimizations |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
178 // first. |
| 10278 | 179 if (should_delay_string_inlining(callee, jvms)) { |
| 7473 | 180 assert(!delayed_forbidden, "strange"); |
| 181 return CallGenerator::for_string_late_inline(callee, cg); | |
| 10278 | 182 } else if (should_delay_boxing_inlining(callee, jvms)) { |
| 183 assert(!delayed_forbidden, "strange"); | |
| 184 return CallGenerator::for_boxing_late_inline(callee, cg); | |
| 7473 | 185 } else if ((should_delay || AlwaysIncrementalInline) && !delayed_forbidden) { |
| 186 return CallGenerator::for_late_inline(callee, cg); | |
| 187 } | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
188 } |
| 7473 | 189 if (cg == NULL || should_delay) { |
| 0 | 190 // Fall through. |
| 191 } else if (require_inline || !InlineWarmCalls) { | |
| 192 return cg; | |
| 193 } else { | |
| 7478 | 194 CallGenerator* cold_cg = call_generator(callee, vtable_index, call_does_dispatch, jvms, false, prof_factor); |
| 0 | 195 return CallGenerator::for_warm_call(ci, cold_cg, cg); |
| 196 } | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 // Try using the type profile. | |
| 7478 | 201 if (call_does_dispatch && site_count > 0 && receiver_count > 0) { |
| 0 | 202 // The major receiver's count >= TypeProfileMajorReceiverPercent of site_count. |
| 203 bool have_major_receiver = (100.*profile.receiver_prob(0) >= (float)TypeProfileMajorReceiverPercent); | |
| 204 ciMethod* receiver_method = NULL; | |
| 12966 | 205 |
| 206 int morphism = profile.morphism(); | |
| 207 if (speculative_receiver_type != NULL) { | |
| 208 // We have a speculative type, we should be able to resolve | |
| 209 // the call. We do that before looking at the profiling at | |
| 210 // this invoke because it may lead to bimorphic inlining which | |
| 211 // a speculative type should help us avoid. | |
| 212 receiver_method = callee->resolve_invoke(jvms->method()->holder(), | |
| 213 speculative_receiver_type); | |
| 214 if (receiver_method == NULL) { | |
| 215 speculative_receiver_type = NULL; | |
| 216 } else { | |
| 217 morphism = 1; | |
| 218 } | |
| 219 } | |
| 220 if (receiver_method == NULL && | |
| 221 (have_major_receiver || morphism == 1 || | |
| 222 (morphism == 2 && UseBimorphicInlining))) { | |
| 0 | 223 // receiver_method = profile.method(); |
| 224 // Profiles do not suggest methods now. Look it up in the major receiver. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
225 receiver_method = callee->resolve_invoke(jvms->method()->holder(), |
| 0 | 226 profile.receiver(0)); |
| 227 } | |
| 228 if (receiver_method != NULL) { | |
| 229 // The single majority receiver sufficiently outweighs the minority. | |
| 230 CallGenerator* hit_cg = this->call_generator(receiver_method, | |
| 7478 | 231 vtable_index, !call_does_dispatch, jvms, allow_inline, prof_factor); |
| 0 | 232 if (hit_cg != NULL) { |
| 233 // Look up second receiver. | |
| 234 CallGenerator* next_hit_cg = NULL; | |
| 235 ciMethod* next_receiver_method = NULL; | |
| 12966 | 236 if (morphism == 2 && UseBimorphicInlining) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
237 next_receiver_method = callee->resolve_invoke(jvms->method()->holder(), |
| 0 | 238 profile.receiver(1)); |
| 239 if (next_receiver_method != NULL) { | |
| 240 next_hit_cg = this->call_generator(next_receiver_method, | |
| 7478 | 241 vtable_index, !call_does_dispatch, jvms, |
| 0 | 242 allow_inline, prof_factor); |
| 243 if (next_hit_cg != NULL && !next_hit_cg->is_inline() && | |
| 244 have_major_receiver && UseOnlyInlinedBimorphic) { | |
| 245 // Skip if we can't inline second receiver's method | |
| 246 next_hit_cg = NULL; | |
| 247 } | |
| 248 } | |
| 249 } | |
| 250 CallGenerator* miss_cg; | |
| 12966 | 251 Deoptimization::DeoptReason reason = morphism == 2 ? |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1157
diff
changeset
|
252 Deoptimization::Reason_bimorphic : |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1157
diff
changeset
|
253 Deoptimization::Reason_class_check; |
| 12966 | 254 if ((morphism == 1 || (morphism == 2 && next_hit_cg != NULL)) && |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1157
diff
changeset
|
255 !too_many_traps(jvms->method(), jvms->bci(), reason) |
| 0 | 256 ) { |
| 257 // Generate uncommon trap for class check failure path | |
| 258 // in case of monomorphic or bimorphic virtual call site. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
259 miss_cg = CallGenerator::for_uncommon_trap(callee, reason, |
| 0 | 260 Deoptimization::Action_maybe_recompile); |
| 261 } else { | |
| 262 // Generate virtual call for class check failure path | |
| 263 // in case of polymorphic virtual call site. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
264 miss_cg = CallGenerator::for_virtual_call(callee, vtable_index); |
| 0 | 265 } |
| 266 if (miss_cg != NULL) { | |
| 267 if (next_hit_cg != NULL) { | |
| 12966 | 268 assert(speculative_receiver_type == NULL, "shouldn't end up here if we used speculation"); |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
269 trace_type_profile(C, jvms->method(), jvms->depth() - 1, jvms->bci(), next_receiver_method, profile.receiver(1), site_count, profile.receiver_count(1)); |
| 0 | 270 // We don't need to record dependency on a receiver here and below. |
| 271 // Whenever we inline, the dependency is added by Parse::Parse(). | |
| 272 miss_cg = CallGenerator::for_predicted_call(profile.receiver(1), miss_cg, next_hit_cg, PROB_MAX); | |
| 273 } | |
| 274 if (miss_cg != NULL) { | |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
7194
diff
changeset
|
275 trace_type_profile(C, jvms->method(), jvms->depth() - 1, jvms->bci(), receiver_method, profile.receiver(0), site_count, receiver_count); |
| 12966 | 276 ciKlass* k = speculative_receiver_type != NULL ? speculative_receiver_type : profile.receiver(0); |
| 277 float hit_prob = speculative_receiver_type != NULL ? 1.0 : profile.receiver_prob(0); | |
| 278 CallGenerator* cg = CallGenerator::for_predicted_call(k, miss_cg, hit_cg, hit_prob); | |
| 0 | 279 if (cg != NULL) return cg; |
| 280 } | |
| 281 } | |
| 282 } | |
| 283 } | |
| 284 } | |
| 285 } | |
| 286 | |
|
12330
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
287 // Nothing claimed the intrinsic, we go with straight-forward inlining |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
288 // for already discovered intrinsic. |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
289 if (allow_inline && allow_intrinsics && cg_intrinsic != NULL) { |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
290 assert(cg_intrinsic->does_virtual_dispatch(), "sanity"); |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
291 return cg_intrinsic; |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
292 } |
|
29bdcf12457c
8014447: Object.hashCode intrinsic breaks inline caches
shade
parents:
12295
diff
changeset
|
293 |
| 0 | 294 // There was no special inlining tactic, or it bailed out. |
| 295 // Use a more generic tactic, like a simple call. | |
| 7478 | 296 if (call_does_dispatch) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
297 return CallGenerator::for_virtual_call(callee, vtable_index); |
| 0 | 298 } else { |
| 299 // Class Hierarchy Analysis or Type Profile reveals a unique target, | |
| 300 // or it is a static or special call. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
301 return CallGenerator::for_direct_call(callee, should_delay_inlining(callee, jvms)); |
| 0 | 302 } |
| 303 } | |
| 304 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
305 // Return true for methods that shouldn't be inlined early so that |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
306 // they are easier to analyze and optimize as intrinsics. |
| 10278 | 307 bool Compile::should_delay_string_inlining(ciMethod* call_method, JVMState* jvms) { |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
308 if (has_stringbuilder()) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
309 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
310 if ((call_method->holder() == C->env()->StringBuilder_klass() || |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
311 call_method->holder() == C->env()->StringBuffer_klass()) && |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
312 (jvms->method()->holder() == C->env()->StringBuilder_klass() || |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
313 jvms->method()->holder() == C->env()->StringBuffer_klass())) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
314 // Delay SB calls only when called from non-SB code |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
315 return false; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
316 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
317 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
318 switch (call_method->intrinsic_id()) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
319 case vmIntrinsics::_StringBuilder_void: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
320 case vmIntrinsics::_StringBuilder_int: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
321 case vmIntrinsics::_StringBuilder_String: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
322 case vmIntrinsics::_StringBuilder_append_char: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
323 case vmIntrinsics::_StringBuilder_append_int: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
324 case vmIntrinsics::_StringBuilder_append_String: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
325 case vmIntrinsics::_StringBuilder_toString: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
326 case vmIntrinsics::_StringBuffer_void: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
327 case vmIntrinsics::_StringBuffer_int: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
328 case vmIntrinsics::_StringBuffer_String: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
329 case vmIntrinsics::_StringBuffer_append_char: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
330 case vmIntrinsics::_StringBuffer_append_int: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
331 case vmIntrinsics::_StringBuffer_append_String: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
332 case vmIntrinsics::_StringBuffer_toString: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
333 case vmIntrinsics::_Integer_toString: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
334 return true; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
335 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
336 case vmIntrinsics::_String_String: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
337 { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
338 Node* receiver = jvms->map()->in(jvms->argoff() + 1); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
339 if (receiver->is_Proj() && receiver->in(0)->is_CallStaticJava()) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
340 CallStaticJavaNode* csj = receiver->in(0)->as_CallStaticJava(); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
341 ciMethod* m = csj->method(); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
342 if (m != NULL && |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
343 (m->intrinsic_id() == vmIntrinsics::_StringBuffer_toString || |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
344 m->intrinsic_id() == vmIntrinsics::_StringBuilder_toString)) |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
345 // Delay String.<init>(new SB()) |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
346 return true; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
347 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
348 return false; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
349 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
350 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
351 default: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
352 return false; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
353 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
354 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
355 return false; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
356 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
844
diff
changeset
|
357 |
| 10278 | 358 bool Compile::should_delay_boxing_inlining(ciMethod* call_method, JVMState* jvms) { |
| 359 if (eliminate_boxing() && call_method->is_boxing_method()) { | |
| 360 set_has_boxed_value(true); | |
| 361 return true; | |
| 362 } | |
| 363 return false; | |
| 364 } | |
| 0 | 365 |
| 366 // uncommon-trap call-sites where callee is unloaded, uninitialized or will not link | |
| 367 bool Parse::can_not_compile_call_site(ciMethod *dest_method, ciInstanceKlass* klass) { | |
| 368 // Additional inputs to consider... | |
| 369 // bc = bc() | |
| 370 // caller = method() | |
| 371 // iter().get_method_holder_index() | |
| 372 assert( dest_method->is_loaded(), "ciTypeFlow should not let us get here" ); | |
| 373 // Interface classes can be loaded & linked and never get around to | |
| 374 // being initialized. Uncommon-trap for not-initialized static or | |
| 375 // v-calls. Let interface calls happen. | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1135
diff
changeset
|
376 ciInstanceKlass* holder_klass = dest_method->holder(); |
|
1645
3941674cc7fa
6958668: repeated uncommon trapping for new of klass which is being initialized
never
parents:
1552
diff
changeset
|
377 if (!holder_klass->is_being_initialized() && |
|
3941674cc7fa
6958668: repeated uncommon trapping for new of klass which is being initialized
never
parents:
1552
diff
changeset
|
378 !holder_klass->is_initialized() && |
| 0 | 379 !holder_klass->is_interface()) { |
| 380 uncommon_trap(Deoptimization::Reason_uninitialized, | |
| 381 Deoptimization::Action_reinterpret, | |
| 382 holder_klass); | |
| 383 return true; | |
| 384 } | |
| 385 | |
| 6973 | 386 assert(dest_method->is_loaded(), "dest_method: typeflow responsibility"); |
| 0 | 387 return false; |
| 388 } | |
| 389 | |
| 390 | |
| 391 //------------------------------do_call---------------------------------------- | |
| 392 // Handle your basic call. Inline if we can & want to, else just setup call. | |
| 393 void Parse::do_call() { | |
| 394 // It's likely we are going to add debug info soon. | |
| 395 // Also, if we inline a guy who eventually needs debug info for this JVMS, | |
| 396 // our contribution to it is cleaned up right here. | |
| 397 kill_dead_locals(); | |
| 398 | |
| 399 // Set frequently used booleans | |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
400 const bool is_virtual = bc() == Bytecodes::_invokevirtual; |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
401 const bool is_virtual_or_interface = is_virtual || bc() == Bytecodes::_invokeinterface; |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
402 const bool has_receiver = Bytecodes::has_receiver(bc()); |
| 0 | 403 |
| 404 // Find target being called | |
| 405 bool will_link; | |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
406 ciSignature* declared_signature = NULL; |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
407 ciMethod* orig_callee = iter().get_method(will_link, &declared_signature); // callee in the bytecode |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
408 ciInstanceKlass* holder_klass = orig_callee->holder(); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
409 ciKlass* holder = iter().get_declared_method_holder(); |
| 0 | 410 ciInstanceKlass* klass = ciEnv::get_instance_klass_for_declared_method_holder(holder); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
411 assert(declared_signature != NULL, "cannot be null"); |
| 0 | 412 |
| 413 // uncommon-trap when callee is unloaded, uninitialized or will not link | |
| 414 // bailout when too many arguments for register representation | |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
415 if (!will_link || can_not_compile_call_site(orig_callee, klass)) { |
| 0 | 416 #ifndef PRODUCT |
| 417 if (PrintOpto && (Verbose || WizardMode)) { | |
| 418 method()->print_name(); tty->print_cr(" can not compile call at bci %d to:", bci()); | |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
419 orig_callee->print_name(); tty->cr(); |
| 0 | 420 } |
| 421 #endif | |
| 422 return; | |
| 423 } | |
| 424 assert(holder_klass->is_loaded(), ""); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
425 //assert((bc_callee->is_static() || is_invokedynamic) == !has_receiver , "must match bc"); // XXX invokehandle (cur_bc_raw) |
| 0 | 426 // Note: this takes into account invokeinterface of methods declared in java/lang/Object, |
| 427 // which should be invokevirtuals but according to the VM spec may be invokeinterfaces | |
| 428 assert(holder_klass->is_interface() || holder_klass->super() == NULL || (bc() != Bytecodes::_invokeinterface), "must match bc"); | |
| 429 // Note: In the absence of miranda methods, an abstract class K can perform | |
| 430 // an invokevirtual directly on an interface method I.m if K implements I. | |
| 431 | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
432 // orig_callee is the resolved callee which's signature includes the |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
433 // appendix argument. |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
434 const int nargs = orig_callee->arg_size(); |
| 7478 | 435 const bool is_signature_polymorphic = MethodHandles::is_signature_polymorphic(orig_callee->intrinsic_id()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
436 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
437 // Push appendix argument (MethodType, CallSite, etc.), if one. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
438 if (iter().has_appendix()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
439 ciObject* appendix_arg = iter().get_appendix(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
440 const TypeOopPtr* appendix_arg_type = TypeOopPtr::make_from_constant(appendix_arg); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
441 Node* appendix_arg_node = _gvn.makecon(appendix_arg_type); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
442 push(appendix_arg_node); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
443 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
444 |
| 0 | 445 // --------------------- |
| 446 // Does Class Hierarchy Analysis reveal only a single target of a v-call? | |
| 447 // Then we may inline or make a static call, but become dependent on there being only 1 target. | |
| 448 // Does the call-site type profile reveal only one receiver? | |
| 449 // Then we may introduce a run-time check and inline on the path where it succeeds. | |
| 450 // The other path may uncommon_trap, check for another receiver, or do a v-call. | |
| 451 | |
| 7478 | 452 // Try to get the most accurate receiver type |
| 453 ciMethod* callee = orig_callee; | |
| 454 int vtable_index = Method::invalid_vtable_index; | |
| 455 bool call_does_dispatch = false; | |
| 0 | 456 |
| 12966 | 457 // Speculative type of the receiver if any |
| 458 ciKlass* speculative_receiver_type = NULL; | |
| 0 | 459 if (is_virtual_or_interface) { |
| 12966 | 460 Node* receiver_node = stack(sp() - nargs); |
| 0 | 461 const TypeOopPtr* receiver_type = _gvn.type(receiver_node)->isa_oopptr(); |
| 7478 | 462 // call_does_dispatch and vtable_index are out-parameters. They might be changed. |
| 463 callee = C->optimize_virtual_call(method(), bci(), klass, orig_callee, receiver_type, | |
| 464 is_virtual, | |
| 465 call_does_dispatch, vtable_index); // out-parameters | |
| 12966 | 466 speculative_receiver_type = receiver_type != NULL ? receiver_type->speculative_type() : NULL; |
| 0 | 467 } |
| 468 | |
| 469 // Note: It's OK to try to inline a virtual call. | |
| 470 // The call generator will not attempt to inline a polymorphic call | |
| 471 // unless it knows how to optimize the receiver dispatch. | |
| 472 bool try_inline = (C->do_inlining() || InlineAccessors); | |
| 473 | |
| 474 // --------------------- | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
475 dec_sp(nargs); // Temporarily pop args for JVM state of call |
| 0 | 476 JVMState* jvms = sync_jvms(); |
| 477 | |
| 478 // --------------------- | |
| 479 // Decide call tactic. | |
| 480 // This call checks with CHA, the interpreter profile, intrinsics table, etc. | |
| 481 // It decides whether inlining is desirable or not. | |
| 12966 | 482 CallGenerator* cg = C->call_generator(callee, vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), speculative_receiver_type); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
483 |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
484 // NOTE: Don't use orig_callee and callee after this point! Use cg->method() instead. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
485 orig_callee = callee = NULL; |
| 0 | 486 |
| 487 // --------------------- | |
| 488 // Round double arguments before call | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
489 round_double_arguments(cg->method()); |
| 0 | 490 |
| 12966 | 491 // Feed profiling data for arguments to the type system so it can |
| 492 // propagate it as speculative types | |
| 493 record_profiled_arguments_for_speculation(cg->method(), bc()); | |
| 494 | |
| 0 | 495 #ifndef PRODUCT |
| 496 // bump global counters for calls | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
497 count_compiled_calls(/*at_method_entry*/ false, cg->is_inline()); |
| 0 | 498 |
| 499 // Record first part of parsing work for this call | |
| 500 parse_histogram()->record_change(); | |
| 501 #endif // not PRODUCT | |
| 502 | |
| 503 assert(jvms == this->jvms(), "still operating on the right JVMS"); | |
| 504 assert(jvms_in_sync(), "jvms must carry full info into CG"); | |
| 505 | |
| 506 // save across call, for a subsequent cast_not_null. | |
| 507 Node* receiver = has_receiver ? argument(0) : NULL; | |
| 508 | |
| 12966 | 509 // The extra CheckCastPP for speculative types mess with PhaseStringOpts |
| 510 if (receiver != NULL && !call_does_dispatch && !cg->is_string_late_inline()) { | |
| 511 // Feed profiling data for a single receiver to the type system so | |
| 512 // it can propagate it as a speculative type | |
| 513 receiver = record_profiled_receiver_for_speculation(receiver); | |
| 514 } | |
| 515 | |
| 0 | 516 // Bump method data counters (We profile *before* the call is made |
| 517 // because exceptions don't return to the call site.) | |
| 518 profile_call(receiver); | |
| 519 | |
|
12956
3213ba4d3dff
8024069: replace_in_map() should operate on parent maps
roland
parents:
12330
diff
changeset
|
520 JVMState* new_jvms = cg->generate(jvms, this); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
521 if (new_jvms == NULL) { |
| 0 | 522 // When inlining attempt fails (e.g., too many arguments), |
| 523 // it may contaminate the current compile state, making it | |
| 524 // impossible to pull back and try again. Once we call | |
| 525 // cg->generate(), we are committed. If it fails, the whole | |
| 526 // compilation task is compromised. | |
| 527 if (failing()) return; | |
|
5927
b40ac3579043
6658428: C2 doesn't inline java method if corresponding intrinsic failed to inline.
never
parents:
4117
diff
changeset
|
528 |
| 0 | 529 // This can happen if a library intrinsic is available, but refuses |
| 530 // the call site, perhaps because it did not match a pattern the | |
|
5927
b40ac3579043
6658428: C2 doesn't inline java method if corresponding intrinsic failed to inline.
never
parents:
4117
diff
changeset
|
531 // intrinsic was expecting to optimize. Should always be possible to |
|
b40ac3579043
6658428: C2 doesn't inline java method if corresponding intrinsic failed to inline.
never
parents:
4117
diff
changeset
|
532 // get a normal java call that may inline in that case |
| 12966 | 533 cg = C->call_generator(cg->method(), vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), speculative_receiver_type, /* allow_intrinsics= */ false); |
|
12956
3213ba4d3dff
8024069: replace_in_map() should operate on parent maps
roland
parents:
12330
diff
changeset
|
534 if ((new_jvms = cg->generate(jvms, this)) == NULL) { |
| 0 | 535 guarantee(failing(), "call failed to generate: calls should work"); |
| 536 return; | |
| 537 } | |
| 538 } | |
| 539 | |
| 540 if (cg->is_inline()) { | |
| 67 | 541 // Accumulate has_loops estimate |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
542 C->set_has_loops(C->has_loops() || cg->method()->has_loops()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
543 C->env()->notice_inlined_method(cg->method()); |
| 0 | 544 } |
| 545 | |
| 546 // Reset parser state from [new_]jvms, which now carries results of the call. | |
| 547 // Return value (if any) is already pushed on the stack by the cg. | |
| 548 add_exception_states_from(new_jvms); | |
| 549 if (new_jvms->map()->control() == top()) { | |
| 550 stop_and_kill_map(); | |
| 551 } else { | |
| 552 assert(new_jvms->same_calls_as(jvms), "method/bci left unchanged"); | |
| 553 set_jvms(new_jvms); | |
| 554 } | |
| 555 | |
| 556 if (!stopped()) { | |
| 557 // This was some sort of virtual call, which did a null check for us. | |
| 558 // Now we can assert receiver-not-null, on the normal return path. | |
| 559 if (receiver != NULL && cg->is_virtual()) { | |
| 560 Node* cast = cast_not_null(receiver); | |
| 561 // %%% assert(receiver == cast, "should already have cast the receiver"); | |
| 562 } | |
| 563 | |
| 564 // Round double result after a call from strict to non-strict code | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
565 round_double_result(cg->method()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
566 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
567 ciType* rtype = cg->method()->return_type(); |
| 7478 | 568 ciType* ctype = declared_signature->return_type(); |
| 569 | |
| 570 if (Bytecodes::has_optional_appendix(iter().cur_bc_raw()) || is_signature_polymorphic) { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
571 // Be careful here with return types. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
572 if (ctype != rtype) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
573 BasicType rt = rtype->basic_type(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
574 BasicType ct = ctype->basic_type(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
575 if (ct == T_VOID) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
576 // It's OK for a method to return a value that is discarded. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
577 // The discarding does not require any special action from the caller. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
578 // The Java code knows this, at VerifyType.isNullConversion. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
579 pop_node(rt); // whatever it was, pop it |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
580 } else if (rt == T_INT || is_subword_type(rt)) { |
| 7478 | 581 // Nothing. These cases are handled in lambda form bytecode. |
| 582 assert(ct == T_INT || is_subword_type(ct), err_msg_res("must match: rt=%s, ct=%s", type2name(rt), type2name(ct))); | |
|
6270
b72784e722ff
7188276: JSR 292: assert(ct == T_OBJECT) failed: rt=T_OBJECT, ct=13
twisti
parents:
6268
diff
changeset
|
583 } else if (rt == T_OBJECT || rt == T_ARRAY) { |
|
b72784e722ff
7188276: JSR 292: assert(ct == T_OBJECT) failed: rt=T_OBJECT, ct=13
twisti
parents:
6268
diff
changeset
|
584 assert(ct == T_OBJECT || ct == T_ARRAY, err_msg_res("rt=%s, ct=%s", type2name(rt), type2name(ct))); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
585 if (ctype->is_loaded()) { |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
586 const TypeOopPtr* arg_type = TypeOopPtr::make_from_klass(rtype->as_klass()); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
587 const Type* sig_type = TypeOopPtr::make_from_klass(ctype->as_klass()); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
588 if (arg_type != NULL && !arg_type->higher_equal(sig_type)) { |
| 7478 | 589 Node* retnode = pop(); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
590 Node* cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(), retnode, sig_type)); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6270
diff
changeset
|
591 push(cast_obj); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
592 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
593 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
594 } else { |
| 7478 | 595 assert(rt == ct, err_msg_res("unexpected mismatch: rt=%s, ct=%s", type2name(rt), type2name(ct))); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
596 // push a zero; it's better than getting an oop/int mismatch |
| 7478 | 597 pop_node(rt); |
| 598 Node* retnode = zerocon(ct); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
599 push_node(ct, retnode); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
600 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
601 // Now that the value is well-behaved, continue with the call-site type. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
602 rtype = ctype; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
603 } |
| 7478 | 604 } else { |
|
7604
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
605 // Symbolic resolution enforces the types to be the same. |
|
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
606 // NOTE: We must relax the assert for unloaded types because two |
|
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
607 // different ciType instances of the same unloaded class type |
|
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
608 // can appear to be "loaded" by different loaders (depending on |
|
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
609 // the accessing class). |
|
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
610 assert(!rtype->is_loaded() || !ctype->is_loaded() || rtype == ctype, |
|
f1de9dbc914e
8006109: test/java/util/AbstractSequentialList/AddAll.java fails: assert(rtype == ctype) failed: mismatched return types
twisti
parents:
7478
diff
changeset
|
611 err_msg_res("mismatched return types: rtype=%s, ctype=%s", rtype->name(), ctype->name())); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
612 } |
| 0 | 613 |
| 614 // If the return type of the method is not loaded, assert that the | |
| 615 // value we got is a null. Otherwise, we need to recompile. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
616 if (!rtype->is_loaded()) { |
| 0 | 617 #ifndef PRODUCT |
| 618 if (PrintOpto && (Verbose || WizardMode)) { | |
| 619 method()->print_name(); tty->print_cr(" asserting nullness of result at bci: %d", bci()); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
620 cg->method()->print_name(); tty->cr(); |
| 0 | 621 } |
| 622 #endif | |
| 623 if (C->log() != NULL) { | |
| 624 C->log()->elem("assert_null reason='return' klass='%d'", | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6086
diff
changeset
|
625 C->log()->identify(rtype)); |
| 0 | 626 } |
| 627 // If there is going to be a trap, put it at the next bytecode: | |
| 628 set_bci(iter().next_bci()); | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
629 null_assert(peek()); |
| 0 | 630 set_bci(iter().cur_bci()); // put it back |
| 631 } | |
| 12966 | 632 BasicType ct = ctype->basic_type(); |
| 633 if (ct == T_OBJECT || ct == T_ARRAY) { | |
| 634 ciKlass* better_type = method()->return_profiled_type(bci()); | |
| 635 if (UseTypeSpeculation && better_type != NULL) { | |
| 636 // If profiling reports a single type for the return value, | |
| 637 // feed it to the type system so it can propagate it as a | |
| 638 // speculative type | |
| 639 record_profile_for_speculation(stack(sp()-1), better_type); | |
| 640 } | |
| 641 } | |
| 0 | 642 } |
| 643 | |
| 644 // Restart record of parsing work after possible inlining of call | |
| 645 #ifndef PRODUCT | |
| 646 parse_histogram()->set_initial_state(bc()); | |
| 647 #endif | |
| 648 } | |
| 649 | |
| 650 //---------------------------catch_call_exceptions----------------------------- | |
| 651 // Put a Catch and CatchProj nodes behind a just-created call. | |
| 652 // Send their caught exceptions to the proper handler. | |
| 653 // This may be used after a call to the rethrow VM stub, | |
| 654 // when it is needed to process unloaded exception classes. | |
| 655 void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) { | |
| 656 // Exceptions are delivered through this channel: | |
| 657 Node* i_o = this->i_o(); | |
| 658 | |
| 659 // Add a CatchNode. | |
| 660 GrowableArray<int>* bcis = new (C->node_arena()) GrowableArray<int>(C->node_arena(), 8, 0, -1); | |
| 661 GrowableArray<const Type*>* extypes = new (C->node_arena()) GrowableArray<const Type*>(C->node_arena(), 8, 0, NULL); | |
| 662 GrowableArray<int>* saw_unloaded = new (C->node_arena()) GrowableArray<int>(C->node_arena(), 8, 0, 0); | |
| 663 | |
| 664 for (; !handlers.is_done(); handlers.next()) { | |
| 665 ciExceptionHandler* h = handlers.handler(); | |
| 666 int h_bci = h->handler_bci(); | |
| 667 ciInstanceKlass* h_klass = h->is_catch_all() ? env()->Throwable_klass() : h->catch_klass(); | |
| 668 // Do not introduce unloaded exception types into the graph: | |
| 669 if (!h_klass->is_loaded()) { | |
| 670 if (saw_unloaded->contains(h_bci)) { | |
| 671 /* We've already seen an unloaded exception with h_bci, | |
| 672 so don't duplicate. Duplication will cause the CatchNode to be | |
| 673 unnecessarily large. See 4713716. */ | |
| 674 continue; | |
| 675 } else { | |
| 676 saw_unloaded->append(h_bci); | |
| 677 } | |
| 678 } | |
| 679 const Type* h_extype = TypeOopPtr::make_from_klass(h_klass); | |
| 680 // (We use make_from_klass because it respects UseUniqueSubclasses.) | |
| 681 h_extype = h_extype->join(TypeInstPtr::NOTNULL); | |
| 682 assert(!h_extype->empty(), "sanity"); | |
| 683 // Note: It's OK if the BCIs repeat themselves. | |
| 684 bcis->append(h_bci); | |
| 685 extypes->append(h_extype); | |
| 686 } | |
| 687 | |
| 688 int len = bcis->length(); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
689 CatchNode *cn = new (C) CatchNode(control(), i_o, len+1); |
| 0 | 690 Node *catch_ = _gvn.transform(cn); |
| 691 | |
| 692 // now branch with the exception state to each of the (potential) | |
| 693 // handlers | |
| 694 for(int i=0; i < len; i++) { | |
| 695 // Setup JVM state to enter the handler. | |
| 696 PreserveJVMState pjvms(this); | |
| 697 // Locals are just copied from before the call. | |
| 698 // Get control from the CatchNode. | |
| 699 int handler_bci = bcis->at(i); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
700 Node* ctrl = _gvn.transform( new (C) CatchProjNode(catch_, i+1,handler_bci)); |
| 0 | 701 // This handler cannot happen? |
| 702 if (ctrl == top()) continue; | |
| 703 set_control(ctrl); | |
| 704 | |
| 705 // Create exception oop | |
| 706 const TypeInstPtr* extype = extypes->at(i)->is_instptr(); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
707 Node *ex_oop = _gvn.transform(new (C) CreateExNode(extypes->at(i), ctrl, i_o)); |
| 0 | 708 |
| 709 // Handle unloaded exception classes. | |
| 710 if (saw_unloaded->contains(handler_bci)) { | |
| 711 // An unloaded exception type is coming here. Do an uncommon trap. | |
| 712 #ifndef PRODUCT | |
| 713 // We do not expect the same handler bci to take both cold unloaded | |
| 714 // and hot loaded exceptions. But, watch for it. | |
|
6267
977007096840
7187290: nightly failures after JSR 292 lazy method handle update
twisti
parents:
6266
diff
changeset
|
715 if ((Verbose || WizardMode) && extype->is_loaded()) { |
|
977007096840
7187290: nightly failures after JSR 292 lazy method handle update
twisti
parents:
6266
diff
changeset
|
716 tty->print("Warning: Handler @%d takes mixed loaded/unloaded exceptions in ", bci()); |
| 0 | 717 method()->print_name(); tty->cr(); |
| 718 } else if (PrintOpto && (Verbose || WizardMode)) { | |
| 719 tty->print("Bailing out on unloaded exception type "); | |
| 720 extype->klass()->print_name(); | |
| 721 tty->print(" at bci:%d in ", bci()); | |
| 722 method()->print_name(); tty->cr(); | |
| 723 } | |
| 724 #endif | |
| 725 // Emit an uncommon trap instead of processing the block. | |
| 726 set_bci(handler_bci); | |
| 727 push_ex_oop(ex_oop); | |
| 728 uncommon_trap(Deoptimization::Reason_unloaded, | |
| 729 Deoptimization::Action_reinterpret, | |
| 730 extype->klass(), "!loaded exception"); | |
| 731 set_bci(iter().cur_bci()); // put it back | |
| 732 continue; | |
| 733 } | |
| 734 | |
| 735 // go to the exception handler | |
| 736 if (handler_bci < 0) { // merge with corresponding rethrow node | |
| 737 throw_to_exit(make_exception_state(ex_oop)); | |
| 738 } else { // Else jump to corresponding handle | |
| 739 push_ex_oop(ex_oop); // Clear stack and push just the oop. | |
| 740 merge_exception(handler_bci); | |
| 741 } | |
| 742 } | |
| 743 | |
| 744 // The first CatchProj is for the normal return. | |
| 745 // (Note: If this is a call to rethrow_Java, this node goes dead.) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
746 set_control(_gvn.transform( new (C) CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci))); |
| 0 | 747 } |
| 748 | |
| 749 | |
| 750 //----------------------------catch_inline_exceptions-------------------------- | |
| 751 // Handle all exceptions thrown by an inlined method or individual bytecode. | |
| 752 // Common case 1: we have no handler, so all exceptions merge right into | |
| 753 // the rethrow case. | |
| 754 // Case 2: we have some handlers, with loaded exception klasses that have | |
| 755 // no subklasses. We do a Deutsch-Shiffman style type-check on the incoming | |
| 756 // exception oop and branch to the handler directly. | |
| 757 // Case 3: We have some handlers with subklasses or are not loaded at | |
| 758 // compile-time. We have to call the runtime to resolve the exception. | |
| 759 // So we insert a RethrowCall and all the logic that goes with it. | |
| 760 void Parse::catch_inline_exceptions(SafePointNode* ex_map) { | |
| 761 // Caller is responsible for saving away the map for normal control flow! | |
| 762 assert(stopped(), "call set_map(NULL) first"); | |
| 763 assert(method()->has_exception_handlers(), "don't come here w/o work to do"); | |
| 764 | |
| 765 Node* ex_node = saved_ex_oop(ex_map); | |
| 766 if (ex_node == top()) { | |
| 767 // No action needed. | |
| 768 return; | |
| 769 } | |
| 770 const TypeInstPtr* ex_type = _gvn.type(ex_node)->isa_instptr(); | |
| 771 NOT_PRODUCT(if (ex_type==NULL) tty->print_cr("*** Exception not InstPtr")); | |
| 772 if (ex_type == NULL) | |
| 773 ex_type = TypeOopPtr::make_from_klass(env()->Throwable_klass())->is_instptr(); | |
| 774 | |
| 775 // determine potential exception handlers | |
| 776 ciExceptionHandlerStream handlers(method(), bci(), | |
| 777 ex_type->klass()->as_instance_klass(), | |
| 778 ex_type->klass_is_exact()); | |
| 779 | |
| 780 // Start executing from the given throw state. (Keep its stack, for now.) | |
| 781 // Get the exception oop as known at compile time. | |
| 782 ex_node = use_exception_state(ex_map); | |
| 783 | |
| 784 // Get the exception oop klass from its header | |
| 785 Node* ex_klass_node = NULL; | |
| 786 if (has_ex_handler() && !ex_type->klass_is_exact()) { | |
| 787 Node* p = basic_plus_adr( ex_node, ex_node, oopDesc::klass_offset_in_bytes()); | |
|
164
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
67
diff
changeset
|
788 ex_klass_node = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeInstPtr::KLASS, TypeKlassPtr::OBJECT) ); |
| 0 | 789 |
| 790 // Compute the exception klass a little more cleverly. | |
| 791 // Obvious solution is to simple do a LoadKlass from the 'ex_node'. | |
| 792 // However, if the ex_node is a PhiNode, I'm going to do a LoadKlass for | |
| 793 // each arm of the Phi. If I know something clever about the exceptions | |
| 794 // I'm loading the class from, I can replace the LoadKlass with the | |
| 795 // klass constant for the exception oop. | |
| 796 if( ex_node->is_Phi() ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
797 ex_klass_node = new (C) PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT ); |
| 0 | 798 for( uint i = 1; i < ex_node->req(); i++ ) { |
| 799 Node* p = basic_plus_adr( ex_node->in(i), ex_node->in(i), oopDesc::klass_offset_in_bytes() ); | |
|
164
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
67
diff
changeset
|
800 Node* k = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeInstPtr::KLASS, TypeKlassPtr::OBJECT) ); |
| 0 | 801 ex_klass_node->init_req( i, k ); |
| 802 } | |
| 803 _gvn.set_type(ex_klass_node, TypeKlassPtr::OBJECT); | |
| 804 | |
| 805 } | |
| 806 } | |
| 807 | |
| 808 // Scan the exception table for applicable handlers. | |
| 809 // If none, we can call rethrow() and be done! | |
| 810 // If precise (loaded with no subklasses), insert a D.S. style | |
| 811 // pointer compare to the correct handler and loop back. | |
| 812 // If imprecise, switch to the Rethrow VM-call style handling. | |
| 813 | |
| 814 int remaining = handlers.count_remaining(); | |
| 815 | |
| 816 // iterate through all entries sequentially | |
| 817 for (;!handlers.is_done(); handlers.next()) { | |
| 818 ciExceptionHandler* handler = handlers.handler(); | |
| 819 | |
| 820 if (handler->is_rethrow()) { | |
| 821 // If we fell off the end of the table without finding an imprecise | |
| 822 // exception klass (and without finding a generic handler) then we | |
| 823 // know this exception is not handled in this method. We just rethrow | |
| 824 // the exception into the caller. | |
| 825 throw_to_exit(make_exception_state(ex_node)); | |
| 826 return; | |
| 827 } | |
| 828 | |
| 829 // exception handler bci range covers throw_bci => investigate further | |
| 830 int handler_bci = handler->handler_bci(); | |
| 831 | |
| 832 if (remaining == 1) { | |
| 833 push_ex_oop(ex_node); // Push exception oop for handler | |
| 834 #ifndef PRODUCT | |
| 835 if (PrintOpto && WizardMode) { | |
| 836 tty->print_cr(" Catching every inline exception bci:%d -> handler_bci:%d", bci(), handler_bci); | |
| 837 } | |
| 838 #endif | |
| 839 merge_exception(handler_bci); // jump to handler | |
| 840 return; // No more handling to be done here! | |
| 841 } | |
| 842 | |
| 1344 | 843 // Get the handler's klass |
| 0 | 844 ciInstanceKlass* klass = handler->catch_klass(); |
| 1344 | 845 |
| 846 if (!klass->is_loaded()) { // klass is not loaded? | |
| 847 // fall through into catch_call_exceptions which will emit a | |
| 848 // handler with an uncommon trap. | |
| 849 break; | |
| 0 | 850 } |
| 851 | |
| 852 if (klass->is_interface()) // should not happen, but... | |
| 853 break; // bail out | |
| 854 | |
| 1344 | 855 // Check the type of the exception against the catch type |
| 0 | 856 const TypeKlassPtr *tk = TypeKlassPtr::make(klass); |
| 857 Node* con = _gvn.makecon(tk); | |
| 1344 | 858 Node* not_subtype_ctrl = gen_subtype_check(ex_klass_node, con); |
| 859 if (!stopped()) { | |
| 860 PreserveJVMState pjvms(this); | |
| 861 const TypeInstPtr* tinst = TypeOopPtr::make_from_klass_unique(klass)->cast_to_ptr_type(TypePtr::NotNull)->is_instptr(); | |
| 862 assert(klass->has_subklass() || tinst->klass_is_exact(), "lost exactness"); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6793
diff
changeset
|
863 Node* ex_oop = _gvn.transform(new (C) CheckCastPPNode(control(), ex_node, tinst)); |
| 0 | 864 push_ex_oop(ex_oop); // Push exception oop for handler |
| 865 #ifndef PRODUCT | |
| 866 if (PrintOpto && WizardMode) { | |
| 867 tty->print(" Catching inline exception bci:%d -> handler_bci:%d -- ", bci(), handler_bci); | |
| 868 klass->print_name(); | |
| 869 tty->cr(); | |
| 870 } | |
| 871 #endif | |
| 872 merge_exception(handler_bci); | |
| 873 } | |
| 1344 | 874 set_control(not_subtype_ctrl); |
| 0 | 875 |
| 876 // Come here if exception does not match handler. | |
| 877 // Carry on with more handler checks. | |
| 878 --remaining; | |
| 879 } | |
| 880 | |
| 881 assert(!stopped(), "you should return if you finish the chain"); | |
| 882 | |
| 883 // Oops, need to call into the VM to resolve the klasses at runtime. | |
| 884 // Note: This call must not deoptimize, since it is not a real at this bci! | |
| 885 kill_dead_locals(); | |
| 886 | |
| 887 make_runtime_call(RC_NO_LEAF | RC_MUST_THROW, | |
| 888 OptoRuntime::rethrow_Type(), | |
| 889 OptoRuntime::rethrow_stub(), | |
| 890 NULL, NULL, | |
| 891 ex_node); | |
| 892 | |
| 893 // Rethrow is a pure call, no side effects, only a result. | |
| 894 // The result cannot be allocated, so we use I_O | |
| 895 | |
| 896 // Catch exceptions from the rethrow | |
| 897 catch_call_exceptions(handlers); | |
| 898 } | |
| 899 | |
| 900 | |
| 901 // (Note: Moved add_debug_info into GraphKit::add_safepoint_edges.) | |
| 902 | |
| 903 | |
| 904 #ifndef PRODUCT | |
| 905 void Parse::count_compiled_calls(bool at_method_entry, bool is_inline) { | |
| 906 if( CountCompiledCalls ) { | |
| 907 if( at_method_entry ) { | |
| 908 // bump invocation counter if top method (for statistics) | |
| 909 if (CountCompiledCalls && depth() == 1) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
910 const TypePtr* addr_type = TypeMetadataPtr::make(method()); |
| 0 | 911 Node* adr1 = makecon(addr_type); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
912 Node* adr2 = basic_plus_adr(adr1, adr1, in_bytes(Method::compiled_invocation_counter_offset())); |
| 0 | 913 increment_counter(adr2); |
| 914 } | |
| 915 } else if (is_inline) { | |
| 916 switch (bc()) { | |
| 917 case Bytecodes::_invokevirtual: increment_counter(SharedRuntime::nof_inlined_calls_addr()); break; | |
| 918 case Bytecodes::_invokeinterface: increment_counter(SharedRuntime::nof_inlined_interface_calls_addr()); break; | |
| 919 case Bytecodes::_invokestatic: | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
367
diff
changeset
|
920 case Bytecodes::_invokedynamic: |
| 0 | 921 case Bytecodes::_invokespecial: increment_counter(SharedRuntime::nof_inlined_static_calls_addr()); break; |
| 922 default: fatal("unexpected call bytecode"); | |
| 923 } | |
| 924 } else { | |
| 925 switch (bc()) { | |
| 926 case Bytecodes::_invokevirtual: increment_counter(SharedRuntime::nof_normal_calls_addr()); break; | |
| 927 case Bytecodes::_invokeinterface: increment_counter(SharedRuntime::nof_interface_calls_addr()); break; | |
| 928 case Bytecodes::_invokestatic: | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
367
diff
changeset
|
929 case Bytecodes::_invokedynamic: |
| 0 | 930 case Bytecodes::_invokespecial: increment_counter(SharedRuntime::nof_static_calls_addr()); break; |
| 931 default: fatal("unexpected call bytecode"); | |
| 932 } | |
| 933 } | |
| 934 } | |
| 935 } | |
| 936 #endif //PRODUCT | |
| 937 | |
| 938 | |
| 7478 | 939 ciMethod* Compile::optimize_virtual_call(ciMethod* caller, int bci, ciInstanceKlass* klass, |
| 940 ciMethod* callee, const TypeOopPtr* receiver_type, | |
| 941 bool is_virtual, | |
| 942 bool& call_does_dispatch, int& vtable_index) { | |
| 943 // Set default values for out-parameters. | |
| 944 call_does_dispatch = true; | |
| 945 vtable_index = Method::invalid_vtable_index; | |
| 946 | |
| 947 // Choose call strategy. | |
| 948 ciMethod* optimized_virtual_method = optimize_inlining(caller, bci, klass, callee, receiver_type); | |
| 949 | |
| 950 // Have the call been sufficiently improved such that it is no longer a virtual? | |
| 951 if (optimized_virtual_method != NULL) { | |
| 952 callee = optimized_virtual_method; | |
| 953 call_does_dispatch = false; | |
| 954 } else if (!UseInlineCaches && is_virtual && callee->is_loaded()) { | |
| 955 // We can make a vtable call at this site | |
| 956 vtable_index = callee->resolve_vtable_index(caller->holder(), klass); | |
| 957 } | |
| 958 return callee; | |
| 959 } | |
| 960 | |
| 0 | 961 // Identify possible target method and inlining style |
| 7478 | 962 ciMethod* Compile::optimize_inlining(ciMethod* caller, int bci, ciInstanceKlass* klass, |
| 963 ciMethod* callee, const TypeOopPtr* receiver_type) { | |
| 0 | 964 // only use for virtual or interface calls |
| 965 | |
| 966 // If it is obviously final, do not bother to call find_monomorphic_target, | |
| 967 // because the class hierarchy checks are not needed, and may fail due to | |
| 968 // incompletely loaded classes. Since we do our own class loading checks | |
| 969 // in this module, we may confidently bind to any method. | |
| 7478 | 970 if (callee->can_be_statically_bound()) { |
| 971 return callee; | |
| 0 | 972 } |
| 973 | |
| 974 // Attempt to improve the receiver | |
| 975 bool actual_receiver_is_exact = false; | |
| 976 ciInstanceKlass* actual_receiver = klass; | |
| 977 if (receiver_type != NULL) { | |
| 978 // Array methods are all inherited from Object, and are monomorphic. | |
| 979 if (receiver_type->isa_aryptr() && | |
| 7478 | 980 callee->holder() == env()->Object_klass()) { |
| 981 return callee; | |
| 0 | 982 } |
| 983 | |
| 984 // All other interesting cases are instance klasses. | |
| 985 if (!receiver_type->isa_instptr()) { | |
| 986 return NULL; | |
| 987 } | |
| 988 | |
| 989 ciInstanceKlass *ikl = receiver_type->klass()->as_instance_klass(); | |
| 990 if (ikl->is_loaded() && ikl->is_initialized() && !ikl->is_interface() && | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
991 (ikl == actual_receiver || ikl->is_subtype_of(actual_receiver))) { |
| 0 | 992 // ikl is a same or better type than the original actual_receiver, |
| 993 // e.g. static receiver from bytecodes. | |
| 994 actual_receiver = ikl; | |
| 995 // Is the actual_receiver exact? | |
| 996 actual_receiver_is_exact = receiver_type->klass_is_exact(); | |
| 997 } | |
| 998 } | |
| 999 | |
| 1000 ciInstanceKlass* calling_klass = caller->holder(); | |
| 7478 | 1001 ciMethod* cha_monomorphic_target = callee->find_monomorphic_target(calling_klass, klass, actual_receiver); |
| 0 | 1002 if (cha_monomorphic_target != NULL) { |
| 1003 assert(!cha_monomorphic_target->is_abstract(), ""); | |
| 1004 // Look at the method-receiver type. Does it add "too much information"? | |
| 1005 ciKlass* mr_klass = cha_monomorphic_target->holder(); | |
| 1006 const Type* mr_type = TypeInstPtr::make(TypePtr::BotPTR, mr_klass); | |
| 1007 if (receiver_type == NULL || !receiver_type->higher_equal(mr_type)) { | |
| 1008 // Calling this method would include an implicit cast to its holder. | |
| 1009 // %%% Not yet implemented. Would throw minor asserts at present. | |
| 1010 // %%% The most common wins are already gained by +UseUniqueSubclasses. | |
| 1011 // To fix, put the higher_equal check at the call of this routine, | |
| 1012 // and add a CheckCastPP to the receiver. | |
| 1013 if (TraceDependencies) { | |
| 1014 tty->print_cr("found unique CHA method, but could not cast up"); | |
| 1015 tty->print(" method = "); | |
| 1016 cha_monomorphic_target->print(); | |
| 1017 tty->cr(); | |
| 1018 } | |
| 7478 | 1019 if (log() != NULL) { |
| 1020 log()->elem("missed_CHA_opportunity klass='%d' method='%d'", | |
| 1021 log()->identify(klass), | |
| 1022 log()->identify(cha_monomorphic_target)); | |
| 0 | 1023 } |
| 1024 cha_monomorphic_target = NULL; | |
| 1025 } | |
| 1026 } | |
| 1027 if (cha_monomorphic_target != NULL) { | |
| 1028 // Hardwiring a virtual. | |
| 1029 // If we inlined because CHA revealed only a single target method, | |
| 1030 // then we are dependent on that target method not getting overridden | |
| 1031 // by dynamic class loading. Be sure to test the "static" receiver | |
| 1032 // dest_method here, as opposed to the actual receiver, which may | |
| 1033 // falsely lead us to believe that the receiver is final or private. | |
| 7478 | 1034 dependencies()->assert_unique_concrete_method(actual_receiver, cha_monomorphic_target); |
| 0 | 1035 return cha_monomorphic_target; |
| 1036 } | |
| 1037 | |
| 1038 // If the type is exact, we can still bind the method w/o a vcall. | |
| 1039 // (This case comes after CHA so we can see how much extra work it does.) | |
| 1040 if (actual_receiver_is_exact) { | |
| 1041 // In case of evolution, there is a dependence on every inlined method, since each | |
| 1042 // such method can be changed when its class is redefined. | |
| 7478 | 1043 ciMethod* exact_method = callee->resolve_invoke(calling_klass, actual_receiver); |
| 0 | 1044 if (exact_method != NULL) { |
| 1045 #ifndef PRODUCT | |
| 1046 if (PrintOpto) { | |
| 1047 tty->print(" Calling method via exact type @%d --- ", bci); | |
| 1048 exact_method->print_name(); | |
| 1049 tty->cr(); | |
| 1050 } | |
| 1051 #endif | |
| 1052 return exact_method; | |
| 1053 } | |
| 1054 } | |
| 1055 | |
| 1056 return NULL; | |
| 1057 } |