Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/sharedRuntime.cpp @ 452:00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery.
Reviewed-by: apetrusenko, jcoomes
| author | ysr |
|---|---|
| date | Thu, 20 Nov 2008 12:27:41 -0800 |
| parents | 1ee8caae33af |
| children | dc16daa0329d |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 1997-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 #include "incls/_precompiled.incl" | |
| 26 #include "incls/_sharedRuntime.cpp.incl" | |
| 27 #include <math.h> | |
| 28 | |
| 29 HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t); | |
| 30 HS_DTRACE_PROBE_DECL7(hotspot, method__entry, int, | |
| 31 char*, int, char*, int, char*, int); | |
| 32 HS_DTRACE_PROBE_DECL7(hotspot, method__return, int, | |
| 33 char*, int, char*, int, char*, int); | |
| 34 | |
| 35 // Implementation of SharedRuntime | |
| 36 | |
| 37 #ifndef PRODUCT | |
| 38 // For statistics | |
| 39 int SharedRuntime::_ic_miss_ctr = 0; | |
| 40 int SharedRuntime::_wrong_method_ctr = 0; | |
| 41 int SharedRuntime::_resolve_static_ctr = 0; | |
| 42 int SharedRuntime::_resolve_virtual_ctr = 0; | |
| 43 int SharedRuntime::_resolve_opt_virtual_ctr = 0; | |
| 44 int SharedRuntime::_implicit_null_throws = 0; | |
| 45 int SharedRuntime::_implicit_div0_throws = 0; | |
| 46 int SharedRuntime::_throw_null_ctr = 0; | |
| 47 | |
| 48 int SharedRuntime::_nof_normal_calls = 0; | |
| 49 int SharedRuntime::_nof_optimized_calls = 0; | |
| 50 int SharedRuntime::_nof_inlined_calls = 0; | |
| 51 int SharedRuntime::_nof_megamorphic_calls = 0; | |
| 52 int SharedRuntime::_nof_static_calls = 0; | |
| 53 int SharedRuntime::_nof_inlined_static_calls = 0; | |
| 54 int SharedRuntime::_nof_interface_calls = 0; | |
| 55 int SharedRuntime::_nof_optimized_interface_calls = 0; | |
| 56 int SharedRuntime::_nof_inlined_interface_calls = 0; | |
| 57 int SharedRuntime::_nof_megamorphic_interface_calls = 0; | |
| 58 int SharedRuntime::_nof_removable_exceptions = 0; | |
| 59 | |
| 60 int SharedRuntime::_new_instance_ctr=0; | |
| 61 int SharedRuntime::_new_array_ctr=0; | |
| 62 int SharedRuntime::_multi1_ctr=0; | |
| 63 int SharedRuntime::_multi2_ctr=0; | |
| 64 int SharedRuntime::_multi3_ctr=0; | |
| 65 int SharedRuntime::_multi4_ctr=0; | |
| 66 int SharedRuntime::_multi5_ctr=0; | |
| 67 int SharedRuntime::_mon_enter_stub_ctr=0; | |
| 68 int SharedRuntime::_mon_exit_stub_ctr=0; | |
| 69 int SharedRuntime::_mon_enter_ctr=0; | |
| 70 int SharedRuntime::_mon_exit_ctr=0; | |
| 71 int SharedRuntime::_partial_subtype_ctr=0; | |
| 72 int SharedRuntime::_jbyte_array_copy_ctr=0; | |
| 73 int SharedRuntime::_jshort_array_copy_ctr=0; | |
| 74 int SharedRuntime::_jint_array_copy_ctr=0; | |
| 75 int SharedRuntime::_jlong_array_copy_ctr=0; | |
| 76 int SharedRuntime::_oop_array_copy_ctr=0; | |
| 77 int SharedRuntime::_checkcast_array_copy_ctr=0; | |
| 78 int SharedRuntime::_unsafe_array_copy_ctr=0; | |
| 79 int SharedRuntime::_generic_array_copy_ctr=0; | |
| 80 int SharedRuntime::_slow_array_copy_ctr=0; | |
| 81 int SharedRuntime::_find_handler_ctr=0; | |
| 82 int SharedRuntime::_rethrow_ctr=0; | |
| 83 | |
| 84 int SharedRuntime::_ICmiss_index = 0; | |
| 85 int SharedRuntime::_ICmiss_count[SharedRuntime::maxICmiss_count]; | |
| 86 address SharedRuntime::_ICmiss_at[SharedRuntime::maxICmiss_count]; | |
| 87 | |
| 88 void SharedRuntime::trace_ic_miss(address at) { | |
| 89 for (int i = 0; i < _ICmiss_index; i++) { | |
| 90 if (_ICmiss_at[i] == at) { | |
| 91 _ICmiss_count[i]++; | |
| 92 return; | |
| 93 } | |
| 94 } | |
| 95 int index = _ICmiss_index++; | |
| 96 if (_ICmiss_index >= maxICmiss_count) _ICmiss_index = maxICmiss_count - 1; | |
| 97 _ICmiss_at[index] = at; | |
| 98 _ICmiss_count[index] = 1; | |
| 99 } | |
| 100 | |
| 101 void SharedRuntime::print_ic_miss_histogram() { | |
| 102 if (ICMissHistogram) { | |
| 103 tty->print_cr ("IC Miss Histogram:"); | |
| 104 int tot_misses = 0; | |
| 105 for (int i = 0; i < _ICmiss_index; i++) { | |
| 106 tty->print_cr(" at: " INTPTR_FORMAT " nof: %d", _ICmiss_at[i], _ICmiss_count[i]); | |
| 107 tot_misses += _ICmiss_count[i]; | |
| 108 } | |
| 109 tty->print_cr ("Total IC misses: %7d", tot_misses); | |
| 110 } | |
| 111 } | |
| 112 #endif // PRODUCT | |
| 113 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
114 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
115 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
116 // G1 write-barrier pre: executed before a pointer store. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
117 JRT_LEAF(void, SharedRuntime::g1_wb_pre(oopDesc* orig, JavaThread *thread)) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
118 if (orig == NULL) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
119 assert(false, "should be optimized out"); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
120 return; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
121 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
122 // store the original value that was in the field reference |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
123 thread->satb_mark_queue().enqueue(orig); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
124 JRT_END |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
125 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
126 // G1 write-barrier post: executed after a pointer store. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
127 JRT_LEAF(void, SharedRuntime::g1_wb_post(void* card_addr, JavaThread* thread)) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
128 thread->dirty_card_queue().enqueue(card_addr); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
129 JRT_END |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
130 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
131 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
132 |
| 0 | 133 |
| 134 JRT_LEAF(jlong, SharedRuntime::lmul(jlong y, jlong x)) | |
| 135 return x * y; | |
| 136 JRT_END | |
| 137 | |
| 138 | |
| 139 JRT_LEAF(jlong, SharedRuntime::ldiv(jlong y, jlong x)) | |
| 140 if (x == min_jlong && y == CONST64(-1)) { | |
| 141 return x; | |
| 142 } else { | |
| 143 return x / y; | |
| 144 } | |
| 145 JRT_END | |
| 146 | |
| 147 | |
| 148 JRT_LEAF(jlong, SharedRuntime::lrem(jlong y, jlong x)) | |
| 149 if (x == min_jlong && y == CONST64(-1)) { | |
| 150 return 0; | |
| 151 } else { | |
| 152 return x % y; | |
| 153 } | |
| 154 JRT_END | |
| 155 | |
| 156 | |
| 157 const juint float_sign_mask = 0x7FFFFFFF; | |
| 158 const juint float_infinity = 0x7F800000; | |
| 159 const julong double_sign_mask = CONST64(0x7FFFFFFFFFFFFFFF); | |
| 160 const julong double_infinity = CONST64(0x7FF0000000000000); | |
| 161 | |
| 162 JRT_LEAF(jfloat, SharedRuntime::frem(jfloat x, jfloat y)) | |
| 163 #ifdef _WIN64 | |
| 164 // 64-bit Windows on amd64 returns the wrong values for | |
| 165 // infinity operands. | |
| 166 union { jfloat f; juint i; } xbits, ybits; | |
| 167 xbits.f = x; | |
| 168 ybits.f = y; | |
| 169 // x Mod Infinity == x unless x is infinity | |
| 170 if ( ((xbits.i & float_sign_mask) != float_infinity) && | |
| 171 ((ybits.i & float_sign_mask) == float_infinity) ) { | |
| 172 return x; | |
| 173 } | |
| 174 #endif | |
| 175 return ((jfloat)fmod((double)x,(double)y)); | |
| 176 JRT_END | |
| 177 | |
| 178 | |
| 179 JRT_LEAF(jdouble, SharedRuntime::drem(jdouble x, jdouble y)) | |
| 180 #ifdef _WIN64 | |
| 181 union { jdouble d; julong l; } xbits, ybits; | |
| 182 xbits.d = x; | |
| 183 ybits.d = y; | |
| 184 // x Mod Infinity == x unless x is infinity | |
| 185 if ( ((xbits.l & double_sign_mask) != double_infinity) && | |
| 186 ((ybits.l & double_sign_mask) == double_infinity) ) { | |
| 187 return x; | |
| 188 } | |
| 189 #endif | |
| 190 return ((jdouble)fmod((double)x,(double)y)); | |
| 191 JRT_END | |
| 192 | |
| 193 | |
| 194 JRT_LEAF(jint, SharedRuntime::f2i(jfloat x)) | |
| 195 if (g_isnan(x)) {return 0;} | |
| 196 jlong lltmp = (jlong)x; | |
| 197 jint ltmp = (jint)lltmp; | |
| 198 if (ltmp == lltmp) { | |
| 199 return ltmp; | |
| 200 } else { | |
| 201 if (x < 0) { | |
| 202 return min_jint; | |
| 203 } else { | |
| 204 return max_jint; | |
| 205 } | |
| 206 } | |
| 207 JRT_END | |
| 208 | |
| 209 | |
| 210 JRT_LEAF(jlong, SharedRuntime::f2l(jfloat x)) | |
| 211 if (g_isnan(x)) {return 0;} | |
| 212 jlong lltmp = (jlong)x; | |
| 213 if (lltmp != min_jlong) { | |
| 214 return lltmp; | |
| 215 } else { | |
| 216 if (x < 0) { | |
| 217 return min_jlong; | |
| 218 } else { | |
| 219 return max_jlong; | |
| 220 } | |
| 221 } | |
| 222 JRT_END | |
| 223 | |
| 224 | |
| 225 JRT_LEAF(jint, SharedRuntime::d2i(jdouble x)) | |
| 226 if (g_isnan(x)) {return 0;} | |
| 227 jlong lltmp = (jlong)x; | |
| 228 jint ltmp = (jint)lltmp; | |
| 229 if (ltmp == lltmp) { | |
| 230 return ltmp; | |
| 231 } else { | |
| 232 if (x < 0) { | |
| 233 return min_jint; | |
| 234 } else { | |
| 235 return max_jint; | |
| 236 } | |
| 237 } | |
| 238 JRT_END | |
| 239 | |
| 240 | |
| 241 JRT_LEAF(jlong, SharedRuntime::d2l(jdouble x)) | |
| 242 if (g_isnan(x)) {return 0;} | |
| 243 jlong lltmp = (jlong)x; | |
| 244 if (lltmp != min_jlong) { | |
| 245 return lltmp; | |
| 246 } else { | |
| 247 if (x < 0) { | |
| 248 return min_jlong; | |
| 249 } else { | |
| 250 return max_jlong; | |
| 251 } | |
| 252 } | |
| 253 JRT_END | |
| 254 | |
| 255 | |
| 256 JRT_LEAF(jfloat, SharedRuntime::d2f(jdouble x)) | |
| 257 return (jfloat)x; | |
| 258 JRT_END | |
| 259 | |
| 260 | |
| 261 JRT_LEAF(jfloat, SharedRuntime::l2f(jlong x)) | |
| 262 return (jfloat)x; | |
| 263 JRT_END | |
| 264 | |
| 265 | |
| 266 JRT_LEAF(jdouble, SharedRuntime::l2d(jlong x)) | |
| 267 return (jdouble)x; | |
| 268 JRT_END | |
| 269 | |
| 270 // Exception handling accross interpreter/compiler boundaries | |
| 271 // | |
| 272 // exception_handler_for_return_address(...) returns the continuation address. | |
| 273 // The continuation address is the entry point of the exception handler of the | |
| 274 // previous frame depending on the return address. | |
| 275 | |
| 276 address SharedRuntime::raw_exception_handler_for_return_address(address return_address) { | |
| 277 assert(frame::verify_return_pc(return_address), "must be a return pc"); | |
| 278 | |
| 279 // the fastest case first | |
| 280 CodeBlob* blob = CodeCache::find_blob(return_address); | |
| 281 if (blob != NULL && blob->is_nmethod()) { | |
| 282 nmethod* code = (nmethod*)blob; | |
| 283 assert(code != NULL, "nmethod must be present"); | |
| 284 // native nmethods don't have exception handlers | |
| 285 assert(!code->is_native_method(), "no exception handler"); | |
| 286 assert(code->header_begin() != code->exception_begin(), "no exception handler"); | |
| 287 if (code->is_deopt_pc(return_address)) { | |
| 288 return SharedRuntime::deopt_blob()->unpack_with_exception(); | |
| 289 } else { | |
| 290 return code->exception_begin(); | |
| 291 } | |
| 292 } | |
| 293 | |
| 294 // Entry code | |
| 295 if (StubRoutines::returns_to_call_stub(return_address)) { | |
| 296 return StubRoutines::catch_exception_entry(); | |
| 297 } | |
| 298 // Interpreted code | |
| 299 if (Interpreter::contains(return_address)) { | |
| 300 return Interpreter::rethrow_exception_entry(); | |
| 301 } | |
| 302 | |
| 303 // Compiled code | |
| 304 if (CodeCache::contains(return_address)) { | |
| 305 CodeBlob* blob = CodeCache::find_blob(return_address); | |
| 306 if (blob->is_nmethod()) { | |
| 307 nmethod* code = (nmethod*)blob; | |
| 308 assert(code != NULL, "nmethod must be present"); | |
| 309 assert(code->header_begin() != code->exception_begin(), "no exception handler"); | |
| 310 return code->exception_begin(); | |
| 311 } | |
| 312 if (blob->is_runtime_stub()) { | |
| 313 ShouldNotReachHere(); // callers are responsible for skipping runtime stub frames | |
| 314 } | |
| 315 } | |
| 316 guarantee(!VtableStubs::contains(return_address), "NULL exceptions in vtables should have been handled already!"); | |
| 317 #ifndef PRODUCT | |
| 318 { ResourceMark rm; | |
| 319 tty->print_cr("No exception handler found for exception at " INTPTR_FORMAT " - potential problems:", return_address); | |
| 320 tty->print_cr("a) exception happened in (new?) code stubs/buffers that is not handled here"); | |
| 321 tty->print_cr("b) other problem"); | |
| 322 } | |
| 323 #endif // PRODUCT | |
| 324 ShouldNotReachHere(); | |
| 325 return NULL; | |
| 326 } | |
| 327 | |
| 328 | |
| 329 JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(address return_address)) | |
| 330 return raw_exception_handler_for_return_address(return_address); | |
| 331 JRT_END | |
| 332 | |
| 333 address SharedRuntime::get_poll_stub(address pc) { | |
| 334 address stub; | |
| 335 // Look up the code blob | |
| 336 CodeBlob *cb = CodeCache::find_blob(pc); | |
| 337 | |
| 338 // Should be an nmethod | |
| 339 assert( cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod" ); | |
| 340 | |
| 341 // Look up the relocation information | |
| 342 assert( ((nmethod*)cb)->is_at_poll_or_poll_return(pc), | |
| 343 "safepoint polling: type must be poll" ); | |
| 344 | |
| 345 assert( ((NativeInstruction*)pc)->is_safepoint_poll(), | |
| 346 "Only polling locations are used for safepoint"); | |
| 347 | |
| 348 bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc); | |
| 349 if (at_poll_return) { | |
| 350 assert(SharedRuntime::polling_page_return_handler_blob() != NULL, | |
| 351 "polling page return stub not created yet"); | |
| 352 stub = SharedRuntime::polling_page_return_handler_blob()->instructions_begin(); | |
| 353 } else { | |
| 354 assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL, | |
| 355 "polling page safepoint stub not created yet"); | |
| 356 stub = SharedRuntime::polling_page_safepoint_handler_blob()->instructions_begin(); | |
| 357 } | |
| 358 #ifndef PRODUCT | |
| 359 if( TraceSafepoint ) { | |
| 360 char buf[256]; | |
| 361 jio_snprintf(buf, sizeof(buf), | |
| 362 "... found polling page %s exception at pc = " | |
| 363 INTPTR_FORMAT ", stub =" INTPTR_FORMAT, | |
| 364 at_poll_return ? "return" : "loop", | |
| 365 (intptr_t)pc, (intptr_t)stub); | |
| 366 tty->print_raw_cr(buf); | |
| 367 } | |
| 368 #endif // PRODUCT | |
| 369 return stub; | |
| 370 } | |
| 371 | |
| 372 | |
| 373 oop SharedRuntime::retrieve_receiver( symbolHandle sig, frame caller ) { | |
| 374 assert(caller.is_interpreted_frame(), ""); | |
| 375 int args_size = ArgumentSizeComputer(sig).size() + 1; | |
| 376 assert(args_size <= caller.interpreter_frame_expression_stack_size(), "receiver must be on interpreter stack"); | |
| 377 oop result = (oop) *caller.interpreter_frame_tos_at(args_size - 1); | |
| 378 assert(Universe::heap()->is_in(result) && result->is_oop(), "receiver must be an oop"); | |
| 379 return result; | |
| 380 } | |
| 381 | |
| 382 | |
| 383 void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Handle h_exception) { | |
| 384 if (JvmtiExport::can_post_exceptions()) { | |
| 385 vframeStream vfst(thread, true); | |
| 386 methodHandle method = methodHandle(thread, vfst.method()); | |
| 387 address bcp = method()->bcp_from(vfst.bci()); | |
| 388 JvmtiExport::post_exception_throw(thread, method(), bcp, h_exception()); | |
| 389 } | |
| 390 Exceptions::_throw(thread, __FILE__, __LINE__, h_exception); | |
| 391 } | |
| 392 | |
| 393 void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, symbolOop name, const char *message) { | |
| 394 Handle h_exception = Exceptions::new_exception(thread, name, message); | |
| 395 throw_and_post_jvmti_exception(thread, h_exception); | |
| 396 } | |
| 397 | |
| 398 // ret_pc points into caller; we are returning caller's exception handler | |
| 399 // for given exception | |
| 400 address SharedRuntime::compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception, | |
| 401 bool force_unwind, bool top_frame_only) { | |
| 402 assert(nm != NULL, "must exist"); | |
| 403 ResourceMark rm; | |
| 404 | |
| 405 ScopeDesc* sd = nm->scope_desc_at(ret_pc); | |
| 406 // determine handler bci, if any | |
| 407 EXCEPTION_MARK; | |
| 408 | |
| 409 int handler_bci = -1; | |
| 410 int scope_depth = 0; | |
| 411 if (!force_unwind) { | |
| 412 int bci = sd->bci(); | |
| 413 do { | |
| 414 bool skip_scope_increment = false; | |
| 415 // exception handler lookup | |
| 416 KlassHandle ek (THREAD, exception->klass()); | |
| 417 handler_bci = sd->method()->fast_exception_handler_bci_for(ek, bci, THREAD); | |
| 418 if (HAS_PENDING_EXCEPTION) { | |
| 419 // We threw an exception while trying to find the exception handler. | |
| 420 // Transfer the new exception to the exception handle which will | |
| 421 // be set into thread local storage, and do another lookup for an | |
| 422 // exception handler for this exception, this time starting at the | |
| 423 // BCI of the exception handler which caused the exception to be | |
| 424 // thrown (bugs 4307310 and 4546590). Set "exception" reference | |
| 425 // argument to ensure that the correct exception is thrown (4870175). | |
| 426 exception = Handle(THREAD, PENDING_EXCEPTION); | |
| 427 CLEAR_PENDING_EXCEPTION; | |
| 428 if (handler_bci >= 0) { | |
| 429 bci = handler_bci; | |
| 430 handler_bci = -1; | |
| 431 skip_scope_increment = true; | |
| 432 } | |
| 433 } | |
| 434 if (!top_frame_only && handler_bci < 0 && !skip_scope_increment) { | |
| 435 sd = sd->sender(); | |
| 436 if (sd != NULL) { | |
| 437 bci = sd->bci(); | |
| 438 } | |
| 439 ++scope_depth; | |
| 440 } | |
| 441 } while (!top_frame_only && handler_bci < 0 && sd != NULL); | |
| 442 } | |
| 443 | |
| 444 // found handling method => lookup exception handler | |
| 445 int catch_pco = ret_pc - nm->instructions_begin(); | |
| 446 | |
| 447 ExceptionHandlerTable table(nm); | |
| 448 HandlerTableEntry *t = table.entry_for(catch_pco, handler_bci, scope_depth); | |
| 449 if (t == NULL && (nm->is_compiled_by_c1() || handler_bci != -1)) { | |
| 450 // Allow abbreviated catch tables. The idea is to allow a method | |
| 451 // to materialize its exceptions without committing to the exact | |
| 452 // routing of exceptions. In particular this is needed for adding | |
| 453 // a synthethic handler to unlock monitors when inlining | |
| 454 // synchonized methods since the unlock path isn't represented in | |
| 455 // the bytecodes. | |
| 456 t = table.entry_for(catch_pco, -1, 0); | |
| 457 } | |
| 458 | |
| 459 #ifdef COMPILER1 | |
| 460 if (nm->is_compiled_by_c1() && t == NULL && handler_bci == -1) { | |
| 461 // Exception is not handled by this frame so unwind. Note that | |
| 462 // this is not the same as how C2 does this. C2 emits a table | |
| 463 // entry that dispatches to the unwind code in the nmethod. | |
| 464 return NULL; | |
| 465 } | |
| 466 #endif /* COMPILER1 */ | |
| 467 | |
| 468 | |
| 469 if (t == NULL) { | |
| 470 tty->print_cr("MISSING EXCEPTION HANDLER for pc " INTPTR_FORMAT " and handler bci %d", ret_pc, handler_bci); | |
| 471 tty->print_cr(" Exception:"); | |
| 472 exception->print(); | |
| 473 tty->cr(); | |
| 474 tty->print_cr(" Compiled exception table :"); | |
| 475 table.print(); | |
| 476 nm->print_code(); | |
| 477 guarantee(false, "missing exception handler"); | |
| 478 return NULL; | |
| 479 } | |
| 480 | |
| 481 return nm->instructions_begin() + t->pco(); | |
| 482 } | |
| 483 | |
| 484 JRT_ENTRY(void, SharedRuntime::throw_AbstractMethodError(JavaThread* thread)) | |
| 485 // These errors occur only at call sites | |
| 486 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_AbstractMethodError()); | |
| 487 JRT_END | |
| 488 | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
489 JRT_ENTRY(void, SharedRuntime::throw_IncompatibleClassChangeError(JavaThread* thread)) |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
490 // These errors occur only at call sites |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
491 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError(), "vtable stub"); |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
492 JRT_END |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
493 |
| 0 | 494 JRT_ENTRY(void, SharedRuntime::throw_ArithmeticException(JavaThread* thread)) |
| 495 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArithmeticException(), "/ by zero"); | |
| 496 JRT_END | |
| 497 | |
| 498 JRT_ENTRY(void, SharedRuntime::throw_NullPointerException(JavaThread* thread)) | |
| 499 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException()); | |
| 500 JRT_END | |
| 501 | |
| 502 JRT_ENTRY(void, SharedRuntime::throw_NullPointerException_at_call(JavaThread* thread)) | |
| 503 // This entry point is effectively only used for NullPointerExceptions which occur at inline | |
| 504 // cache sites (when the callee activation is not yet set up) so we are at a call site | |
| 505 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException()); | |
| 506 JRT_END | |
| 507 | |
| 508 JRT_ENTRY(void, SharedRuntime::throw_StackOverflowError(JavaThread* thread)) | |
| 509 // We avoid using the normal exception construction in this case because | |
| 510 // it performs an upcall to Java, and we're already out of stack space. | |
| 511 klassOop k = SystemDictionary::StackOverflowError_klass(); | |
| 512 oop exception_oop = instanceKlass::cast(k)->allocate_instance(CHECK); | |
| 513 Handle exception (thread, exception_oop); | |
| 514 if (StackTraceInThrowable) { | |
| 515 java_lang_Throwable::fill_in_stack_trace(exception); | |
| 516 } | |
| 517 throw_and_post_jvmti_exception(thread, exception); | |
| 518 JRT_END | |
| 519 | |
| 520 address SharedRuntime::continuation_for_implicit_exception(JavaThread* thread, | |
| 521 address pc, | |
| 522 SharedRuntime::ImplicitExceptionKind exception_kind) | |
| 523 { | |
| 524 address target_pc = NULL; | |
| 525 | |
| 526 if (Interpreter::contains(pc)) { | |
| 527 #ifdef CC_INTERP | |
| 528 // C++ interpreter doesn't throw implicit exceptions | |
| 529 ShouldNotReachHere(); | |
| 530 #else | |
| 531 switch (exception_kind) { | |
| 532 case IMPLICIT_NULL: return Interpreter::throw_NullPointerException_entry(); | |
| 533 case IMPLICIT_DIVIDE_BY_ZERO: return Interpreter::throw_ArithmeticException_entry(); | |
| 534 case STACK_OVERFLOW: return Interpreter::throw_StackOverflowError_entry(); | |
| 535 default: ShouldNotReachHere(); | |
| 536 } | |
| 537 #endif // !CC_INTERP | |
| 538 } else { | |
| 539 switch (exception_kind) { | |
| 540 case STACK_OVERFLOW: { | |
| 541 // Stack overflow only occurs upon frame setup; the callee is | |
| 542 // going to be unwound. Dispatch to a shared runtime stub | |
| 543 // which will cause the StackOverflowError to be fabricated | |
| 544 // and processed. | |
| 545 // For stack overflow in deoptimization blob, cleanup thread. | |
| 546 if (thread->deopt_mark() != NULL) { | |
| 547 Deoptimization::cleanup_deopt_info(thread, NULL); | |
| 548 } | |
| 549 return StubRoutines::throw_StackOverflowError_entry(); | |
| 550 } | |
| 551 | |
| 552 case IMPLICIT_NULL: { | |
| 553 if (VtableStubs::contains(pc)) { | |
| 554 // We haven't yet entered the callee frame. Fabricate an | |
| 555 // exception and begin dispatching it in the caller. Since | |
| 556 // the caller was at a call site, it's safe to destroy all | |
| 557 // caller-saved registers, as these entry points do. | |
| 558 VtableStub* vt_stub = VtableStubs::stub_containing(pc); | |
| 559 guarantee(vt_stub != NULL, "unable to find SEGVing vtable stub"); | |
| 560 if (vt_stub->is_abstract_method_error(pc)) { | |
| 561 assert(!vt_stub->is_vtable_stub(), "should never see AbstractMethodErrors from vtable-type VtableStubs"); | |
| 562 return StubRoutines::throw_AbstractMethodError_entry(); | |
| 563 } else { | |
| 564 return StubRoutines::throw_NullPointerException_at_call_entry(); | |
| 565 } | |
| 566 } else { | |
| 567 CodeBlob* cb = CodeCache::find_blob(pc); | |
| 568 guarantee(cb != NULL, "exception happened outside interpreter, nmethods and vtable stubs (1)"); | |
| 569 | |
| 570 // Exception happened in CodeCache. Must be either: | |
| 571 // 1. Inline-cache check in C2I handler blob, | |
| 572 // 2. Inline-cache check in nmethod, or | |
| 573 // 3. Implict null exception in nmethod | |
| 574 | |
| 575 if (!cb->is_nmethod()) { | |
| 576 guarantee(cb->is_adapter_blob(), | |
| 577 "exception happened outside interpreter, nmethods and vtable stubs (2)"); | |
| 578 // There is no handler here, so we will simply unwind. | |
| 579 return StubRoutines::throw_NullPointerException_at_call_entry(); | |
| 580 } | |
| 581 | |
| 582 // Otherwise, it's an nmethod. Consult its exception handlers. | |
| 583 nmethod* nm = (nmethod*)cb; | |
| 584 if (nm->inlinecache_check_contains(pc)) { | |
| 585 // exception happened inside inline-cache check code | |
| 586 // => the nmethod is not yet active (i.e., the frame | |
| 587 // is not set up yet) => use return address pushed by | |
| 588 // caller => don't push another return address | |
| 589 return StubRoutines::throw_NullPointerException_at_call_entry(); | |
| 590 } | |
| 591 | |
| 592 #ifndef PRODUCT | |
| 593 _implicit_null_throws++; | |
| 594 #endif | |
| 595 target_pc = nm->continuation_for_implicit_exception(pc); | |
| 596 guarantee(target_pc != 0, "must have a continuation point"); | |
| 597 } | |
| 598 | |
| 599 break; // fall through | |
| 600 } | |
| 601 | |
| 602 | |
| 603 case IMPLICIT_DIVIDE_BY_ZERO: { | |
| 604 nmethod* nm = CodeCache::find_nmethod(pc); | |
| 605 guarantee(nm != NULL, "must have containing nmethod for implicit division-by-zero exceptions"); | |
| 606 #ifndef PRODUCT | |
| 607 _implicit_div0_throws++; | |
| 608 #endif | |
| 609 target_pc = nm->continuation_for_implicit_exception(pc); | |
| 610 guarantee(target_pc != 0, "must have a continuation point"); | |
| 611 break; // fall through | |
| 612 } | |
| 613 | |
| 614 default: ShouldNotReachHere(); | |
| 615 } | |
| 616 | |
| 617 guarantee(target_pc != NULL, "must have computed destination PC for implicit exception"); | |
| 618 assert(exception_kind == IMPLICIT_NULL || exception_kind == IMPLICIT_DIVIDE_BY_ZERO, "wrong implicit exception kind"); | |
| 619 | |
| 620 // for AbortVMOnException flag | |
| 621 NOT_PRODUCT(Exceptions::debug_check_abort("java.lang.NullPointerException")); | |
| 622 if (exception_kind == IMPLICIT_NULL) { | |
| 623 Events::log("Implicit null exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc); | |
| 624 } else { | |
| 625 Events::log("Implicit division by zero exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc); | |
| 626 } | |
| 627 return target_pc; | |
| 628 } | |
| 629 | |
| 630 ShouldNotReachHere(); | |
| 631 return NULL; | |
| 632 } | |
| 633 | |
| 634 | |
| 635 JNI_ENTRY(void, throw_unsatisfied_link_error(JNIEnv* env, ...)) | |
| 636 { | |
| 637 THROW(vmSymbols::java_lang_UnsatisfiedLinkError()); | |
| 638 } | |
| 639 JNI_END | |
| 640 | |
| 641 | |
| 642 address SharedRuntime::native_method_throw_unsatisfied_link_error_entry() { | |
| 643 return CAST_FROM_FN_PTR(address, &throw_unsatisfied_link_error); | |
| 644 } | |
| 645 | |
| 646 | |
| 647 #ifndef PRODUCT | |
| 648 JRT_ENTRY(intptr_t, SharedRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2)) | |
| 649 const frame f = thread->last_frame(); | |
| 650 assert(f.is_interpreted_frame(), "must be an interpreted frame"); | |
| 651 #ifndef PRODUCT | |
| 652 methodHandle mh(THREAD, f.interpreter_frame_method()); | |
| 653 BytecodeTracer::trace(mh, f.interpreter_frame_bcp(), tos, tos2); | |
| 654 #endif // !PRODUCT | |
| 655 return preserve_this_value; | |
| 656 JRT_END | |
| 657 #endif // !PRODUCT | |
| 658 | |
| 659 | |
| 660 JRT_ENTRY(void, SharedRuntime::yield_all(JavaThread* thread, int attempts)) | |
| 661 os::yield_all(attempts); | |
| 662 JRT_END | |
| 663 | |
| 664 | |
| 665 // --------------------------------------------------------------------------------------------------------- | |
| 666 // Non-product code | |
| 667 #ifndef PRODUCT | |
| 668 | |
| 669 void SharedRuntime::verify_caller_frame(frame caller_frame, methodHandle callee_method) { | |
| 670 ResourceMark rm; | |
| 671 assert (caller_frame.is_interpreted_frame(), "sanity check"); | |
| 672 assert (callee_method->has_compiled_code(), "callee must be compiled"); | |
| 673 methodHandle caller_method (Thread::current(), caller_frame.interpreter_frame_method()); | |
| 674 jint bci = caller_frame.interpreter_frame_bci(); | |
| 675 methodHandle method = find_callee_method_inside_interpreter(caller_frame, caller_method, bci); | |
| 676 assert (callee_method == method, "incorrect method"); | |
| 677 } | |
| 678 | |
| 679 methodHandle SharedRuntime::find_callee_method_inside_interpreter(frame caller_frame, methodHandle caller_method, int bci) { | |
| 680 EXCEPTION_MARK; | |
| 681 Bytecode_invoke* bytecode = Bytecode_invoke_at(caller_method, bci); | |
| 682 methodHandle staticCallee = bytecode->static_target(CATCH); // Non-product code | |
| 683 | |
| 684 bytecode = Bytecode_invoke_at(caller_method, bci); | |
| 685 int bytecode_index = bytecode->index(); | |
| 686 Bytecodes::Code bc = bytecode->adjusted_invoke_code(); | |
| 687 | |
| 688 Handle receiver; | |
| 689 if (bc == Bytecodes::_invokeinterface || | |
| 690 bc == Bytecodes::_invokevirtual || | |
| 691 bc == Bytecodes::_invokespecial) { | |
| 692 symbolHandle signature (THREAD, staticCallee->signature()); | |
| 693 receiver = Handle(THREAD, retrieve_receiver(signature, caller_frame)); | |
| 694 } else { | |
| 695 receiver = Handle(); | |
| 696 } | |
| 697 CallInfo result; | |
| 698 constantPoolHandle constants (THREAD, caller_method->constants()); | |
| 699 LinkResolver::resolve_invoke(result, receiver, constants, bytecode_index, bc, CATCH); // Non-product code | |
| 700 methodHandle calleeMethod = result.selected_method(); | |
| 701 return calleeMethod; | |
| 702 } | |
| 703 | |
| 704 #endif // PRODUCT | |
| 705 | |
| 706 | |
| 707 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::register_finalizer(JavaThread* thread, oopDesc* obj)) | |
| 708 assert(obj->is_oop(), "must be a valid oop"); | |
| 709 assert(obj->klass()->klass_part()->has_finalizer(), "shouldn't be here otherwise"); | |
| 710 instanceKlass::register_finalizer(instanceOop(obj), CHECK); | |
| 711 JRT_END | |
| 712 | |
| 713 | |
| 714 jlong SharedRuntime::get_java_tid(Thread* thread) { | |
| 715 if (thread != NULL) { | |
| 716 if (thread->is_Java_thread()) { | |
| 717 oop obj = ((JavaThread*)thread)->threadObj(); | |
| 718 return (obj == NULL) ? 0 : java_lang_Thread::thread_id(obj); | |
| 719 } | |
| 720 } | |
| 721 return 0; | |
| 722 } | |
| 723 | |
| 724 /** | |
| 725 * This function ought to be a void function, but cannot be because | |
| 726 * it gets turned into a tail-call on sparc, which runs into dtrace bug | |
| 727 * 6254741. Once that is fixed we can remove the dummy return value. | |
| 728 */ | |
| 729 int SharedRuntime::dtrace_object_alloc(oopDesc* o) { | |
| 730 return dtrace_object_alloc_base(Thread::current(), o); | |
| 731 } | |
| 732 | |
| 733 int SharedRuntime::dtrace_object_alloc_base(Thread* thread, oopDesc* o) { | |
| 734 assert(DTraceAllocProbes, "wrong call"); | |
| 735 Klass* klass = o->blueprint(); | |
| 736 int size = o->size(); | |
| 737 symbolOop name = klass->name(); | |
| 738 HS_DTRACE_PROBE4(hotspot, object__alloc, get_java_tid(thread), | |
| 739 name->bytes(), name->utf8_length(), size * HeapWordSize); | |
| 740 return 0; | |
| 741 } | |
| 742 | |
| 743 JRT_LEAF(int, SharedRuntime::dtrace_method_entry( | |
| 744 JavaThread* thread, methodOopDesc* method)) | |
| 745 assert(DTraceMethodProbes, "wrong call"); | |
| 746 symbolOop kname = method->klass_name(); | |
| 747 symbolOop name = method->name(); | |
| 748 symbolOop sig = method->signature(); | |
| 749 HS_DTRACE_PROBE7(hotspot, method__entry, get_java_tid(thread), | |
| 750 kname->bytes(), kname->utf8_length(), | |
| 751 name->bytes(), name->utf8_length(), | |
| 752 sig->bytes(), sig->utf8_length()); | |
| 753 return 0; | |
| 754 JRT_END | |
| 755 | |
| 756 JRT_LEAF(int, SharedRuntime::dtrace_method_exit( | |
| 757 JavaThread* thread, methodOopDesc* method)) | |
| 758 assert(DTraceMethodProbes, "wrong call"); | |
| 759 symbolOop kname = method->klass_name(); | |
| 760 symbolOop name = method->name(); | |
| 761 symbolOop sig = method->signature(); | |
| 762 HS_DTRACE_PROBE7(hotspot, method__return, get_java_tid(thread), | |
| 763 kname->bytes(), kname->utf8_length(), | |
| 764 name->bytes(), name->utf8_length(), | |
| 765 sig->bytes(), sig->utf8_length()); | |
| 766 return 0; | |
| 767 JRT_END | |
| 768 | |
| 769 | |
| 770 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode) | |
| 771 // for a call current in progress, i.e., arguments has been pushed on stack | |
| 772 // put callee has not been invoked yet. Used by: resolve virtual/static, | |
| 773 // vtable updates, etc. Caller frame must be compiled. | |
| 774 Handle SharedRuntime::find_callee_info(JavaThread* thread, Bytecodes::Code& bc, CallInfo& callinfo, TRAPS) { | |
| 775 ResourceMark rm(THREAD); | |
| 776 | |
| 777 // last java frame on stack (which includes native call frames) | |
| 778 vframeStream vfst(thread, true); // Do not skip and javaCalls | |
| 779 | |
| 780 return find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(Handle())); | |
| 781 } | |
| 782 | |
| 783 | |
| 784 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode | |
| 785 // for a call current in progress, i.e., arguments has been pushed on stack | |
| 786 // but callee has not been invoked yet. Caller frame must be compiled. | |
| 787 Handle SharedRuntime::find_callee_info_helper(JavaThread* thread, | |
| 788 vframeStream& vfst, | |
| 789 Bytecodes::Code& bc, | |
| 790 CallInfo& callinfo, TRAPS) { | |
| 791 Handle receiver; | |
| 792 Handle nullHandle; //create a handy null handle for exception returns | |
| 793 | |
| 794 assert(!vfst.at_end(), "Java frame must exist"); | |
| 795 | |
| 796 // Find caller and bci from vframe | |
| 797 methodHandle caller (THREAD, vfst.method()); | |
| 798 int bci = vfst.bci(); | |
| 799 | |
| 800 // Find bytecode | |
| 801 Bytecode_invoke* bytecode = Bytecode_invoke_at(caller, bci); | |
| 802 bc = bytecode->adjusted_invoke_code(); | |
| 803 int bytecode_index = bytecode->index(); | |
| 804 | |
| 805 // Find receiver for non-static call | |
| 806 if (bc != Bytecodes::_invokestatic) { | |
| 807 // This register map must be update since we need to find the receiver for | |
| 808 // compiled frames. The receiver might be in a register. | |
| 809 RegisterMap reg_map2(thread); | |
| 810 frame stubFrame = thread->last_frame(); | |
| 811 // Caller-frame is a compiled frame | |
| 812 frame callerFrame = stubFrame.sender(®_map2); | |
| 813 | |
| 814 methodHandle callee = bytecode->static_target(CHECK_(nullHandle)); | |
| 815 if (callee.is_null()) { | |
| 816 THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle); | |
| 817 } | |
| 818 // Retrieve from a compiled argument list | |
| 819 receiver = Handle(THREAD, callerFrame.retrieve_receiver(®_map2)); | |
| 820 | |
| 821 if (receiver.is_null()) { | |
| 822 THROW_(vmSymbols::java_lang_NullPointerException(), nullHandle); | |
| 823 } | |
| 824 } | |
| 825 | |
| 826 // Resolve method. This is parameterized by bytecode. | |
| 827 constantPoolHandle constants (THREAD, caller->constants()); | |
| 828 assert (receiver.is_null() || receiver->is_oop(), "wrong receiver"); | |
| 829 LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_(nullHandle)); | |
| 830 | |
| 831 #ifdef ASSERT | |
| 832 // Check that the receiver klass is of the right subtype and that it is initialized for virtual calls | |
| 833 if (bc != Bytecodes::_invokestatic) { | |
| 834 assert(receiver.not_null(), "should have thrown exception"); | |
| 835 KlassHandle receiver_klass (THREAD, receiver->klass()); | |
| 836 klassOop rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle)); | |
| 837 // klass is already loaded | |
| 838 KlassHandle static_receiver_klass (THREAD, rk); | |
| 839 assert(receiver_klass->is_subtype_of(static_receiver_klass()), "actual receiver must be subclass of static receiver klass"); | |
| 840 if (receiver_klass->oop_is_instance()) { | |
| 841 if (instanceKlass::cast(receiver_klass())->is_not_initialized()) { | |
| 842 tty->print_cr("ERROR: Klass not yet initialized!!"); | |
| 843 receiver_klass.print(); | |
| 844 } | |
| 845 assert (!instanceKlass::cast(receiver_klass())->is_not_initialized(), "receiver_klass must be initialized"); | |
| 846 } | |
| 847 } | |
| 848 #endif | |
| 849 | |
| 850 return receiver; | |
| 851 } | |
| 852 | |
| 853 methodHandle SharedRuntime::find_callee_method(JavaThread* thread, TRAPS) { | |
| 854 ResourceMark rm(THREAD); | |
| 855 // We need first to check if any Java activations (compiled, interpreted) | |
| 856 // exist on the stack since last JavaCall. If not, we need | |
| 857 // to get the target method from the JavaCall wrapper. | |
| 858 vframeStream vfst(thread, true); // Do not skip any javaCalls | |
| 859 methodHandle callee_method; | |
| 860 if (vfst.at_end()) { | |
| 861 // No Java frames were found on stack since we did the JavaCall. | |
| 862 // Hence the stack can only contain an entry_frame. We need to | |
| 863 // find the target method from the stub frame. | |
| 864 RegisterMap reg_map(thread, false); | |
| 865 frame fr = thread->last_frame(); | |
| 866 assert(fr.is_runtime_frame(), "must be a runtimeStub"); | |
| 867 fr = fr.sender(®_map); | |
| 868 assert(fr.is_entry_frame(), "must be"); | |
| 869 // fr is now pointing to the entry frame. | |
| 870 callee_method = methodHandle(THREAD, fr.entry_frame_call_wrapper()->callee_method()); | |
| 871 assert(fr.entry_frame_call_wrapper()->receiver() == NULL || !callee_method->is_static(), "non-null receiver for static call??"); | |
| 872 } else { | |
| 873 Bytecodes::Code bc; | |
| 874 CallInfo callinfo; | |
| 875 find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(methodHandle())); | |
| 876 callee_method = callinfo.selected_method(); | |
| 877 } | |
| 878 assert(callee_method()->is_method(), "must be"); | |
| 879 return callee_method; | |
| 880 } | |
| 881 | |
| 882 // Resolves a call. | |
| 883 methodHandle SharedRuntime::resolve_helper(JavaThread *thread, | |
| 884 bool is_virtual, | |
| 885 bool is_optimized, TRAPS) { | |
| 886 methodHandle callee_method; | |
| 887 callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD); | |
| 888 if (JvmtiExport::can_hotswap_or_post_breakpoint()) { | |
| 889 int retry_count = 0; | |
| 890 while (!HAS_PENDING_EXCEPTION && callee_method->is_old() && | |
| 891 callee_method->method_holder() != SystemDictionary::object_klass()) { | |
| 892 // If has a pending exception then there is no need to re-try to | |
| 893 // resolve this method. | |
| 894 // If the method has been redefined, we need to try again. | |
| 895 // Hack: we have no way to update the vtables of arrays, so don't | |
| 896 // require that java.lang.Object has been updated. | |
| 897 | |
| 898 // It is very unlikely that method is redefined more than 100 times | |
| 899 // in the middle of resolve. If it is looping here more than 100 times | |
| 900 // means then there could be a bug here. | |
| 901 guarantee((retry_count++ < 100), | |
| 902 "Could not resolve to latest version of redefined method"); | |
| 903 // method is redefined in the middle of resolve so re-try. | |
| 904 callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD); | |
| 905 } | |
| 906 } | |
| 907 return callee_method; | |
| 908 } | |
| 909 | |
| 910 // Resolves a call. The compilers generate code for calls that go here | |
| 911 // and are patched with the real destination of the call. | |
| 912 methodHandle SharedRuntime::resolve_sub_helper(JavaThread *thread, | |
| 913 bool is_virtual, | |
| 914 bool is_optimized, TRAPS) { | |
| 915 | |
| 916 ResourceMark rm(thread); | |
| 917 RegisterMap cbl_map(thread, false); | |
| 918 frame caller_frame = thread->last_frame().sender(&cbl_map); | |
| 919 | |
| 920 CodeBlob* cb = caller_frame.cb(); | |
| 921 guarantee(cb != NULL && cb->is_nmethod(), "must be called from nmethod"); | |
| 922 // make sure caller is not getting deoptimized | |
| 923 // and removed before we are done with it. | |
| 924 // CLEANUP - with lazy deopt shouldn't need this lock | |
| 925 nmethodLocker caller_lock((nmethod*)cb); | |
| 926 | |
| 927 | |
| 928 // determine call info & receiver | |
| 929 // note: a) receiver is NULL for static calls | |
| 930 // b) an exception is thrown if receiver is NULL for non-static calls | |
| 931 CallInfo call_info; | |
| 932 Bytecodes::Code invoke_code = Bytecodes::_illegal; | |
| 933 Handle receiver = find_callee_info(thread, invoke_code, | |
| 934 call_info, CHECK_(methodHandle())); | |
| 935 methodHandle callee_method = call_info.selected_method(); | |
| 936 | |
| 937 assert((!is_virtual && invoke_code == Bytecodes::_invokestatic) || | |
| 938 ( is_virtual && invoke_code != Bytecodes::_invokestatic), "inconsistent bytecode"); | |
| 939 | |
| 940 #ifndef PRODUCT | |
| 941 // tracing/debugging/statistics | |
| 942 int *addr = (is_optimized) ? (&_resolve_opt_virtual_ctr) : | |
| 943 (is_virtual) ? (&_resolve_virtual_ctr) : | |
| 944 (&_resolve_static_ctr); | |
| 945 Atomic::inc(addr); | |
| 946 | |
| 947 if (TraceCallFixup) { | |
| 948 ResourceMark rm(thread); | |
| 949 tty->print("resolving %s%s (%s) call to", | |
| 950 (is_optimized) ? "optimized " : "", (is_virtual) ? "virtual" : "static", | |
| 951 Bytecodes::name(invoke_code)); | |
| 952 callee_method->print_short_name(tty); | |
| 953 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 954 } | |
| 955 #endif | |
| 956 | |
| 957 // Compute entry points. This might require generation of C2I converter | |
| 958 // frames, so we cannot be holding any locks here. Furthermore, the | |
| 959 // computation of the entry points is independent of patching the call. We | |
| 960 // always return the entry-point, but we only patch the stub if the call has | |
| 961 // not been deoptimized. Return values: For a virtual call this is an | |
| 962 // (cached_oop, destination address) pair. For a static call/optimized | |
| 963 // virtual this is just a destination address. | |
| 964 | |
| 965 StaticCallInfo static_call_info; | |
| 966 CompiledICInfo virtual_call_info; | |
| 967 | |
| 968 | |
| 969 // Make sure the callee nmethod does not get deoptimized and removed before | |
| 970 // we are done patching the code. | |
| 971 nmethod* nm = callee_method->code(); | |
| 972 nmethodLocker nl_callee(nm); | |
| 973 #ifdef ASSERT | |
| 974 address dest_entry_point = nm == NULL ? 0 : nm->entry_point(); // used below | |
| 975 #endif | |
| 976 | |
| 977 if (is_virtual) { | |
| 978 assert(receiver.not_null(), "sanity check"); | |
| 979 bool static_bound = call_info.resolved_method()->can_be_statically_bound(); | |
| 980 KlassHandle h_klass(THREAD, receiver->klass()); | |
| 981 CompiledIC::compute_monomorphic_entry(callee_method, h_klass, | |
| 982 is_optimized, static_bound, virtual_call_info, | |
| 983 CHECK_(methodHandle())); | |
| 984 } else { | |
| 985 // static call | |
| 986 CompiledStaticCall::compute_entry(callee_method, static_call_info); | |
| 987 } | |
| 988 | |
| 989 // grab lock, check for deoptimization and potentially patch caller | |
| 990 { | |
| 991 MutexLocker ml_patch(CompiledIC_lock); | |
| 992 | |
| 993 // Now that we are ready to patch if the methodOop was redefined then | |
| 994 // don't update call site and let the caller retry. | |
| 995 | |
| 996 if (!callee_method->is_old()) { | |
| 997 #ifdef ASSERT | |
| 998 // We must not try to patch to jump to an already unloaded method. | |
| 999 if (dest_entry_point != 0) { | |
| 1000 assert(CodeCache::find_blob(dest_entry_point) != NULL, | |
| 1001 "should not unload nmethod while locked"); | |
| 1002 } | |
| 1003 #endif | |
| 1004 if (is_virtual) { | |
| 1005 CompiledIC* inline_cache = CompiledIC_before(caller_frame.pc()); | |
| 1006 if (inline_cache->is_clean()) { | |
| 1007 inline_cache->set_to_monomorphic(virtual_call_info); | |
| 1008 } | |
| 1009 } else { | |
| 1010 CompiledStaticCall* ssc = compiledStaticCall_before(caller_frame.pc()); | |
| 1011 if (ssc->is_clean()) ssc->set(static_call_info); | |
| 1012 } | |
| 1013 } | |
| 1014 | |
| 1015 } // unlock CompiledIC_lock | |
| 1016 | |
| 1017 return callee_method; | |
| 1018 } | |
| 1019 | |
| 1020 | |
| 1021 // Inline caches exist only in compiled code | |
| 1022 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_ic_miss(JavaThread* thread)) | |
| 1023 #ifdef ASSERT | |
| 1024 RegisterMap reg_map(thread, false); | |
| 1025 frame stub_frame = thread->last_frame(); | |
| 1026 assert(stub_frame.is_runtime_frame(), "sanity check"); | |
| 1027 frame caller_frame = stub_frame.sender(®_map); | |
| 1028 assert(!caller_frame.is_interpreted_frame() && !caller_frame.is_entry_frame(), "unexpected frame"); | |
| 1029 #endif /* ASSERT */ | |
| 1030 | |
| 1031 methodHandle callee_method; | |
| 1032 JRT_BLOCK | |
| 1033 callee_method = SharedRuntime::handle_ic_miss_helper(thread, CHECK_NULL); | |
| 1034 // Return methodOop through TLS | |
| 1035 thread->set_vm_result(callee_method()); | |
| 1036 JRT_BLOCK_END | |
| 1037 // return compiled code entry point after potential safepoints | |
| 1038 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1039 return callee_method->verified_code_entry(); | |
| 1040 JRT_END | |
| 1041 | |
| 1042 | |
| 1043 // Handle call site that has been made non-entrant | |
| 1044 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method(JavaThread* thread)) | |
| 1045 // 6243940 We might end up in here if the callee is deoptimized | |
| 1046 // as we race to call it. We don't want to take a safepoint if | |
| 1047 // the caller was interpreted because the caller frame will look | |
| 1048 // interpreted to the stack walkers and arguments are now | |
| 1049 // "compiled" so it is much better to make this transition | |
| 1050 // invisible to the stack walking code. The i2c path will | |
| 1051 // place the callee method in the callee_target. It is stashed | |
| 1052 // there because if we try and find the callee by normal means a | |
| 1053 // safepoint is possible and have trouble gc'ing the compiled args. | |
| 1054 RegisterMap reg_map(thread, false); | |
| 1055 frame stub_frame = thread->last_frame(); | |
| 1056 assert(stub_frame.is_runtime_frame(), "sanity check"); | |
| 1057 frame caller_frame = stub_frame.sender(®_map); | |
| 1058 if (caller_frame.is_interpreted_frame() || caller_frame.is_entry_frame() ) { | |
| 1059 methodOop callee = thread->callee_target(); | |
| 1060 guarantee(callee != NULL && callee->is_method(), "bad handshake"); | |
| 1061 thread->set_vm_result(callee); | |
| 1062 thread->set_callee_target(NULL); | |
| 1063 return callee->get_c2i_entry(); | |
| 1064 } | |
| 1065 | |
| 1066 // Must be compiled to compiled path which is safe to stackwalk | |
| 1067 methodHandle callee_method; | |
| 1068 JRT_BLOCK | |
| 1069 // Force resolving of caller (if we called from compiled frame) | |
| 1070 callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_NULL); | |
| 1071 thread->set_vm_result(callee_method()); | |
| 1072 JRT_BLOCK_END | |
| 1073 // return compiled code entry point after potential safepoints | |
| 1074 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1075 return callee_method->verified_code_entry(); | |
| 1076 JRT_END | |
| 1077 | |
| 1078 | |
| 1079 // resolve a static call and patch code | |
| 1080 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_static_call_C(JavaThread *thread )) | |
| 1081 methodHandle callee_method; | |
| 1082 JRT_BLOCK | |
| 1083 callee_method = SharedRuntime::resolve_helper(thread, false, false, CHECK_NULL); | |
| 1084 thread->set_vm_result(callee_method()); | |
| 1085 JRT_BLOCK_END | |
| 1086 // return compiled code entry point after potential safepoints | |
| 1087 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1088 return callee_method->verified_code_entry(); | |
| 1089 JRT_END | |
| 1090 | |
| 1091 | |
| 1092 // resolve virtual call and update inline cache to monomorphic | |
| 1093 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_virtual_call_C(JavaThread *thread )) | |
| 1094 methodHandle callee_method; | |
| 1095 JRT_BLOCK | |
| 1096 callee_method = SharedRuntime::resolve_helper(thread, true, false, CHECK_NULL); | |
| 1097 thread->set_vm_result(callee_method()); | |
| 1098 JRT_BLOCK_END | |
| 1099 // return compiled code entry point after potential safepoints | |
| 1100 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1101 return callee_method->verified_code_entry(); | |
| 1102 JRT_END | |
| 1103 | |
| 1104 | |
| 1105 // Resolve a virtual call that can be statically bound (e.g., always | |
| 1106 // monomorphic, so it has no inline cache). Patch code to resolved target. | |
| 1107 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_opt_virtual_call_C(JavaThread *thread)) | |
| 1108 methodHandle callee_method; | |
| 1109 JRT_BLOCK | |
| 1110 callee_method = SharedRuntime::resolve_helper(thread, true, true, CHECK_NULL); | |
| 1111 thread->set_vm_result(callee_method()); | |
| 1112 JRT_BLOCK_END | |
| 1113 // return compiled code entry point after potential safepoints | |
| 1114 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1115 return callee_method->verified_code_entry(); | |
| 1116 JRT_END | |
| 1117 | |
| 1118 | |
| 1119 | |
| 1120 | |
| 1121 | |
| 1122 methodHandle SharedRuntime::handle_ic_miss_helper(JavaThread *thread, TRAPS) { | |
| 1123 ResourceMark rm(thread); | |
| 1124 CallInfo call_info; | |
| 1125 Bytecodes::Code bc; | |
| 1126 | |
| 1127 // receiver is NULL for static calls. An exception is thrown for NULL | |
| 1128 // receivers for non-static calls | |
| 1129 Handle receiver = find_callee_info(thread, bc, call_info, | |
| 1130 CHECK_(methodHandle())); | |
| 1131 // Compiler1 can produce virtual call sites that can actually be statically bound | |
| 1132 // If we fell thru to below we would think that the site was going megamorphic | |
| 1133 // when in fact the site can never miss. Worse because we'd think it was megamorphic | |
| 1134 // we'd try and do a vtable dispatch however methods that can be statically bound | |
| 1135 // don't have vtable entries (vtable_index < 0) and we'd blow up. So we force a | |
| 1136 // reresolution of the call site (as if we did a handle_wrong_method and not an | |
| 1137 // plain ic_miss) and the site will be converted to an optimized virtual call site | |
| 1138 // never to miss again. I don't believe C2 will produce code like this but if it | |
| 1139 // did this would still be the correct thing to do for it too, hence no ifdef. | |
| 1140 // | |
| 1141 if (call_info.resolved_method()->can_be_statically_bound()) { | |
| 1142 methodHandle callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_(methodHandle())); | |
| 1143 if (TraceCallFixup) { | |
| 1144 RegisterMap reg_map(thread, false); | |
| 1145 frame caller_frame = thread->last_frame().sender(®_map); | |
| 1146 ResourceMark rm(thread); | |
| 1147 tty->print("converting IC miss to reresolve (%s) call to", Bytecodes::name(bc)); | |
| 1148 callee_method->print_short_name(tty); | |
| 1149 tty->print_cr(" from pc: " INTPTR_FORMAT, caller_frame.pc()); | |
| 1150 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1151 } | |
| 1152 return callee_method; | |
| 1153 } | |
| 1154 | |
| 1155 methodHandle callee_method = call_info.selected_method(); | |
| 1156 | |
| 1157 bool should_be_mono = false; | |
| 1158 | |
| 1159 #ifndef PRODUCT | |
| 1160 Atomic::inc(&_ic_miss_ctr); | |
| 1161 | |
| 1162 // Statistics & Tracing | |
| 1163 if (TraceCallFixup) { | |
| 1164 ResourceMark rm(thread); | |
| 1165 tty->print("IC miss (%s) call to", Bytecodes::name(bc)); | |
| 1166 callee_method->print_short_name(tty); | |
| 1167 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1168 } | |
| 1169 | |
| 1170 if (ICMissHistogram) { | |
| 1171 MutexLocker m(VMStatistic_lock); | |
| 1172 RegisterMap reg_map(thread, false); | |
| 1173 frame f = thread->last_frame().real_sender(®_map);// skip runtime stub | |
| 1174 // produce statistics under the lock | |
| 1175 trace_ic_miss(f.pc()); | |
| 1176 } | |
| 1177 #endif | |
| 1178 | |
| 1179 // install an event collector so that when a vtable stub is created the | |
| 1180 // profiler can be notified via a DYNAMIC_CODE_GENERATED event. The | |
| 1181 // event can't be posted when the stub is created as locks are held | |
| 1182 // - instead the event will be deferred until the event collector goes | |
| 1183 // out of scope. | |
| 1184 JvmtiDynamicCodeEventCollector event_collector; | |
| 1185 | |
| 1186 // Update inline cache to megamorphic. Skip update if caller has been | |
| 1187 // made non-entrant or we are called from interpreted. | |
| 1188 { MutexLocker ml_patch (CompiledIC_lock); | |
| 1189 RegisterMap reg_map(thread, false); | |
| 1190 frame caller_frame = thread->last_frame().sender(®_map); | |
| 1191 CodeBlob* cb = caller_frame.cb(); | |
| 1192 if (cb->is_nmethod() && ((nmethod*)cb)->is_in_use()) { | |
| 1193 // Not a non-entrant nmethod, so find inline_cache | |
| 1194 CompiledIC* inline_cache = CompiledIC_before(caller_frame.pc()); | |
| 1195 bool should_be_mono = false; | |
| 1196 if (inline_cache->is_optimized()) { | |
| 1197 if (TraceCallFixup) { | |
| 1198 ResourceMark rm(thread); | |
| 1199 tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc)); | |
| 1200 callee_method->print_short_name(tty); | |
| 1201 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1202 } | |
| 1203 should_be_mono = true; | |
| 1204 } else { | |
| 1205 compiledICHolderOop ic_oop = (compiledICHolderOop) inline_cache->cached_oop(); | |
| 1206 if ( ic_oop != NULL && ic_oop->is_compiledICHolder()) { | |
| 1207 | |
| 1208 if (receiver()->klass() == ic_oop->holder_klass()) { | |
| 1209 // This isn't a real miss. We must have seen that compiled code | |
| 1210 // is now available and we want the call site converted to a | |
| 1211 // monomorphic compiled call site. | |
| 1212 // We can't assert for callee_method->code() != NULL because it | |
| 1213 // could have been deoptimized in the meantime | |
| 1214 if (TraceCallFixup) { | |
| 1215 ResourceMark rm(thread); | |
| 1216 tty->print("FALSE IC miss (%s) converting to compiled call to", Bytecodes::name(bc)); | |
| 1217 callee_method->print_short_name(tty); | |
| 1218 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1219 } | |
| 1220 should_be_mono = true; | |
| 1221 } | |
| 1222 } | |
| 1223 } | |
| 1224 | |
| 1225 if (should_be_mono) { | |
| 1226 | |
| 1227 // We have a path that was monomorphic but was going interpreted | |
| 1228 // and now we have (or had) a compiled entry. We correct the IC | |
| 1229 // by using a new icBuffer. | |
| 1230 CompiledICInfo info; | |
| 1231 KlassHandle receiver_klass(THREAD, receiver()->klass()); | |
| 1232 inline_cache->compute_monomorphic_entry(callee_method, | |
| 1233 receiver_klass, | |
| 1234 inline_cache->is_optimized(), | |
| 1235 false, | |
| 1236 info, CHECK_(methodHandle())); | |
| 1237 inline_cache->set_to_monomorphic(info); | |
| 1238 } else if (!inline_cache->is_megamorphic() && !inline_cache->is_clean()) { | |
| 1239 // Change to megamorphic | |
| 1240 inline_cache->set_to_megamorphic(&call_info, bc, CHECK_(methodHandle())); | |
| 1241 } else { | |
| 1242 // Either clean or megamorphic | |
| 1243 } | |
| 1244 } | |
| 1245 } // Release CompiledIC_lock | |
| 1246 | |
| 1247 return callee_method; | |
| 1248 } | |
| 1249 | |
| 1250 // | |
| 1251 // Resets a call-site in compiled code so it will get resolved again. | |
| 1252 // This routines handles both virtual call sites, optimized virtual call | |
| 1253 // sites, and static call sites. Typically used to change a call sites | |
| 1254 // destination from compiled to interpreted. | |
| 1255 // | |
| 1256 methodHandle SharedRuntime::reresolve_call_site(JavaThread *thread, TRAPS) { | |
| 1257 ResourceMark rm(thread); | |
| 1258 RegisterMap reg_map(thread, false); | |
| 1259 frame stub_frame = thread->last_frame(); | |
| 1260 assert(stub_frame.is_runtime_frame(), "must be a runtimeStub"); | |
| 1261 frame caller = stub_frame.sender(®_map); | |
| 1262 | |
| 1263 // Do nothing if the frame isn't a live compiled frame. | |
| 1264 // nmethod could be deoptimized by the time we get here | |
| 1265 // so no update to the caller is needed. | |
| 1266 | |
| 1267 if (caller.is_compiled_frame() && !caller.is_deoptimized_frame()) { | |
| 1268 | |
| 1269 address pc = caller.pc(); | |
| 1270 Events::log("update call-site at pc " INTPTR_FORMAT, pc); | |
| 1271 | |
| 1272 // Default call_addr is the location of the "basic" call. | |
| 1273 // Determine the address of the call we a reresolving. With | |
| 1274 // Inline Caches we will always find a recognizable call. | |
| 1275 // With Inline Caches disabled we may or may not find a | |
| 1276 // recognizable call. We will always find a call for static | |
| 1277 // calls and for optimized virtual calls. For vanilla virtual | |
| 1278 // calls it depends on the state of the UseInlineCaches switch. | |
| 1279 // | |
| 1280 // With Inline Caches disabled we can get here for a virtual call | |
| 1281 // for two reasons: | |
| 1282 // 1 - calling an abstract method. The vtable for abstract methods | |
| 1283 // will run us thru handle_wrong_method and we will eventually | |
| 1284 // end up in the interpreter to throw the ame. | |
| 1285 // 2 - a racing deoptimization. We could be doing a vanilla vtable | |
| 1286 // call and between the time we fetch the entry address and | |
| 1287 // we jump to it the target gets deoptimized. Similar to 1 | |
| 1288 // we will wind up in the interprter (thru a c2i with c2). | |
| 1289 // | |
| 1290 address call_addr = NULL; | |
| 1291 { | |
| 1292 // Get call instruction under lock because another thread may be | |
| 1293 // busy patching it. | |
| 1294 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag); | |
| 1295 // Location of call instruction | |
| 1296 if (NativeCall::is_call_before(pc)) { | |
| 1297 NativeCall *ncall = nativeCall_before(pc); | |
| 1298 call_addr = ncall->instruction_address(); | |
| 1299 } | |
| 1300 } | |
| 1301 | |
| 1302 // Check for static or virtual call | |
| 1303 bool is_static_call = false; | |
| 1304 nmethod* caller_nm = CodeCache::find_nmethod(pc); | |
| 1305 // Make sure nmethod doesn't get deoptimized and removed until | |
| 1306 // this is done with it. | |
| 1307 // CLEANUP - with lazy deopt shouldn't need this lock | |
| 1308 nmethodLocker nmlock(caller_nm); | |
| 1309 | |
| 1310 if (call_addr != NULL) { | |
| 1311 RelocIterator iter(caller_nm, call_addr, call_addr+1); | |
| 1312 int ret = iter.next(); // Get item | |
| 1313 if (ret) { | |
| 1314 assert(iter.addr() == call_addr, "must find call"); | |
| 1315 if (iter.type() == relocInfo::static_call_type) { | |
| 1316 is_static_call = true; | |
| 1317 } else { | |
| 1318 assert(iter.type() == relocInfo::virtual_call_type || | |
| 1319 iter.type() == relocInfo::opt_virtual_call_type | |
| 1320 , "unexpected relocInfo. type"); | |
| 1321 } | |
| 1322 } else { | |
| 1323 assert(!UseInlineCaches, "relocation info. must exist for this address"); | |
| 1324 } | |
| 1325 | |
| 1326 // Cleaning the inline cache will force a new resolve. This is more robust | |
| 1327 // than directly setting it to the new destination, since resolving of calls | |
| 1328 // is always done through the same code path. (experience shows that it | |
| 1329 // leads to very hard to track down bugs, if an inline cache gets updated | |
| 1330 // to a wrong method). It should not be performance critical, since the | |
| 1331 // resolve is only done once. | |
| 1332 | |
| 1333 MutexLocker ml(CompiledIC_lock); | |
| 1334 // | |
| 1335 // We do not patch the call site if the nmethod has been made non-entrant | |
| 1336 // as it is a waste of time | |
| 1337 // | |
| 1338 if (caller_nm->is_in_use()) { | |
| 1339 if (is_static_call) { | |
| 1340 CompiledStaticCall* ssc= compiledStaticCall_at(call_addr); | |
| 1341 ssc->set_to_clean(); | |
| 1342 } else { | |
| 1343 // compiled, dispatched call (which used to call an interpreted method) | |
| 1344 CompiledIC* inline_cache = CompiledIC_at(call_addr); | |
| 1345 inline_cache->set_to_clean(); | |
| 1346 } | |
| 1347 } | |
| 1348 } | |
| 1349 | |
| 1350 } | |
| 1351 | |
| 1352 methodHandle callee_method = find_callee_method(thread, CHECK_(methodHandle())); | |
| 1353 | |
| 1354 | |
| 1355 #ifndef PRODUCT | |
| 1356 Atomic::inc(&_wrong_method_ctr); | |
| 1357 | |
| 1358 if (TraceCallFixup) { | |
| 1359 ResourceMark rm(thread); | |
| 1360 tty->print("handle_wrong_method reresolving call to"); | |
| 1361 callee_method->print_short_name(tty); | |
| 1362 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1363 } | |
| 1364 #endif | |
| 1365 | |
| 1366 return callee_method; | |
| 1367 } | |
| 1368 | |
| 1369 // --------------------------------------------------------------------------- | |
| 1370 // We are calling the interpreter via a c2i. Normally this would mean that | |
| 1371 // we were called by a compiled method. However we could have lost a race | |
| 1372 // where we went int -> i2c -> c2i and so the caller could in fact be | |
| 1373 // interpreted. If the caller is compiled we attampt to patch the caller | |
| 1374 // so he no longer calls into the interpreter. | |
| 1375 IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(methodOopDesc* method, address caller_pc)) | |
| 1376 methodOop moop(method); | |
| 1377 | |
| 1378 address entry_point = moop->from_compiled_entry(); | |
| 1379 | |
| 1380 // It's possible that deoptimization can occur at a call site which hasn't | |
| 1381 // been resolved yet, in which case this function will be called from | |
| 1382 // an nmethod that has been patched for deopt and we can ignore the | |
| 1383 // request for a fixup. | |
| 1384 // Also it is possible that we lost a race in that from_compiled_entry | |
| 1385 // is now back to the i2c in that case we don't need to patch and if | |
| 1386 // we did we'd leap into space because the callsite needs to use | |
| 1387 // "to interpreter" stub in order to load up the methodOop. Don't | |
| 1388 // ask me how I know this... | |
| 1389 // | |
| 1390 | |
| 1391 CodeBlob* cb = CodeCache::find_blob(caller_pc); | |
| 1392 if ( !cb->is_nmethod() || entry_point == moop->get_c2i_entry()) { | |
| 1393 return; | |
| 1394 } | |
| 1395 | |
| 1396 // There is a benign race here. We could be attempting to patch to a compiled | |
| 1397 // entry point at the same time the callee is being deoptimized. If that is | |
| 1398 // the case then entry_point may in fact point to a c2i and we'd patch the | |
| 1399 // call site with the same old data. clear_code will set code() to NULL | |
| 1400 // at the end of it. If we happen to see that NULL then we can skip trying | |
| 1401 // to patch. If we hit the window where the callee has a c2i in the | |
| 1402 // from_compiled_entry and the NULL isn't present yet then we lose the race | |
| 1403 // and patch the code with the same old data. Asi es la vida. | |
| 1404 | |
| 1405 if (moop->code() == NULL) return; | |
| 1406 | |
| 1407 if (((nmethod*)cb)->is_in_use()) { | |
| 1408 | |
| 1409 // Expect to find a native call there (unless it was no-inline cache vtable dispatch) | |
| 1410 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag); | |
| 1411 if (NativeCall::is_call_before(caller_pc + frame::pc_return_offset)) { | |
| 1412 NativeCall *call = nativeCall_before(caller_pc + frame::pc_return_offset); | |
| 1413 // | |
| 1414 // bug 6281185. We might get here after resolving a call site to a vanilla | |
| 1415 // virtual call. Because the resolvee uses the verified entry it may then | |
| 1416 // see compiled code and attempt to patch the site by calling us. This would | |
| 1417 // then incorrectly convert the call site to optimized and its downhill from | |
| 1418 // there. If you're lucky you'll get the assert in the bugid, if not you've | |
| 1419 // just made a call site that could be megamorphic into a monomorphic site | |
| 1420 // for the rest of its life! Just another racing bug in the life of | |
| 1421 // fixup_callers_callsite ... | |
| 1422 // | |
| 1423 RelocIterator iter(cb, call->instruction_address(), call->next_instruction_address()); | |
| 1424 iter.next(); | |
| 1425 assert(iter.has_current(), "must have a reloc at java call site"); | |
| 1426 relocInfo::relocType typ = iter.reloc()->type(); | |
| 1427 if ( typ != relocInfo::static_call_type && | |
| 1428 typ != relocInfo::opt_virtual_call_type && | |
| 1429 typ != relocInfo::static_stub_type) { | |
| 1430 return; | |
| 1431 } | |
| 1432 address destination = call->destination(); | |
| 1433 if (destination != entry_point) { | |
| 1434 CodeBlob* callee = CodeCache::find_blob(destination); | |
| 1435 // callee == cb seems weird. It means calling interpreter thru stub. | |
| 1436 if (callee == cb || callee->is_adapter_blob()) { | |
| 1437 // static call or optimized virtual | |
| 1438 if (TraceCallFixup) { | |
| 1439 tty->print("fixup callsite at " INTPTR_FORMAT " to compiled code for", caller_pc); | |
| 1440 moop->print_short_name(tty); | |
| 1441 tty->print_cr(" to " INTPTR_FORMAT, entry_point); | |
| 1442 } | |
| 1443 call->set_destination_mt_safe(entry_point); | |
| 1444 } else { | |
| 1445 if (TraceCallFixup) { | |
| 1446 tty->print("failed to fixup callsite at " INTPTR_FORMAT " to compiled code for", caller_pc); | |
| 1447 moop->print_short_name(tty); | |
| 1448 tty->print_cr(" to " INTPTR_FORMAT, entry_point); | |
| 1449 } | |
| 1450 // assert is too strong could also be resolve destinations. | |
| 1451 // assert(InlineCacheBuffer::contains(destination) || VtableStubs::contains(destination), "must be"); | |
| 1452 } | |
| 1453 } else { | |
| 1454 if (TraceCallFixup) { | |
| 1455 tty->print("already patched callsite at " INTPTR_FORMAT " to compiled code for", caller_pc); | |
| 1456 moop->print_short_name(tty); | |
| 1457 tty->print_cr(" to " INTPTR_FORMAT, entry_point); | |
| 1458 } | |
| 1459 } | |
| 1460 } | |
| 1461 } | |
| 1462 | |
| 1463 IRT_END | |
| 1464 | |
| 1465 | |
| 1466 // same as JVM_Arraycopy, but called directly from compiled code | |
| 1467 JRT_ENTRY(void, SharedRuntime::slow_arraycopy_C(oopDesc* src, jint src_pos, | |
| 1468 oopDesc* dest, jint dest_pos, | |
| 1469 jint length, | |
| 1470 JavaThread* thread)) { | |
| 1471 #ifndef PRODUCT | |
| 1472 _slow_array_copy_ctr++; | |
| 1473 #endif | |
| 1474 // Check if we have null pointers | |
| 1475 if (src == NULL || dest == NULL) { | |
| 1476 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 1477 } | |
| 1478 // Do the copy. The casts to arrayOop are necessary to the copy_array API, | |
| 1479 // even though the copy_array API also performs dynamic checks to ensure | |
| 1480 // that src and dest are truly arrays (and are conformable). | |
| 1481 // The copy_array mechanism is awkward and could be removed, but | |
| 1482 // the compilers don't call this function except as a last resort, | |
| 1483 // so it probably doesn't matter. | |
| 1484 Klass::cast(src->klass())->copy_array((arrayOopDesc*)src, src_pos, | |
| 1485 (arrayOopDesc*)dest, dest_pos, | |
| 1486 length, thread); | |
| 1487 } | |
| 1488 JRT_END | |
| 1489 | |
| 1490 char* SharedRuntime::generate_class_cast_message( | |
| 1491 JavaThread* thread, const char* objName) { | |
| 1492 | |
| 1493 // Get target class name from the checkcast instruction | |
| 1494 vframeStream vfst(thread, true); | |
| 1495 assert(!vfst.at_end(), "Java frame must exist"); | |
| 1496 Bytecode_checkcast* cc = Bytecode_checkcast_at( | |
| 1497 vfst.method()->bcp_from(vfst.bci())); | |
| 1498 Klass* targetKlass = Klass::cast(vfst.method()->constants()->klass_at( | |
| 1499 cc->index(), thread)); | |
| 1500 return generate_class_cast_message(objName, targetKlass->external_name()); | |
| 1501 } | |
| 1502 | |
| 1503 char* SharedRuntime::generate_class_cast_message( | |
| 1504 const char* objName, const char* targetKlassName) { | |
| 1505 const char* desc = " cannot be cast to "; | |
| 1506 size_t msglen = strlen(objName) + strlen(desc) + strlen(targetKlassName) + 1; | |
| 1507 | |
| 53 | 1508 char* message = NEW_RESOURCE_ARRAY(char, msglen); |
| 0 | 1509 if (NULL == message) { |
| 53 | 1510 // Shouldn't happen, but don't cause even more problems if it does |
| 0 | 1511 message = const_cast<char*>(objName); |
| 1512 } else { | |
| 1513 jio_snprintf(message, msglen, "%s%s%s", objName, desc, targetKlassName); | |
| 1514 } | |
| 1515 return message; | |
| 1516 } | |
| 1517 | |
| 1518 JRT_LEAF(void, SharedRuntime::reguard_yellow_pages()) | |
| 1519 (void) JavaThread::current()->reguard_stack(); | |
| 1520 JRT_END | |
| 1521 | |
| 1522 | |
| 1523 // Handles the uncommon case in locking, i.e., contention or an inflated lock. | |
| 1524 #ifndef PRODUCT | |
| 1525 int SharedRuntime::_monitor_enter_ctr=0; | |
| 1526 #endif | |
| 1527 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::complete_monitor_locking_C(oopDesc* _obj, BasicLock* lock, JavaThread* thread)) | |
| 1528 oop obj(_obj); | |
| 1529 #ifndef PRODUCT | |
| 1530 _monitor_enter_ctr++; // monitor enter slow | |
| 1531 #endif | |
| 1532 if (PrintBiasedLockingStatistics) { | |
| 1533 Atomic::inc(BiasedLocking::slow_path_entry_count_addr()); | |
| 1534 } | |
| 1535 Handle h_obj(THREAD, obj); | |
| 1536 if (UseBiasedLocking) { | |
| 1537 // Retry fast entry if bias is revoked to avoid unnecessary inflation | |
| 1538 ObjectSynchronizer::fast_enter(h_obj, lock, true, CHECK); | |
| 1539 } else { | |
| 1540 ObjectSynchronizer::slow_enter(h_obj, lock, CHECK); | |
| 1541 } | |
| 1542 assert(!HAS_PENDING_EXCEPTION, "Should have no exception here"); | |
| 1543 JRT_END | |
| 1544 | |
| 1545 #ifndef PRODUCT | |
| 1546 int SharedRuntime::_monitor_exit_ctr=0; | |
| 1547 #endif | |
| 1548 // Handles the uncommon cases of monitor unlocking in compiled code | |
| 1549 JRT_LEAF(void, SharedRuntime::complete_monitor_unlocking_C(oopDesc* _obj, BasicLock* lock)) | |
| 1550 oop obj(_obj); | |
| 1551 #ifndef PRODUCT | |
| 1552 _monitor_exit_ctr++; // monitor exit slow | |
| 1553 #endif | |
| 1554 Thread* THREAD = JavaThread::current(); | |
| 1555 // I'm not convinced we need the code contained by MIGHT_HAVE_PENDING anymore | |
| 1556 // testing was unable to ever fire the assert that guarded it so I have removed it. | |
| 1557 assert(!HAS_PENDING_EXCEPTION, "Do we need code below anymore?"); | |
| 1558 #undef MIGHT_HAVE_PENDING | |
| 1559 #ifdef MIGHT_HAVE_PENDING | |
| 1560 // Save and restore any pending_exception around the exception mark. | |
| 1561 // While the slow_exit must not throw an exception, we could come into | |
| 1562 // this routine with one set. | |
| 1563 oop pending_excep = NULL; | |
| 1564 const char* pending_file; | |
| 1565 int pending_line; | |
| 1566 if (HAS_PENDING_EXCEPTION) { | |
| 1567 pending_excep = PENDING_EXCEPTION; | |
| 1568 pending_file = THREAD->exception_file(); | |
| 1569 pending_line = THREAD->exception_line(); | |
| 1570 CLEAR_PENDING_EXCEPTION; | |
| 1571 } | |
| 1572 #endif /* MIGHT_HAVE_PENDING */ | |
| 1573 | |
| 1574 { | |
| 1575 // Exit must be non-blocking, and therefore no exceptions can be thrown. | |
| 1576 EXCEPTION_MARK; | |
| 1577 ObjectSynchronizer::slow_exit(obj, lock, THREAD); | |
| 1578 } | |
| 1579 | |
| 1580 #ifdef MIGHT_HAVE_PENDING | |
| 1581 if (pending_excep != NULL) { | |
| 1582 THREAD->set_pending_exception(pending_excep, pending_file, pending_line); | |
| 1583 } | |
| 1584 #endif /* MIGHT_HAVE_PENDING */ | |
| 1585 JRT_END | |
| 1586 | |
| 1587 #ifndef PRODUCT | |
| 1588 | |
| 1589 void SharedRuntime::print_statistics() { | |
| 1590 ttyLocker ttyl; | |
| 1591 if (xtty != NULL) xtty->head("statistics type='SharedRuntime'"); | |
| 1592 | |
| 1593 if (_monitor_enter_ctr ) tty->print_cr("%5d monitor enter slow", _monitor_enter_ctr); | |
| 1594 if (_monitor_exit_ctr ) tty->print_cr("%5d monitor exit slow", _monitor_exit_ctr); | |
| 1595 if (_throw_null_ctr) tty->print_cr("%5d implicit null throw", _throw_null_ctr); | |
| 1596 | |
| 1597 SharedRuntime::print_ic_miss_histogram(); | |
| 1598 | |
| 1599 if (CountRemovableExceptions) { | |
| 1600 if (_nof_removable_exceptions > 0) { | |
| 1601 Unimplemented(); // this counter is not yet incremented | |
| 1602 tty->print_cr("Removable exceptions: %d", _nof_removable_exceptions); | |
| 1603 } | |
| 1604 } | |
| 1605 | |
| 1606 // Dump the JRT_ENTRY counters | |
| 1607 if( _new_instance_ctr ) tty->print_cr("%5d new instance requires GC", _new_instance_ctr); | |
| 1608 if( _new_array_ctr ) tty->print_cr("%5d new array requires GC", _new_array_ctr); | |
| 1609 if( _multi1_ctr ) tty->print_cr("%5d multianewarray 1 dim", _multi1_ctr); | |
| 1610 if( _multi2_ctr ) tty->print_cr("%5d multianewarray 2 dim", _multi2_ctr); | |
| 1611 if( _multi3_ctr ) tty->print_cr("%5d multianewarray 3 dim", _multi3_ctr); | |
| 1612 if( _multi4_ctr ) tty->print_cr("%5d multianewarray 4 dim", _multi4_ctr); | |
| 1613 if( _multi5_ctr ) tty->print_cr("%5d multianewarray 5 dim", _multi5_ctr); | |
| 1614 | |
| 1615 tty->print_cr("%5d inline cache miss in compiled", _ic_miss_ctr ); | |
| 1616 tty->print_cr("%5d wrong method", _wrong_method_ctr ); | |
| 1617 tty->print_cr("%5d unresolved static call site", _resolve_static_ctr ); | |
| 1618 tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr ); | |
| 1619 tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr ); | |
| 1620 | |
| 1621 if( _mon_enter_stub_ctr ) tty->print_cr("%5d monitor enter stub", _mon_enter_stub_ctr ); | |
| 1622 if( _mon_exit_stub_ctr ) tty->print_cr("%5d monitor exit stub", _mon_exit_stub_ctr ); | |
| 1623 if( _mon_enter_ctr ) tty->print_cr("%5d monitor enter slow", _mon_enter_ctr ); | |
| 1624 if( _mon_exit_ctr ) tty->print_cr("%5d monitor exit slow", _mon_exit_ctr ); | |
| 1625 if( _partial_subtype_ctr) tty->print_cr("%5d slow partial subtype", _partial_subtype_ctr ); | |
| 1626 if( _jbyte_array_copy_ctr ) tty->print_cr("%5d byte array copies", _jbyte_array_copy_ctr ); | |
| 1627 if( _jshort_array_copy_ctr ) tty->print_cr("%5d short array copies", _jshort_array_copy_ctr ); | |
| 1628 if( _jint_array_copy_ctr ) tty->print_cr("%5d int array copies", _jint_array_copy_ctr ); | |
| 1629 if( _jlong_array_copy_ctr ) tty->print_cr("%5d long array copies", _jlong_array_copy_ctr ); | |
| 1630 if( _oop_array_copy_ctr ) tty->print_cr("%5d oop array copies", _oop_array_copy_ctr ); | |
| 1631 if( _checkcast_array_copy_ctr ) tty->print_cr("%5d checkcast array copies", _checkcast_array_copy_ctr ); | |
| 1632 if( _unsafe_array_copy_ctr ) tty->print_cr("%5d unsafe array copies", _unsafe_array_copy_ctr ); | |
| 1633 if( _generic_array_copy_ctr ) tty->print_cr("%5d generic array copies", _generic_array_copy_ctr ); | |
| 1634 if( _slow_array_copy_ctr ) tty->print_cr("%5d slow array copies", _slow_array_copy_ctr ); | |
| 1635 if( _find_handler_ctr ) tty->print_cr("%5d find exception handler", _find_handler_ctr ); | |
| 1636 if( _rethrow_ctr ) tty->print_cr("%5d rethrow handler", _rethrow_ctr ); | |
| 1637 | |
| 1638 if (xtty != NULL) xtty->tail("statistics"); | |
| 1639 } | |
| 1640 | |
| 1641 inline double percent(int x, int y) { | |
| 1642 return 100.0 * x / MAX2(y, 1); | |
| 1643 } | |
| 1644 | |
| 1645 class MethodArityHistogram { | |
| 1646 public: | |
| 1647 enum { MAX_ARITY = 256 }; | |
| 1648 private: | |
| 1649 static int _arity_histogram[MAX_ARITY]; // histogram of #args | |
| 1650 static int _size_histogram[MAX_ARITY]; // histogram of arg size in words | |
| 1651 static int _max_arity; // max. arity seen | |
| 1652 static int _max_size; // max. arg size seen | |
| 1653 | |
| 1654 static void add_method_to_histogram(nmethod* nm) { | |
| 1655 methodOop m = nm->method(); | |
| 1656 ArgumentCount args(m->signature()); | |
| 1657 int arity = args.size() + (m->is_static() ? 0 : 1); | |
| 1658 int argsize = m->size_of_parameters(); | |
| 1659 arity = MIN2(arity, MAX_ARITY-1); | |
| 1660 argsize = MIN2(argsize, MAX_ARITY-1); | |
| 1661 int count = nm->method()->compiled_invocation_count(); | |
| 1662 _arity_histogram[arity] += count; | |
| 1663 _size_histogram[argsize] += count; | |
| 1664 _max_arity = MAX2(_max_arity, arity); | |
| 1665 _max_size = MAX2(_max_size, argsize); | |
| 1666 } | |
| 1667 | |
| 1668 void print_histogram_helper(int n, int* histo, const char* name) { | |
| 1669 const int N = MIN2(5, n); | |
| 1670 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):"); | |
| 1671 double sum = 0; | |
| 1672 double weighted_sum = 0; | |
| 1673 int i; | |
| 1674 for (i = 0; i <= n; i++) { sum += histo[i]; weighted_sum += i*histo[i]; } | |
| 1675 double rest = sum; | |
| 1676 double percent = sum / 100; | |
| 1677 for (i = 0; i <= N; i++) { | |
| 1678 rest -= histo[i]; | |
| 1679 tty->print_cr("%4d: %7d (%5.1f%%)", i, histo[i], histo[i] / percent); | |
| 1680 } | |
| 1681 tty->print_cr("rest: %7d (%5.1f%%))", (int)rest, rest / percent); | |
| 1682 tty->print_cr("(avg. %s = %3.1f, max = %d)", name, weighted_sum / sum, n); | |
| 1683 } | |
| 1684 | |
| 1685 void print_histogram() { | |
| 1686 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):"); | |
| 1687 print_histogram_helper(_max_arity, _arity_histogram, "arity"); | |
| 1688 tty->print_cr("\nSame for parameter size (in words):"); | |
| 1689 print_histogram_helper(_max_size, _size_histogram, "size"); | |
| 1690 tty->cr(); | |
| 1691 } | |
| 1692 | |
| 1693 public: | |
| 1694 MethodArityHistogram() { | |
| 1695 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
| 1696 _max_arity = _max_size = 0; | |
| 1697 for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram [i] = 0; | |
| 1698 CodeCache::nmethods_do(add_method_to_histogram); | |
| 1699 print_histogram(); | |
| 1700 } | |
| 1701 }; | |
| 1702 | |
| 1703 int MethodArityHistogram::_arity_histogram[MethodArityHistogram::MAX_ARITY]; | |
| 1704 int MethodArityHistogram::_size_histogram[MethodArityHistogram::MAX_ARITY]; | |
| 1705 int MethodArityHistogram::_max_arity; | |
| 1706 int MethodArityHistogram::_max_size; | |
| 1707 | |
| 1708 void SharedRuntime::print_call_statistics(int comp_total) { | |
| 1709 tty->print_cr("Calls from compiled code:"); | |
| 1710 int total = _nof_normal_calls + _nof_interface_calls + _nof_static_calls; | |
| 1711 int mono_c = _nof_normal_calls - _nof_optimized_calls - _nof_megamorphic_calls; | |
| 1712 int mono_i = _nof_interface_calls - _nof_optimized_interface_calls - _nof_megamorphic_interface_calls; | |
| 1713 tty->print_cr("\t%9d (%4.1f%%) total non-inlined ", total, percent(total, total)); | |
| 1714 tty->print_cr("\t%9d (%4.1f%%) virtual calls ", _nof_normal_calls, percent(_nof_normal_calls, total)); | |
| 1715 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_calls, percent(_nof_inlined_calls, _nof_normal_calls)); | |
| 1716 tty->print_cr("\t %9d (%3.0f%%) optimized ", _nof_optimized_calls, percent(_nof_optimized_calls, _nof_normal_calls)); | |
| 1717 tty->print_cr("\t %9d (%3.0f%%) monomorphic ", mono_c, percent(mono_c, _nof_normal_calls)); | |
| 1718 tty->print_cr("\t %9d (%3.0f%%) megamorphic ", _nof_megamorphic_calls, percent(_nof_megamorphic_calls, _nof_normal_calls)); | |
| 1719 tty->print_cr("\t%9d (%4.1f%%) interface calls ", _nof_interface_calls, percent(_nof_interface_calls, total)); | |
| 1720 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_interface_calls, percent(_nof_inlined_interface_calls, _nof_interface_calls)); | |
| 1721 tty->print_cr("\t %9d (%3.0f%%) optimized ", _nof_optimized_interface_calls, percent(_nof_optimized_interface_calls, _nof_interface_calls)); | |
| 1722 tty->print_cr("\t %9d (%3.0f%%) monomorphic ", mono_i, percent(mono_i, _nof_interface_calls)); | |
| 1723 tty->print_cr("\t %9d (%3.0f%%) megamorphic ", _nof_megamorphic_interface_calls, percent(_nof_megamorphic_interface_calls, _nof_interface_calls)); | |
| 1724 tty->print_cr("\t%9d (%4.1f%%) static/special calls", _nof_static_calls, percent(_nof_static_calls, total)); | |
| 1725 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_static_calls, percent(_nof_inlined_static_calls, _nof_static_calls)); | |
| 1726 tty->cr(); | |
| 1727 tty->print_cr("Note 1: counter updates are not MT-safe."); | |
| 1728 tty->print_cr("Note 2: %% in major categories are relative to total non-inlined calls;"); | |
| 1729 tty->print_cr(" %% in nested categories are relative to their category"); | |
| 1730 tty->print_cr(" (and thus add up to more than 100%% with inlining)"); | |
| 1731 tty->cr(); | |
| 1732 | |
| 1733 MethodArityHistogram h; | |
| 1734 } | |
| 1735 #endif | |
| 1736 | |
| 1737 | |
| 1738 // --------------------------------------------------------------------------- | |
| 1739 // Implementation of AdapterHandlerLibrary | |
| 1740 const char* AdapterHandlerEntry::name = "I2C/C2I adapters"; | |
| 1741 GrowableArray<uint64_t>* AdapterHandlerLibrary::_fingerprints = NULL; | |
| 1742 GrowableArray<AdapterHandlerEntry* >* AdapterHandlerLibrary::_handlers = NULL; | |
| 1743 const int AdapterHandlerLibrary_size = 16*K; | |
| 1744 u_char AdapterHandlerLibrary::_buffer[AdapterHandlerLibrary_size + 32]; | |
| 1745 | |
| 1746 void AdapterHandlerLibrary::initialize() { | |
| 1747 if (_fingerprints != NULL) return; | |
| 1748 _fingerprints = new(ResourceObj::C_HEAP)GrowableArray<uint64_t>(32, true); | |
| 1749 _handlers = new(ResourceObj::C_HEAP)GrowableArray<AdapterHandlerEntry*>(32, true); | |
| 1750 // Index 0 reserved for the slow path handler | |
| 1751 _fingerprints->append(0/*the never-allowed 0 fingerprint*/); | |
| 1752 _handlers->append(NULL); | |
| 1753 | |
| 1754 // Create a special handler for abstract methods. Abstract methods | |
| 1755 // are never compiled so an i2c entry is somewhat meaningless, but | |
| 1756 // fill it in with something appropriate just in case. Pass handle | |
| 1757 // wrong method for the c2i transitions. | |
| 1758 address wrong_method = SharedRuntime::get_handle_wrong_method_stub(); | |
| 1759 _fingerprints->append(0/*the never-allowed 0 fingerprint*/); | |
| 1760 assert(_handlers->length() == AbstractMethodHandler, "in wrong slot"); | |
| 1761 _handlers->append(new AdapterHandlerEntry(StubRoutines::throw_AbstractMethodError_entry(), | |
| 1762 wrong_method, wrong_method)); | |
| 1763 } | |
| 1764 | |
| 1765 int AdapterHandlerLibrary::get_create_adapter_index(methodHandle method) { | |
| 1766 // Use customized signature handler. Need to lock around updates to the | |
| 1767 // _fingerprints array (it is not safe for concurrent readers and a single | |
| 1768 // writer: this can be fixed if it becomes a problem). | |
| 1769 | |
| 1770 // Get the address of the ic_miss handlers before we grab the | |
| 1771 // AdapterHandlerLibrary_lock. This fixes bug 6236259 which | |
| 1772 // was caused by the initialization of the stubs happening | |
| 1773 // while we held the lock and then notifying jvmti while | |
| 1774 // holding it. This just forces the initialization to be a little | |
| 1775 // earlier. | |
| 1776 address ic_miss = SharedRuntime::get_ic_miss_stub(); | |
| 1777 assert(ic_miss != NULL, "must have handler"); | |
| 1778 | |
| 1779 int result; | |
| 1780 BufferBlob *B = NULL; | |
| 1781 uint64_t fingerprint; | |
| 1782 { | |
| 1783 MutexLocker mu(AdapterHandlerLibrary_lock); | |
| 1784 // make sure data structure is initialized | |
| 1785 initialize(); | |
| 1786 | |
| 1787 if (method->is_abstract()) { | |
| 1788 return AbstractMethodHandler; | |
| 1789 } | |
| 1790 | |
| 1791 // Lookup method signature's fingerprint | |
| 1792 fingerprint = Fingerprinter(method).fingerprint(); | |
| 1793 assert( fingerprint != CONST64( 0), "no zero fingerprints allowed" ); | |
| 1794 // Fingerprints are small fixed-size condensed representations of | |
| 1795 // signatures. If the signature is too large, it won't fit in a | |
| 1796 // fingerprint. Signatures which cannot support a fingerprint get a new i2c | |
| 1797 // adapter gen'd each time, instead of searching the cache for one. This -1 | |
| 1798 // game can be avoided if I compared signatures instead of using | |
| 1799 // fingerprints. However, -1 fingerprints are very rare. | |
| 1800 if( fingerprint != UCONST64(-1) ) { // If this is a cache-able fingerprint | |
| 1801 // Turns out i2c adapters do not care what the return value is. Mask it | |
| 1802 // out so signatures that only differ in return type will share the same | |
| 1803 // adapter. | |
| 1804 fingerprint &= ~(SignatureIterator::result_feature_mask << SignatureIterator::static_feature_size); | |
| 1805 // Search for a prior existing i2c/c2i adapter | |
| 1806 int index = _fingerprints->find(fingerprint); | |
| 1807 if( index >= 0 ) return index; // Found existing handlers? | |
| 1808 } else { | |
| 1809 // Annoyingly, I end up adding -1 fingerprints to the array of handlers, | |
| 1810 // because I need a unique handler index. It cannot be scanned for | |
| 1811 // because all -1's look alike. Instead, the matching index is passed out | |
| 1812 // and immediately used to collect the 2 return values (the c2i and i2c | |
| 1813 // adapters). | |
| 1814 } | |
| 1815 | |
| 1816 // Create I2C & C2I handlers | |
| 1817 ResourceMark rm; | |
| 1818 // Improve alignment slightly | |
| 1819 u_char *buf = (u_char*)(((intptr_t)_buffer + CodeEntryAlignment-1) & ~(CodeEntryAlignment-1)); | |
| 1820 CodeBuffer buffer(buf, AdapterHandlerLibrary_size); | |
| 1821 short buffer_locs[20]; | |
| 1822 buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs, | |
| 1823 sizeof(buffer_locs)/sizeof(relocInfo)); | |
| 1824 MacroAssembler _masm(&buffer); | |
| 1825 | |
| 1826 // Fill in the signature array, for the calling-convention call. | |
| 1827 int total_args_passed = method->size_of_parameters(); // All args on stack | |
| 1828 | |
| 1829 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed); | |
| 1830 VMRegPair * regs = NEW_RESOURCE_ARRAY(VMRegPair ,total_args_passed); | |
| 1831 int i=0; | |
| 1832 if( !method->is_static() ) // Pass in receiver first | |
| 1833 sig_bt[i++] = T_OBJECT; | |
| 1834 for( SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) { | |
| 1835 sig_bt[i++] = ss.type(); // Collect remaining bits of signature | |
| 1836 if( ss.type() == T_LONG || ss.type() == T_DOUBLE ) | |
| 1837 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots | |
| 1838 } | |
| 1839 assert( i==total_args_passed, "" ); | |
| 1840 | |
| 1841 // Now get the re-packed compiled-Java layout. | |
| 1842 int comp_args_on_stack; | |
| 1843 | |
| 1844 // Get a description of the compiled java calling convention and the largest used (VMReg) stack slot usage | |
| 1845 comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false); | |
| 1846 | |
| 1847 AdapterHandlerEntry* entry = SharedRuntime::generate_i2c2i_adapters(&_masm, | |
| 1848 total_args_passed, | |
| 1849 comp_args_on_stack, | |
| 1850 sig_bt, | |
| 1851 regs); | |
| 1852 | |
| 1853 B = BufferBlob::create(AdapterHandlerEntry::name, &buffer); | |
| 28 | 1854 if (B == NULL) { |
| 1855 // CodeCache is full, disable compilation | |
| 1856 // Ought to log this but compile log is only per compile thread | |
| 1857 // and we're some non descript Java thread. | |
| 1858 UseInterpreter = true; | |
| 1859 if (UseCompiler || AlwaysCompileLoopMethods ) { | |
| 1860 #ifndef PRODUCT | |
| 1861 warning("CodeCache is full. Compiler has been disabled"); | |
| 1862 if (CompileTheWorld || ExitOnFullCodeCache) { | |
| 1863 before_exit(JavaThread::current()); | |
| 1864 exit_globals(); // will delete tty | |
| 1865 vm_direct_exit(CompileTheWorld ? 0 : 1); | |
| 1866 } | |
| 1867 #endif | |
| 1868 UseCompiler = false; | |
| 1869 AlwaysCompileLoopMethods = false; | |
| 1870 } | |
| 1871 return 0; // Out of CodeCache space (_handlers[0] == NULL) | |
| 1872 } | |
| 0 | 1873 entry->relocate(B->instructions_begin()); |
| 1874 #ifndef PRODUCT | |
| 1875 // debugging suppport | |
| 1876 if (PrintAdapterHandlers) { | |
| 1877 tty->cr(); | |
| 1878 tty->print_cr("i2c argument handler #%d for: %s %s (fingerprint = 0x%llx, %d bytes generated)", | |
| 1879 _handlers->length(), (method->is_static() ? "static" : "receiver"), | |
| 1880 method->signature()->as_C_string(), fingerprint, buffer.code_size() ); | |
| 1881 tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry()); | |
| 1882 Disassembler::decode(entry->get_i2c_entry(), entry->get_i2c_entry() + buffer.code_size()); | |
| 1883 } | |
| 1884 #endif | |
| 1885 | |
| 1886 // add handlers to library | |
| 1887 _fingerprints->append(fingerprint); | |
| 1888 _handlers->append(entry); | |
| 1889 // set handler index | |
| 1890 assert(_fingerprints->length() == _handlers->length(), "sanity check"); | |
| 1891 result = _fingerprints->length() - 1; | |
| 1892 } | |
| 1893 // Outside of the lock | |
| 1894 if (B != NULL) { | |
| 1895 char blob_id[256]; | |
| 1896 jio_snprintf(blob_id, | |
| 1897 sizeof(blob_id), | |
| 1898 "%s(" PTR64_FORMAT ")@" PTR_FORMAT, | |
| 1899 AdapterHandlerEntry::name, | |
| 1900 fingerprint, | |
| 1901 B->instructions_begin()); | |
| 1902 VTune::register_stub(blob_id, B->instructions_begin(), B->instructions_end()); | |
| 1903 Forte::register_stub(blob_id, B->instructions_begin(), B->instructions_end()); | |
| 1904 | |
| 1905 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
| 1906 JvmtiExport::post_dynamic_code_generated(blob_id, | |
| 1907 B->instructions_begin(), | |
| 1908 B->instructions_end()); | |
| 1909 } | |
| 1910 } | |
| 1911 return result; | |
| 1912 } | |
| 1913 | |
| 1914 void AdapterHandlerEntry::relocate(address new_base) { | |
| 1915 ptrdiff_t delta = new_base - _i2c_entry; | |
| 1916 _i2c_entry += delta; | |
| 1917 _c2i_entry += delta; | |
| 1918 _c2i_unverified_entry += delta; | |
| 1919 } | |
| 1920 | |
| 1921 // Create a native wrapper for this native method. The wrapper converts the | |
| 1922 // java compiled calling convention to the native convention, handlizes | |
| 1923 // arguments, and transitions to native. On return from the native we transition | |
| 1924 // back to java blocking if a safepoint is in progress. | |
| 1925 nmethod *AdapterHandlerLibrary::create_native_wrapper(methodHandle method) { | |
| 1926 ResourceMark rm; | |
| 1927 nmethod* nm = NULL; | |
| 1928 | |
| 1929 if (PrintCompilation) { | |
| 1930 ttyLocker ttyl; | |
| 1931 tty->print("--- n%s ", (method->is_synchronized() ? "s" : " ")); | |
| 1932 method->print_short_name(tty); | |
| 1933 if (method->is_static()) { | |
| 1934 tty->print(" (static)"); | |
| 1935 } | |
| 1936 tty->cr(); | |
| 1937 } | |
| 1938 | |
| 1939 assert(method->has_native_function(), "must have something valid to call!"); | |
| 1940 | |
| 1941 { | |
| 1942 // perform the work while holding the lock, but perform any printing outside the lock | |
| 1943 MutexLocker mu(AdapterHandlerLibrary_lock); | |
| 1944 // See if somebody beat us to it | |
| 1945 nm = method->code(); | |
| 1946 if (nm) { | |
| 1947 return nm; | |
| 1948 } | |
| 1949 | |
| 1950 // Improve alignment slightly | |
| 1951 u_char* buf = (u_char*)(((intptr_t)_buffer + CodeEntryAlignment-1) & ~(CodeEntryAlignment-1)); | |
| 1952 CodeBuffer buffer(buf, AdapterHandlerLibrary_size); | |
| 1953 // Need a few relocation entries | |
| 1954 double locs_buf[20]; | |
| 1955 buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo)); | |
| 1956 MacroAssembler _masm(&buffer); | |
| 1957 | |
| 1958 // Fill in the signature array, for the calling-convention call. | |
| 1959 int total_args_passed = method->size_of_parameters(); | |
| 1960 | |
| 1961 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed); | |
| 1962 VMRegPair * regs = NEW_RESOURCE_ARRAY(VMRegPair ,total_args_passed); | |
| 1963 int i=0; | |
| 1964 if( !method->is_static() ) // Pass in receiver first | |
| 1965 sig_bt[i++] = T_OBJECT; | |
| 1966 SignatureStream ss(method->signature()); | |
| 1967 for( ; !ss.at_return_type(); ss.next()) { | |
| 1968 sig_bt[i++] = ss.type(); // Collect remaining bits of signature | |
| 1969 if( ss.type() == T_LONG || ss.type() == T_DOUBLE ) | |
| 1970 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots | |
| 1971 } | |
| 1972 assert( i==total_args_passed, "" ); | |
| 1973 BasicType ret_type = ss.type(); | |
| 1974 | |
| 1975 // Now get the compiled-Java layout as input arguments | |
| 1976 int comp_args_on_stack; | |
| 1977 comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false); | |
| 1978 | |
| 1979 // Generate the compiled-to-native wrapper code | |
| 1980 nm = SharedRuntime::generate_native_wrapper(&_masm, | |
| 1981 method, | |
| 1982 total_args_passed, | |
| 1983 comp_args_on_stack, | |
| 1984 sig_bt,regs, | |
| 1985 ret_type); | |
| 1986 } | |
| 1987 | |
| 1988 // Must unlock before calling set_code | |
| 1989 // Install the generated code. | |
| 1990 if (nm != NULL) { | |
| 1991 method->set_code(method, nm); | |
| 1992 nm->post_compiled_method_load_event(); | |
| 1993 } else { | |
| 1994 // CodeCache is full, disable compilation | |
| 1995 // Ought to log this but compile log is only per compile thread | |
| 1996 // and we're some non descript Java thread. | |
| 1997 UseInterpreter = true; | |
| 1998 if (UseCompiler || AlwaysCompileLoopMethods ) { | |
| 1999 #ifndef PRODUCT | |
| 2000 warning("CodeCache is full. Compiler has been disabled"); | |
| 2001 if (CompileTheWorld || ExitOnFullCodeCache) { | |
| 2002 before_exit(JavaThread::current()); | |
| 2003 exit_globals(); // will delete tty | |
| 2004 vm_direct_exit(CompileTheWorld ? 0 : 1); | |
| 2005 } | |
| 2006 #endif | |
| 2007 UseCompiler = false; | |
| 2008 AlwaysCompileLoopMethods = false; | |
| 2009 } | |
| 2010 } | |
| 2011 return nm; | |
| 2012 } | |
| 2013 | |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2014 #ifdef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2015 // Create a dtrace nmethod for this method. The wrapper converts the |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2016 // java compiled calling convention to the native convention, makes a dummy call |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2017 // (actually nops for the size of the call instruction, which become a trap if |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2018 // probe is enabled). The returns to the caller. Since this all looks like a |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2019 // leaf no thread transition is needed. |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2020 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2021 nmethod *AdapterHandlerLibrary::create_dtrace_nmethod(methodHandle method) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2022 ResourceMark rm; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2023 nmethod* nm = NULL; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2024 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2025 if (PrintCompilation) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2026 ttyLocker ttyl; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2027 tty->print("--- n%s "); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2028 method->print_short_name(tty); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2029 if (method->is_static()) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2030 tty->print(" (static)"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2031 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2032 tty->cr(); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2033 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2034 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2035 { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2036 // perform the work while holding the lock, but perform any printing |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2037 // outside the lock |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2038 MutexLocker mu(AdapterHandlerLibrary_lock); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2039 // See if somebody beat us to it |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2040 nm = method->code(); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2041 if (nm) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2042 return nm; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2043 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2044 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2045 // Improve alignment slightly |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2046 u_char* buf = (u_char*) |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2047 (((intptr_t)_buffer + CodeEntryAlignment-1) & ~(CodeEntryAlignment-1)); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2048 CodeBuffer buffer(buf, AdapterHandlerLibrary_size); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2049 // Need a few relocation entries |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2050 double locs_buf[20]; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2051 buffer.insts()->initialize_shared_locs( |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2052 (relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo)); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2053 MacroAssembler _masm(&buffer); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2054 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2055 // Generate the compiled-to-native wrapper code |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2056 nm = SharedRuntime::generate_dtrace_nmethod(&_masm, method); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2057 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2058 return nm; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2059 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2060 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2061 // the dtrace method needs to convert java lang string to utf8 string. |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2062 void SharedRuntime::get_utf(oopDesc* src, address dst) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2063 typeArrayOop jlsValue = java_lang_String::value(src); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2064 int jlsOffset = java_lang_String::offset(src); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2065 int jlsLen = java_lang_String::length(src); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2066 jchar* jlsPos = (jlsLen == 0) ? NULL : |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2067 jlsValue->char_at_addr(jlsOffset); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2068 (void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2069 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2070 #endif // ndef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2071 |
| 0 | 2072 // ------------------------------------------------------------------------- |
| 2073 // Java-Java calling convention | |
| 2074 // (what you use when Java calls Java) | |
| 2075 | |
| 2076 //------------------------------name_for_receiver---------------------------------- | |
| 2077 // For a given signature, return the VMReg for parameter 0. | |
| 2078 VMReg SharedRuntime::name_for_receiver() { | |
| 2079 VMRegPair regs; | |
| 2080 BasicType sig_bt = T_OBJECT; | |
| 2081 (void) java_calling_convention(&sig_bt, ®s, 1, true); | |
| 2082 // Return argument 0 register. In the LP64 build pointers | |
| 2083 // take 2 registers, but the VM wants only the 'main' name. | |
| 2084 return regs.first(); | |
| 2085 } | |
| 2086 | |
| 2087 VMRegPair *SharedRuntime::find_callee_arguments(symbolOop sig, bool is_static, int* arg_size) { | |
| 2088 // This method is returning a data structure allocating as a | |
| 2089 // ResourceObject, so do not put any ResourceMarks in here. | |
| 2090 char *s = sig->as_C_string(); | |
| 2091 int len = (int)strlen(s); | |
| 2092 *s++; len--; // Skip opening paren | |
| 2093 char *t = s+len; | |
| 2094 while( *(--t) != ')' ) ; // Find close paren | |
| 2095 | |
| 2096 BasicType *sig_bt = NEW_RESOURCE_ARRAY( BasicType, 256 ); | |
| 2097 VMRegPair *regs = NEW_RESOURCE_ARRAY( VMRegPair, 256 ); | |
| 2098 int cnt = 0; | |
| 2099 if (!is_static) { | |
| 2100 sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature | |
| 2101 } | |
| 2102 | |
| 2103 while( s < t ) { | |
| 2104 switch( *s++ ) { // Switch on signature character | |
| 2105 case 'B': sig_bt[cnt++] = T_BYTE; break; | |
| 2106 case 'C': sig_bt[cnt++] = T_CHAR; break; | |
| 2107 case 'D': sig_bt[cnt++] = T_DOUBLE; sig_bt[cnt++] = T_VOID; break; | |
| 2108 case 'F': sig_bt[cnt++] = T_FLOAT; break; | |
| 2109 case 'I': sig_bt[cnt++] = T_INT; break; | |
| 2110 case 'J': sig_bt[cnt++] = T_LONG; sig_bt[cnt++] = T_VOID; break; | |
| 2111 case 'S': sig_bt[cnt++] = T_SHORT; break; | |
| 2112 case 'Z': sig_bt[cnt++] = T_BOOLEAN; break; | |
| 2113 case 'V': sig_bt[cnt++] = T_VOID; break; | |
| 2114 case 'L': // Oop | |
| 2115 while( *s++ != ';' ) ; // Skip signature | |
| 2116 sig_bt[cnt++] = T_OBJECT; | |
| 2117 break; | |
| 2118 case '[': { // Array | |
| 2119 do { // Skip optional size | |
| 2120 while( *s >= '0' && *s <= '9' ) s++; | |
| 2121 } while( *s++ == '[' ); // Nested arrays? | |
| 2122 // Skip element type | |
| 2123 if( s[-1] == 'L' ) | |
| 2124 while( *s++ != ';' ) ; // Skip signature | |
| 2125 sig_bt[cnt++] = T_ARRAY; | |
| 2126 break; | |
| 2127 } | |
| 2128 default : ShouldNotReachHere(); | |
| 2129 } | |
| 2130 } | |
| 2131 assert( cnt < 256, "grow table size" ); | |
| 2132 | |
| 2133 int comp_args_on_stack; | |
| 2134 comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true); | |
| 2135 | |
| 2136 // the calling convention doesn't count out_preserve_stack_slots so | |
| 2137 // we must add that in to get "true" stack offsets. | |
| 2138 | |
| 2139 if (comp_args_on_stack) { | |
| 2140 for (int i = 0; i < cnt; i++) { | |
| 2141 VMReg reg1 = regs[i].first(); | |
| 2142 if( reg1->is_stack()) { | |
| 2143 // Yuck | |
| 2144 reg1 = reg1->bias(out_preserve_stack_slots()); | |
| 2145 } | |
| 2146 VMReg reg2 = regs[i].second(); | |
| 2147 if( reg2->is_stack()) { | |
| 2148 // Yuck | |
| 2149 reg2 = reg2->bias(out_preserve_stack_slots()); | |
| 2150 } | |
| 2151 regs[i].set_pair(reg2, reg1); | |
| 2152 } | |
| 2153 } | |
| 2154 | |
| 2155 // results | |
| 2156 *arg_size = cnt; | |
| 2157 return regs; | |
| 2158 } | |
| 2159 | |
| 2160 // OSR Migration Code | |
| 2161 // | |
| 2162 // This code is used convert interpreter frames into compiled frames. It is | |
| 2163 // called from very start of a compiled OSR nmethod. A temp array is | |
| 2164 // allocated to hold the interesting bits of the interpreter frame. All | |
| 2165 // active locks are inflated to allow them to move. The displaced headers and | |
| 2166 // active interpeter locals are copied into the temp buffer. Then we return | |
| 2167 // back to the compiled code. The compiled code then pops the current | |
| 2168 // interpreter frame off the stack and pushes a new compiled frame. Then it | |
| 2169 // copies the interpreter locals and displaced headers where it wants. | |
| 2170 // Finally it calls back to free the temp buffer. | |
| 2171 // | |
| 2172 // All of this is done NOT at any Safepoint, nor is any safepoint or GC allowed. | |
| 2173 | |
| 2174 JRT_LEAF(intptr_t*, SharedRuntime::OSR_migration_begin( JavaThread *thread) ) | |
| 2175 | |
| 2176 #ifdef IA64 | |
| 2177 ShouldNotReachHere(); // NYI | |
| 2178 #endif /* IA64 */ | |
| 2179 | |
| 2180 // | |
| 2181 // This code is dependent on the memory layout of the interpreter local | |
| 2182 // array and the monitors. On all of our platforms the layout is identical | |
| 2183 // so this code is shared. If some platform lays the their arrays out | |
| 2184 // differently then this code could move to platform specific code or | |
| 2185 // the code here could be modified to copy items one at a time using | |
| 2186 // frame accessor methods and be platform independent. | |
| 2187 | |
| 2188 frame fr = thread->last_frame(); | |
| 2189 assert( fr.is_interpreted_frame(), "" ); | |
| 2190 assert( fr.interpreter_frame_expression_stack_size()==0, "only handle empty stacks" ); | |
| 2191 | |
| 2192 // Figure out how many monitors are active. | |
| 2193 int active_monitor_count = 0; | |
| 2194 for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end(); | |
| 2195 kptr < fr.interpreter_frame_monitor_begin(); | |
| 2196 kptr = fr.next_monitor_in_interpreter_frame(kptr) ) { | |
| 2197 if( kptr->obj() != NULL ) active_monitor_count++; | |
| 2198 } | |
| 2199 | |
| 2200 // QQQ we could place number of active monitors in the array so that compiled code | |
| 2201 // could double check it. | |
| 2202 | |
| 2203 methodOop moop = fr.interpreter_frame_method(); | |
| 2204 int max_locals = moop->max_locals(); | |
| 2205 // Allocate temp buffer, 1 word per local & 2 per active monitor | |
| 2206 int buf_size_words = max_locals + active_monitor_count*2; | |
| 2207 intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words); | |
| 2208 | |
| 2209 // Copy the locals. Order is preserved so that loading of longs works. | |
| 2210 // Since there's no GC I can copy the oops blindly. | |
| 2211 assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code"); | |
| 2212 if (TaggedStackInterpreter) { | |
| 2213 for (int i = 0; i < max_locals; i++) { | |
| 2214 // copy only each local separately to the buffer avoiding the tag | |
| 2215 buf[i] = *fr.interpreter_frame_local_at(max_locals-i-1); | |
| 2216 } | |
| 2217 } else { | |
| 2218 Copy::disjoint_words( | |
| 2219 (HeapWord*)fr.interpreter_frame_local_at(max_locals-1), | |
| 2220 (HeapWord*)&buf[0], | |
| 2221 max_locals); | |
| 2222 } | |
| 2223 | |
| 2224 // Inflate locks. Copy the displaced headers. Be careful, there can be holes. | |
| 2225 int i = max_locals; | |
| 2226 for( BasicObjectLock *kptr2 = fr.interpreter_frame_monitor_end(); | |
| 2227 kptr2 < fr.interpreter_frame_monitor_begin(); | |
| 2228 kptr2 = fr.next_monitor_in_interpreter_frame(kptr2) ) { | |
| 2229 if( kptr2->obj() != NULL) { // Avoid 'holes' in the monitor array | |
| 2230 BasicLock *lock = kptr2->lock(); | |
| 2231 // Inflate so the displaced header becomes position-independent | |
| 2232 if (lock->displaced_header()->is_unlocked()) | |
| 2233 ObjectSynchronizer::inflate_helper(kptr2->obj()); | |
| 2234 // Now the displaced header is free to move | |
| 2235 buf[i++] = (intptr_t)lock->displaced_header(); | |
| 2236 buf[i++] = (intptr_t)kptr2->obj(); | |
| 2237 } | |
| 2238 } | |
| 2239 assert( i - max_locals == active_monitor_count*2, "found the expected number of monitors" ); | |
| 2240 | |
| 2241 return buf; | |
| 2242 JRT_END | |
| 2243 | |
| 2244 JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) ) | |
| 2245 FREE_C_HEAP_ARRAY(intptr_t,buf); | |
| 2246 JRT_END | |
| 2247 | |
| 2248 #ifndef PRODUCT | |
| 2249 bool AdapterHandlerLibrary::contains(CodeBlob* b) { | |
| 2250 | |
|
124
b130b98db9cf
6689060: Escape Analysis does not work with Compressed Oops
kvn
parents:
62
diff
changeset
|
2251 if (_handlers == NULL) return false; |
|
b130b98db9cf
6689060: Escape Analysis does not work with Compressed Oops
kvn
parents:
62
diff
changeset
|
2252 |
| 0 | 2253 for (int i = 0 ; i < _handlers->length() ; i++) { |
| 2254 AdapterHandlerEntry* a = get_entry(i); | |
| 2255 if ( a != NULL && b == CodeCache::find_blob(a->get_i2c_entry()) ) return true; | |
| 2256 } | |
| 2257 return false; | |
| 2258 } | |
| 2259 | |
| 2260 void AdapterHandlerLibrary::print_handler(CodeBlob* b) { | |
| 2261 | |
| 2262 for (int i = 0 ; i < _handlers->length() ; i++) { | |
| 2263 AdapterHandlerEntry* a = get_entry(i); | |
| 2264 if ( a != NULL && b == CodeCache::find_blob(a->get_i2c_entry()) ) { | |
| 2265 tty->print("Adapter for signature: "); | |
| 2266 // Fingerprinter::print(_fingerprints->at(i)); | |
| 2267 tty->print("0x%" FORMAT64_MODIFIER "x", _fingerprints->at(i)); | |
| 2268 tty->print_cr(" i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT, | |
| 2269 a->get_i2c_entry(), a->get_c2i_entry(), a->get_c2i_unverified_entry()); | |
| 2270 | |
| 2271 return; | |
| 2272 } | |
| 2273 } | |
| 2274 assert(false, "Should have found handler"); | |
| 2275 } | |
| 2276 #endif /* PRODUCT */ |