1 /*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/stringTable.hpp"
27 #include "classfile/systemDictionary.hpp"
28 #include "classfile/vmSymbols.hpp"
29 #include "code/codeCache.hpp"
30 #include "code/compiledIC.hpp"
31 #include "code/codeCacheExtensions.hpp"
32 #include "code/scopeDesc.hpp"
33 #include "code/vtableStubs.hpp"
34 #include "compiler/abstractCompiler.hpp"
35 #include "compiler/compileBroker.hpp"
36 #include "compiler/disassembler.hpp"
37 #include "gc/shared/gcLocker.inline.hpp"
38 #include "interpreter/interpreter.hpp"
39 #include "interpreter/interpreterRuntime.hpp"
40 #include "logging/log.hpp"
41 #include "memory/metaspaceShared.hpp"
42 #include "memory/resourceArea.hpp"
43 #include "memory/universe.inline.hpp"
44 #include "oops/klass.hpp"
45 #include "oops/objArrayKlass.hpp"
46 #include "oops/oop.inline.hpp"
47 #include "prims/forte.hpp"
48 #include "prims/jvmtiExport.hpp"
49 #include "prims/methodHandles.hpp"
50 #include "prims/nativeLookup.hpp"
51 #include "runtime/arguments.hpp"
52 #include "runtime/atomic.inline.hpp"
53 #include "runtime/biasedLocking.hpp"
54 #include "runtime/compilationPolicy.hpp"
55 #include "runtime/handles.inline.hpp"
56 #include "runtime/init.hpp"
57 #include "runtime/interfaceSupport.hpp"
58 #include "runtime/javaCalls.hpp"
59 #include "runtime/sharedRuntime.hpp"
60 #include "runtime/stubRoutines.hpp"
61 #include "runtime/vframe.hpp"
62 #include "runtime/vframeArray.hpp"
63 #include "trace/tracing.hpp"
64 #include "utilities/copy.hpp"
65 #include "utilities/dtrace.hpp"
66 #include "utilities/events.hpp"
67 #include "utilities/hashtable.inline.hpp"
68 #include "utilities/macros.hpp"
69 #include "utilities/xmlstream.hpp"
70 #ifdef COMPILER1
71 #include "c1/c1_Runtime1.hpp"
72 #endif
73
74 // Shared stub locations
75 RuntimeStub* SharedRuntime::_wrong_method_blob;
76 RuntimeStub* SharedRuntime::_wrong_method_abstract_blob;
77 RuntimeStub* SharedRuntime::_ic_miss_blob;
78 RuntimeStub* SharedRuntime::_resolve_opt_virtual_call_blob;
79 RuntimeStub* SharedRuntime::_resolve_virtual_call_blob;
80 RuntimeStub* SharedRuntime::_resolve_static_call_blob;
81
82 DeoptimizationBlob* SharedRuntime::_deopt_blob;
83 SafepointBlob* SharedRuntime::_polling_page_vectors_safepoint_handler_blob;
84 SafepointBlob* SharedRuntime::_polling_page_safepoint_handler_blob;
85 SafepointBlob* SharedRuntime::_polling_page_return_handler_blob;
86
87 #ifdef COMPILER2
88 UncommonTrapBlob* SharedRuntime::_uncommon_trap_blob;
89 #endif // COMPILER2
90
91
92 //----------------------------generate_stubs-----------------------------------
93 void SharedRuntime::generate_stubs() {
94 _wrong_method_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method), "wrong_method_stub");
95 _wrong_method_abstract_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_abstract), "wrong_method_abstract_stub");
96 _ic_miss_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss), "ic_miss_stub");
97 _resolve_opt_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C), "resolve_opt_virtual_call");
98 _resolve_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C), "resolve_virtual_call");
99 _resolve_static_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C), "resolve_static_call");
100
101 #if defined(COMPILER2) || INCLUDE_JVMCI
102 // Vectors are generated only by C2 and JVMCI.
103 bool support_wide = is_wide_vector(MaxVectorSize);
104 if (support_wide) {
105 _polling_page_vectors_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_VECTOR_LOOP);
106 }
107 #endif // COMPILER2 || INCLUDE_JVMCI
108 _polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_LOOP);
109 _polling_page_return_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_RETURN);
110
111 generate_deopt_blob();
112
113 #ifdef COMPILER2
114 generate_uncommon_trap_blob();
115 #endif // COMPILER2
116 }
117
118 #include <math.h>
119
120 // Implementation of SharedRuntime
121
122 #ifndef PRODUCT
123 // For statistics
124 int SharedRuntime::_ic_miss_ctr = 0;
125 int SharedRuntime::_wrong_method_ctr = 0;
126 int SharedRuntime::_resolve_static_ctr = 0;
127 int SharedRuntime::_resolve_virtual_ctr = 0;
128 int SharedRuntime::_resolve_opt_virtual_ctr = 0;
129 int SharedRuntime::_implicit_null_throws = 0;
130 int SharedRuntime::_implicit_div0_throws = 0;
131 int SharedRuntime::_throw_null_ctr = 0;
132
133 int SharedRuntime::_nof_normal_calls = 0;
134 int SharedRuntime::_nof_optimized_calls = 0;
135 int SharedRuntime::_nof_inlined_calls = 0;
136 int SharedRuntime::_nof_megamorphic_calls = 0;
137 int SharedRuntime::_nof_static_calls = 0;
138 int SharedRuntime::_nof_inlined_static_calls = 0;
139 int SharedRuntime::_nof_interface_calls = 0;
140 int SharedRuntime::_nof_optimized_interface_calls = 0;
141 int SharedRuntime::_nof_inlined_interface_calls = 0;
142 int SharedRuntime::_nof_megamorphic_interface_calls = 0;
143 int SharedRuntime::_nof_removable_exceptions = 0;
144
145 int SharedRuntime::_new_instance_ctr=0;
146 int SharedRuntime::_new_array_ctr=0;
147 int SharedRuntime::_multi1_ctr=0;
148 int SharedRuntime::_multi2_ctr=0;
149 int SharedRuntime::_multi3_ctr=0;
150 int SharedRuntime::_multi4_ctr=0;
151 int SharedRuntime::_multi5_ctr=0;
152 int SharedRuntime::_mon_enter_stub_ctr=0;
153 int SharedRuntime::_mon_exit_stub_ctr=0;
154 int SharedRuntime::_mon_enter_ctr=0;
155 int SharedRuntime::_mon_exit_ctr=0;
156 int SharedRuntime::_partial_subtype_ctr=0;
157 int SharedRuntime::_jbyte_array_copy_ctr=0;
158 int SharedRuntime::_jshort_array_copy_ctr=0;
159 int SharedRuntime::_jint_array_copy_ctr=0;
160 int SharedRuntime::_jlong_array_copy_ctr=0;
161 int SharedRuntime::_oop_array_copy_ctr=0;
162 int SharedRuntime::_checkcast_array_copy_ctr=0;
163 int SharedRuntime::_unsafe_array_copy_ctr=0;
164 int SharedRuntime::_generic_array_copy_ctr=0;
165 int SharedRuntime::_slow_array_copy_ctr=0;
166 int SharedRuntime::_find_handler_ctr=0;
167 int SharedRuntime::_rethrow_ctr=0;
168
169 int SharedRuntime::_ICmiss_index = 0;
170 int SharedRuntime::_ICmiss_count[SharedRuntime::maxICmiss_count];
171 address SharedRuntime::_ICmiss_at[SharedRuntime::maxICmiss_count];
172
173
174 void SharedRuntime::trace_ic_miss(address at) {
175 for (int i = 0; i < _ICmiss_index; i++) {
176 if (_ICmiss_at[i] == at) {
177 _ICmiss_count[i]++;
178 return;
179 }
180 }
181 int index = _ICmiss_index++;
182 if (_ICmiss_index >= maxICmiss_count) _ICmiss_index = maxICmiss_count - 1;
183 _ICmiss_at[index] = at;
184 _ICmiss_count[index] = 1;
185 }
186
187 void SharedRuntime::print_ic_miss_histogram() {
188 if (ICMissHistogram) {
189 tty->print_cr("IC Miss Histogram:");
190 int tot_misses = 0;
191 for (int i = 0; i < _ICmiss_index; i++) {
192 tty->print_cr(" at: " INTPTR_FORMAT " nof: %d", p2i(_ICmiss_at[i]), _ICmiss_count[i]);
193 tot_misses += _ICmiss_count[i];
194 }
195 tty->print_cr("Total IC misses: %7d", tot_misses);
196 }
197 }
198 #endif // PRODUCT
199
200 #if INCLUDE_ALL_GCS
201
202 // G1 write-barrier pre: executed before a pointer store.
203 JRT_LEAF(void, SharedRuntime::g1_wb_pre(oopDesc* orig, JavaThread *thread))
204 if (orig == NULL) {
205 assert(false, "should be optimized out");
206 return;
207 }
208 assert(orig->is_oop(true /* ignore mark word */), "Error");
209 // store the original value that was in the field reference
210 thread->satb_mark_queue().enqueue(orig);
211 JRT_END
212
213 // G1 write-barrier post: executed after a pointer store.
214 JRT_LEAF(void, SharedRuntime::g1_wb_post(void* card_addr, JavaThread* thread))
215 thread->dirty_card_queue().enqueue(card_addr);
216 JRT_END
217
218 #endif // INCLUDE_ALL_GCS
219
220
221 JRT_LEAF(jlong, SharedRuntime::lmul(jlong y, jlong x))
222 return x * y;
223 JRT_END
224
225
226 JRT_LEAF(jlong, SharedRuntime::ldiv(jlong y, jlong x))
227 if (x == min_jlong && y == CONST64(-1)) {
228 return x;
229 } else {
230 return x / y;
231 }
232 JRT_END
233
234
235 JRT_LEAF(jlong, SharedRuntime::lrem(jlong y, jlong x))
236 if (x == min_jlong && y == CONST64(-1)) {
237 return 0;
238 } else {
239 return x % y;
240 }
241 JRT_END
242
243
244 const juint float_sign_mask = 0x7FFFFFFF;
245 const juint float_infinity = 0x7F800000;
246 const julong double_sign_mask = CONST64(0x7FFFFFFFFFFFFFFF);
247 const julong double_infinity = CONST64(0x7FF0000000000000);
248
249 JRT_LEAF(jfloat, SharedRuntime::frem(jfloat x, jfloat y))
250 #ifdef _WIN64
251 // 64-bit Windows on amd64 returns the wrong values for
252 // infinity operands.
253 union { jfloat f; juint i; } xbits, ybits;
254 xbits.f = x;
255 ybits.f = y;
256 // x Mod Infinity == x unless x is infinity
257 if (((xbits.i & float_sign_mask) != float_infinity) &&
258 ((ybits.i & float_sign_mask) == float_infinity) ) {
259 return x;
260 }
261 return ((jfloat)fmod_winx64((double)x, (double)y));
262 #else
263 return ((jfloat)fmod((double)x,(double)y));
264 #endif
265 JRT_END
266
267
268 JRT_LEAF(jdouble, SharedRuntime::drem(jdouble x, jdouble y))
269 #ifdef _WIN64
270 union { jdouble d; julong l; } xbits, ybits;
271 xbits.d = x;
272 ybits.d = y;
273 // x Mod Infinity == x unless x is infinity
274 if (((xbits.l & double_sign_mask) != double_infinity) &&
275 ((ybits.l & double_sign_mask) == double_infinity) ) {
276 return x;
277 }
278 return ((jdouble)fmod_winx64((double)x, (double)y));
279 #else
280 return ((jdouble)fmod((double)x,(double)y));
281 #endif
282 JRT_END
283
284 #ifdef __SOFTFP__
285 JRT_LEAF(jfloat, SharedRuntime::fadd(jfloat x, jfloat y))
286 return x + y;
287 JRT_END
288
289 JRT_LEAF(jfloat, SharedRuntime::fsub(jfloat x, jfloat y))
290 return x - y;
291 JRT_END
292
293 JRT_LEAF(jfloat, SharedRuntime::fmul(jfloat x, jfloat y))
294 return x * y;
295 JRT_END
296
297 JRT_LEAF(jfloat, SharedRuntime::fdiv(jfloat x, jfloat y))
298 return x / y;
299 JRT_END
300
301 JRT_LEAF(jdouble, SharedRuntime::dadd(jdouble x, jdouble y))
302 return x + y;
303 JRT_END
304
305 JRT_LEAF(jdouble, SharedRuntime::dsub(jdouble x, jdouble y))
306 return x - y;
307 JRT_END
308
309 JRT_LEAF(jdouble, SharedRuntime::dmul(jdouble x, jdouble y))
310 return x * y;
311 JRT_END
312
313 JRT_LEAF(jdouble, SharedRuntime::ddiv(jdouble x, jdouble y))
314 return x / y;
315 JRT_END
316
317 JRT_LEAF(jfloat, SharedRuntime::i2f(jint x))
318 return (jfloat)x;
319 JRT_END
320
321 JRT_LEAF(jdouble, SharedRuntime::i2d(jint x))
322 return (jdouble)x;
323 JRT_END
324
325 JRT_LEAF(jdouble, SharedRuntime::f2d(jfloat x))
326 return (jdouble)x;
327 JRT_END
328
329 JRT_LEAF(int, SharedRuntime::fcmpl(float x, float y))
330 return x>y ? 1 : (x==y ? 0 : -1); /* x<y or is_nan*/
331 JRT_END
332
333 JRT_LEAF(int, SharedRuntime::fcmpg(float x, float y))
334 return x<y ? -1 : (x==y ? 0 : 1); /* x>y or is_nan */
335 JRT_END
336
337 JRT_LEAF(int, SharedRuntime::dcmpl(double x, double y))
338 return x>y ? 1 : (x==y ? 0 : -1); /* x<y or is_nan */
339 JRT_END
340
341 JRT_LEAF(int, SharedRuntime::dcmpg(double x, double y))
342 return x<y ? -1 : (x==y ? 0 : 1); /* x>y or is_nan */
343 JRT_END
344
345 // Functions to return the opposite of the aeabi functions for nan.
346 JRT_LEAF(int, SharedRuntime::unordered_fcmplt(float x, float y))
347 return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
348 JRT_END
349
350 JRT_LEAF(int, SharedRuntime::unordered_dcmplt(double x, double y))
351 return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
352 JRT_END
353
354 JRT_LEAF(int, SharedRuntime::unordered_fcmple(float x, float y))
355 return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
356 JRT_END
357
358 JRT_LEAF(int, SharedRuntime::unordered_dcmple(double x, double y))
359 return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
360 JRT_END
361
362 JRT_LEAF(int, SharedRuntime::unordered_fcmpge(float x, float y))
363 return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
364 JRT_END
365
366 JRT_LEAF(int, SharedRuntime::unordered_dcmpge(double x, double y))
367 return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
368 JRT_END
369
370 JRT_LEAF(int, SharedRuntime::unordered_fcmpgt(float x, float y))
371 return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
372 JRT_END
373
374 JRT_LEAF(int, SharedRuntime::unordered_dcmpgt(double x, double y))
375 return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
376 JRT_END
377
378 // Intrinsics make gcc generate code for these.
379 float SharedRuntime::fneg(float f) {
380 return -f;
381 }
382
383 double SharedRuntime::dneg(double f) {
384 return -f;
385 }
386
387 #endif // __SOFTFP__
388
389 #if defined(__SOFTFP__) || defined(E500V2)
390 // Intrinsics make gcc generate code for these.
391 double SharedRuntime::dabs(double f) {
392 return (f <= (double)0.0) ? (double)0.0 - f : f;
393 }
394
395 #endif
396
397 #if defined(__SOFTFP__) || defined(PPC)
398 double SharedRuntime::dsqrt(double f) {
399 return sqrt(f);
400 }
401 #endif
402
403 JRT_LEAF(jint, SharedRuntime::f2i(jfloat x))
404 if (g_isnan(x))
405 return 0;
406 if (x >= (jfloat) max_jint)
407 return max_jint;
408 if (x <= (jfloat) min_jint)
409 return min_jint;
410 return (jint) x;
411 JRT_END
412
413
414 JRT_LEAF(jlong, SharedRuntime::f2l(jfloat x))
415 if (g_isnan(x))
416 return 0;
417 if (x >= (jfloat) max_jlong)
418 return max_jlong;
419 if (x <= (jfloat) min_jlong)
420 return min_jlong;
421 return (jlong) x;
422 JRT_END
423
424
425 JRT_LEAF(jint, SharedRuntime::d2i(jdouble x))
426 if (g_isnan(x))
427 return 0;
428 if (x >= (jdouble) max_jint)
429 return max_jint;
430 if (x <= (jdouble) min_jint)
431 return min_jint;
432 return (jint) x;
433 JRT_END
434
435
436 JRT_LEAF(jlong, SharedRuntime::d2l(jdouble x))
437 if (g_isnan(x))
438 return 0;
439 if (x >= (jdouble) max_jlong)
440 return max_jlong;
441 if (x <= (jdouble) min_jlong)
442 return min_jlong;
443 return (jlong) x;
444 JRT_END
445
446
447 JRT_LEAF(jfloat, SharedRuntime::d2f(jdouble x))
448 return (jfloat)x;
449 JRT_END
450
451
452 JRT_LEAF(jfloat, SharedRuntime::l2f(jlong x))
453 return (jfloat)x;
454 JRT_END
455
456
457 JRT_LEAF(jdouble, SharedRuntime::l2d(jlong x))
458 return (jdouble)x;
459 JRT_END
460
461 // Exception handling across interpreter/compiler boundaries
462 //
463 // exception_handler_for_return_address(...) returns the continuation address.
464 // The continuation address is the entry point of the exception handler of the
465 // previous frame depending on the return address.
466
467 address SharedRuntime::raw_exception_handler_for_return_address(JavaThread* thread, address return_address) {
468 assert(frame::verify_return_pc(return_address), "must be a return address: " INTPTR_FORMAT, p2i(return_address));
469 assert(thread->frames_to_pop_failed_realloc() == 0 || Interpreter::contains(return_address), "missed frames to pop?");
470
471 // Reset method handle flag.
472 thread->set_is_method_handle_return(false);
473
474 #if INCLUDE_JVMCI
475 // JVMCI's ExceptionHandlerStub expects the thread local exception PC to be clear
476 // and other exception handler continuations do not read it
477 thread->set_exception_pc(NULL);
478 #endif
479
480 // The fastest case first
481 CodeBlob* blob = CodeCache::find_blob(return_address);
482 nmethod* nm = (blob != NULL) ? blob->as_nmethod_or_null() : NULL;
483 if (nm != NULL) {
484 // Set flag if return address is a method handle call site.
485 thread->set_is_method_handle_return(nm->is_method_handle_return(return_address));
486 // native nmethods don't have exception handlers
487 assert(!nm->is_native_method(), "no exception handler");
488 assert(nm->header_begin() != nm->exception_begin(), "no exception handler");
489 if (nm->is_deopt_pc(return_address)) {
490 // If we come here because of a stack overflow, the stack may be
491 // unguarded. Reguard the stack otherwise if we return to the
492 // deopt blob and the stack bang causes a stack overflow we
493 // crash.
494 bool guard_pages_enabled = thread->stack_guards_enabled();
495 if (!guard_pages_enabled) guard_pages_enabled = thread->reguard_stack();
496 if (thread->reserved_stack_activation() != thread->stack_base()) {
497 thread->set_reserved_stack_activation(thread->stack_base());
498 }
499 assert(guard_pages_enabled, "stack banging in deopt blob may cause crash");
500 return SharedRuntime::deopt_blob()->unpack_with_exception();
501 } else {
502 return nm->exception_begin();
503 }
504 }
505
506 // Entry code
507 if (StubRoutines::returns_to_call_stub(return_address)) {
508 return StubRoutines::catch_exception_entry();
509 }
510 // Interpreted code
511 if (Interpreter::contains(return_address)) {
512 return Interpreter::rethrow_exception_entry();
513 }
514
515 guarantee(blob == NULL || !blob->is_runtime_stub(), "caller should have skipped stub");
516 guarantee(!VtableStubs::contains(return_address), "NULL exceptions in vtables should have been handled already!");
517
518 #ifndef PRODUCT
519 { ResourceMark rm;
520 tty->print_cr("No exception handler found for exception at " INTPTR_FORMAT " - potential problems:", p2i(return_address));
521 tty->print_cr("a) exception happened in (new?) code stubs/buffers that is not handled here");
522 tty->print_cr("b) other problem");
523 }
524 #endif // PRODUCT
525
526 ShouldNotReachHere();
527 return NULL;
528 }
529
530
531 JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(JavaThread* thread, address return_address))
532 return raw_exception_handler_for_return_address(thread, return_address);
533 JRT_END
534
535
536 address SharedRuntime::get_poll_stub(address pc) {
537 address stub;
538 // Look up the code blob
539 CodeBlob *cb = CodeCache::find_blob(pc);
540
541 // Should be an nmethod
542 assert(cb && cb->is_compiled(), "safepoint polling: pc must refer to an nmethod");
543
544 // Look up the relocation information
545 assert(((CompiledMethod*)cb)->is_at_poll_or_poll_return(pc),
546 "safepoint polling: type must be poll");
547
548 #ifdef ASSERT
549 if (!((NativeInstruction*)pc)->is_safepoint_poll()) {
550 tty->print_cr("bad pc: " PTR_FORMAT, p2i(pc));
551 Disassembler::decode(cb);
552 fatal("Only polling locations are used for safepoint");
553 }
554 #endif
555
556 bool at_poll_return = ((CompiledMethod*)cb)->is_at_poll_return(pc);
557 bool has_wide_vectors = ((CompiledMethod*)cb)->has_wide_vectors();
558 if (at_poll_return) {
559 assert(SharedRuntime::polling_page_return_handler_blob() != NULL,
560 "polling page return stub not created yet");
561 stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
562 } else if (has_wide_vectors) {
563 assert(SharedRuntime::polling_page_vectors_safepoint_handler_blob() != NULL,
564 "polling page vectors safepoint stub not created yet");
565 stub = SharedRuntime::polling_page_vectors_safepoint_handler_blob()->entry_point();
566 } else {
567 assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL,
568 "polling page safepoint stub not created yet");
569 stub = SharedRuntime::polling_page_safepoint_handler_blob()->entry_point();
570 }
571 log_debug(safepoint)("... found polling page %s exception at pc = "
572 INTPTR_FORMAT ", stub =" INTPTR_FORMAT,
573 at_poll_return ? "return" : "loop",
574 (intptr_t)pc, (intptr_t)stub);
575 return stub;
576 }
577
578
579 oop SharedRuntime::retrieve_receiver( Symbol* sig, frame caller ) {
580 assert(caller.is_interpreted_frame(), "");
581 int args_size = ArgumentSizeComputer(sig).size() + 1;
582 assert(args_size <= caller.interpreter_frame_expression_stack_size(), "receiver must be on interpreter stack");
583 oop result = cast_to_oop(*caller.interpreter_frame_tos_at(args_size - 1));
584 assert(GC::gc()->heap()->is_in(result) && result->is_oop(), "receiver must be an oop");
585 return result;
586 }
587
588
589 void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Handle h_exception) {
590 if (JvmtiExport::can_post_on_exceptions()) {
591 vframeStream vfst(thread, true);
592 methodHandle method = methodHandle(thread, vfst.method());
593 address bcp = method()->bcp_from(vfst.bci());
594 JvmtiExport::post_exception_throw(thread, method(), bcp, h_exception());
595 }
596 Exceptions::_throw(thread, __FILE__, __LINE__, h_exception);
597 }
598
599 void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Symbol* name, const char *message) {
600 Handle h_exception = Exceptions::new_exception(thread, name, message);
601 throw_and_post_jvmti_exception(thread, h_exception);
602 }
603
604 // The interpreter code to call this tracing function is only
605 // called/generated when UL is on for redefine, class and has the right level
606 // and tags. Since obsolete methods are never compiled, we don't have
607 // to modify the compilers to generate calls to this function.
608 //
609 JRT_LEAF(int, SharedRuntime::rc_trace_method_entry(
610 JavaThread* thread, Method* method))
611 if (method->is_obsolete()) {
612 // We are calling an obsolete method, but this is not necessarily
613 // an error. Our method could have been redefined just after we
614 // fetched the Method* from the constant pool.
615 ResourceMark rm;
616 log_trace(redefine, class, obsolete)("calling obsolete method '%s'", method->name_and_sig_as_C_string());
617 }
618 return 0;
619 JRT_END
620
621 // ret_pc points into caller; we are returning caller's exception handler
622 // for given exception
623 address SharedRuntime::compute_compiled_exc_handler(CompiledMethod* cm, address ret_pc, Handle& exception,
624 bool force_unwind, bool top_frame_only) {
625 assert(cm != NULL, "must exist");
626 ResourceMark rm;
627
628 #if INCLUDE_JVMCI
629 if (cm->is_compiled_by_jvmci()) {
630 // lookup exception handler for this pc
631 int catch_pco = ret_pc - cm->code_begin();
632 ExceptionHandlerTable table(cm);
633 HandlerTableEntry *t = table.entry_for(catch_pco, -1, 0);
634 if (t != NULL) {
635 return cm->code_begin() + t->pco();
636 } else {
637 // there is no exception handler for this pc => deoptimize
638 cm->make_not_entrant();
639
640 // Use Deoptimization::deoptimize for all of its side-effects:
641 // revoking biases of monitors, gathering traps statistics, logging...
642 // it also patches the return pc but we do not care about that
643 // since we return a continuation to the deopt_blob below.
644 JavaThread* thread = JavaThread::current();
645 RegisterMap reg_map(thread, UseBiasedLocking);
646 frame runtime_frame = thread->last_frame();
647 frame caller_frame = runtime_frame.sender(®_map);
648 Deoptimization::deoptimize(thread, caller_frame, ®_map, Deoptimization::Reason_not_compiled_exception_handler);
649
650 return SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
651 }
652 }
653 #endif // INCLUDE_JVMCI
654
655 nmethod* nm = cm->as_nmethod();
656 ScopeDesc* sd = nm->scope_desc_at(ret_pc);
657 // determine handler bci, if any
658 EXCEPTION_MARK;
659
660 int handler_bci = -1;
661 int scope_depth = 0;
662 if (!force_unwind) {
663 int bci = sd->bci();
664 bool recursive_exception = false;
665 do {
666 bool skip_scope_increment = false;
667 // exception handler lookup
668 KlassHandle ek (THREAD, exception->klass());
669 methodHandle mh(THREAD, sd->method());
670 handler_bci = Method::fast_exception_handler_bci_for(mh, ek, bci, THREAD);
671 if (HAS_PENDING_EXCEPTION) {
672 recursive_exception = true;
673 // We threw an exception while trying to find the exception handler.
674 // Transfer the new exception to the exception handle which will
675 // be set into thread local storage, and do another lookup for an
676 // exception handler for this exception, this time starting at the
677 // BCI of the exception handler which caused the exception to be
678 // thrown (bugs 4307310 and 4546590). Set "exception" reference
679 // argument to ensure that the correct exception is thrown (4870175).
680 exception = Handle(THREAD, PENDING_EXCEPTION);
681 CLEAR_PENDING_EXCEPTION;
682 if (handler_bci >= 0) {
683 bci = handler_bci;
684 handler_bci = -1;
685 skip_scope_increment = true;
686 }
687 }
688 else {
689 recursive_exception = false;
690 }
691 if (!top_frame_only && handler_bci < 0 && !skip_scope_increment) {
692 sd = sd->sender();
693 if (sd != NULL) {
694 bci = sd->bci();
695 }
696 ++scope_depth;
697 }
698 } while (recursive_exception || (!top_frame_only && handler_bci < 0 && sd != NULL));
699 }
700
701 // found handling method => lookup exception handler
702 int catch_pco = ret_pc - nm->code_begin();
703
704 ExceptionHandlerTable table(nm);
705 HandlerTableEntry *t = table.entry_for(catch_pco, handler_bci, scope_depth);
706 if (t == NULL && (nm->is_compiled_by_c1() || handler_bci != -1)) {
707 // Allow abbreviated catch tables. The idea is to allow a method
708 // to materialize its exceptions without committing to the exact
709 // routing of exceptions. In particular this is needed for adding
710 // a synthetic handler to unlock monitors when inlining
711 // synchronized methods since the unlock path isn't represented in
712 // the bytecodes.
713 t = table.entry_for(catch_pco, -1, 0);
714 }
715
716 #ifdef COMPILER1
717 if (t == NULL && nm->is_compiled_by_c1()) {
718 assert(nm->unwind_handler_begin() != NULL, "");
719 return nm->unwind_handler_begin();
720 }
721 #endif
722
723 if (t == NULL) {
724 ttyLocker ttyl;
725 tty->print_cr("MISSING EXCEPTION HANDLER for pc " INTPTR_FORMAT " and handler bci %d", p2i(ret_pc), handler_bci);
726 tty->print_cr(" Exception:");
727 exception->print();
728 tty->cr();
729 tty->print_cr(" Compiled exception table :");
730 table.print();
731 nm->print_code();
732 guarantee(false, "missing exception handler");
733 return NULL;
734 }
735
736 return nm->code_begin() + t->pco();
737 }
738
739 JRT_ENTRY(void, SharedRuntime::throw_AbstractMethodError(JavaThread* thread))
740 // These errors occur only at call sites
741 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_AbstractMethodError());
742 JRT_END
743
744 JRT_ENTRY(void, SharedRuntime::throw_IncompatibleClassChangeError(JavaThread* thread))
745 // These errors occur only at call sites
746 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError(), "vtable stub");
747 JRT_END
748
749 JRT_ENTRY(void, SharedRuntime::throw_ArithmeticException(JavaThread* thread))
750 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArithmeticException(), "/ by zero");
751 JRT_END
752
753 JRT_ENTRY(void, SharedRuntime::throw_NullPointerException(JavaThread* thread))
754 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());
755 JRT_END
756
757 JRT_ENTRY(void, SharedRuntime::throw_NullPointerException_at_call(JavaThread* thread))
758 // This entry point is effectively only used for NullPointerExceptions which occur at inline
759 // cache sites (when the callee activation is not yet set up) so we are at a call site
760 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());
761 JRT_END
762
763 JRT_ENTRY(void, SharedRuntime::throw_StackOverflowError(JavaThread* thread))
764 throw_StackOverflowError_common(thread, false);
765 JRT_END
766
767 JRT_ENTRY(void, SharedRuntime::throw_delayed_StackOverflowError(JavaThread* thread))
768 throw_StackOverflowError_common(thread, true);
769 JRT_END
770
771 void SharedRuntime::throw_StackOverflowError_common(JavaThread* thread, bool delayed) {
772 // We avoid using the normal exception construction in this case because
773 // it performs an upcall to Java, and we're already out of stack space.
774 Thread* THREAD = thread;
775 Klass* k = SystemDictionary::StackOverflowError_klass();
776 oop exception_oop = InstanceKlass::cast(k)->allocate_instance(CHECK);
777 if (delayed) {
778 java_lang_Throwable::set_message(exception_oop,
779 Universe::delayed_stack_overflow_error_message());
780 }
781 Handle exception (thread, exception_oop);
782 if (StackTraceInThrowable) {
783 java_lang_Throwable::fill_in_stack_trace(exception);
784 }
785 // Increment counter for hs_err file reporting
786 Atomic::inc(&Exceptions::_stack_overflow_errors);
787 throw_and_post_jvmti_exception(thread, exception);
788 }
789
790 #if INCLUDE_JVMCI
791 address SharedRuntime::deoptimize_for_implicit_exception(JavaThread* thread, address pc, CompiledMethod* nm, int deopt_reason) {
792 assert(deopt_reason > Deoptimization::Reason_none && deopt_reason < Deoptimization::Reason_LIMIT, "invalid deopt reason");
793 thread->set_jvmci_implicit_exception_pc(pc);
794 thread->set_pending_deoptimization(Deoptimization::make_trap_request((Deoptimization::DeoptReason)deopt_reason, Deoptimization::Action_reinterpret));
795 return (SharedRuntime::deopt_blob()->implicit_exception_uncommon_trap());
796 }
797 #endif // INCLUDE_JVMCI
798
799 address SharedRuntime::continuation_for_implicit_exception(JavaThread* thread,
800 address pc,
801 SharedRuntime::ImplicitExceptionKind exception_kind)
802 {
803 address target_pc = NULL;
804
805 if (Interpreter::contains(pc)) {
806 #ifdef CC_INTERP
807 // C++ interpreter doesn't throw implicit exceptions
808 ShouldNotReachHere();
809 #else
810 switch (exception_kind) {
811 case IMPLICIT_NULL: return Interpreter::throw_NullPointerException_entry();
812 case IMPLICIT_DIVIDE_BY_ZERO: return Interpreter::throw_ArithmeticException_entry();
813 case STACK_OVERFLOW: return Interpreter::throw_StackOverflowError_entry();
814 default: ShouldNotReachHere();
815 }
816 #endif // !CC_INTERP
817 } else {
818 switch (exception_kind) {
819 case STACK_OVERFLOW: {
820 // Stack overflow only occurs upon frame setup; the callee is
821 // going to be unwound. Dispatch to a shared runtime stub
822 // which will cause the StackOverflowError to be fabricated
823 // and processed.
824 // Stack overflow should never occur during deoptimization:
825 // the compiled method bangs the stack by as much as the
826 // interpreter would need in case of a deoptimization. The
827 // deoptimization blob and uncommon trap blob bang the stack
828 // in a debug VM to verify the correctness of the compiled
829 // method stack banging.
830 assert(thread->deopt_mark() == NULL, "no stack overflow from deopt blob/uncommon trap");
831 Events::log_exception(thread, "StackOverflowError at " INTPTR_FORMAT, p2i(pc));
832 return StubRoutines::throw_StackOverflowError_entry();
833 }
834
835 case IMPLICIT_NULL: {
836 if (VtableStubs::contains(pc)) {
837 // We haven't yet entered the callee frame. Fabricate an
838 // exception and begin dispatching it in the caller. Since
839 // the caller was at a call site, it's safe to destroy all
840 // caller-saved registers, as these entry points do.
841 VtableStub* vt_stub = VtableStubs::stub_containing(pc);
842
843 // If vt_stub is NULL, then return NULL to signal handler to report the SEGV error.
844 if (vt_stub == NULL) return NULL;
845
846 if (vt_stub->is_abstract_method_error(pc)) {
847 assert(!vt_stub->is_vtable_stub(), "should never see AbstractMethodErrors from vtable-type VtableStubs");
848 Events::log_exception(thread, "AbstractMethodError at " INTPTR_FORMAT, p2i(pc));
849 return StubRoutines::throw_AbstractMethodError_entry();
850 } else {
851 Events::log_exception(thread, "NullPointerException at vtable entry " INTPTR_FORMAT, p2i(pc));
852 return StubRoutines::throw_NullPointerException_at_call_entry();
853 }
854 } else {
855 CodeBlob* cb = CodeCache::find_blob(pc);
856
857 // If code blob is NULL, then return NULL to signal handler to report the SEGV error.
858 if (cb == NULL) return NULL;
859
860 // Exception happened in CodeCache. Must be either:
861 // 1. Inline-cache check in C2I handler blob,
862 // 2. Inline-cache check in nmethod, or
863 // 3. Implicit null exception in nmethod
864
865 if (!cb->is_compiled()) {
866 bool is_in_blob = cb->is_adapter_blob() || cb->is_method_handles_adapter_blob();
867 if (!is_in_blob) {
868 // Allow normal crash reporting to handle this
869 return NULL;
870 }
871 Events::log_exception(thread, "NullPointerException in code blob at " INTPTR_FORMAT, p2i(pc));
872 // There is no handler here, so we will simply unwind.
873 return StubRoutines::throw_NullPointerException_at_call_entry();
874 }
875
876 // Otherwise, it's a compiled method. Consult its exception handlers.
877 CompiledMethod* cm = (CompiledMethod*)cb;
878 if (cm->inlinecache_check_contains(pc)) {
879 // exception happened inside inline-cache check code
880 // => the nmethod is not yet active (i.e., the frame
881 // is not set up yet) => use return address pushed by
882 // caller => don't push another return address
883 Events::log_exception(thread, "NullPointerException in IC check " INTPTR_FORMAT, p2i(pc));
884 return StubRoutines::throw_NullPointerException_at_call_entry();
885 }
886
887 if (cm->method()->is_method_handle_intrinsic()) {
888 // exception happened inside MH dispatch code, similar to a vtable stub
889 Events::log_exception(thread, "NullPointerException in MH adapter " INTPTR_FORMAT, p2i(pc));
890 return StubRoutines::throw_NullPointerException_at_call_entry();
891 }
892
893 #ifndef PRODUCT
894 _implicit_null_throws++;
895 #endif
896 #if INCLUDE_JVMCI
897 if (cm->is_compiled_by_jvmci() && cm->pc_desc_at(pc) != NULL) {
898 // If there's no PcDesc then we'll die way down inside of
899 // deopt instead of just getting normal error reporting,
900 // so only go there if it will succeed.
901 return deoptimize_for_implicit_exception(thread, pc, cm, Deoptimization::Reason_null_check);
902 } else {
903 #endif // INCLUDE_JVMCI
904 assert (cm->is_nmethod(), "Expect nmethod");
905 target_pc = ((nmethod*)cm)->continuation_for_implicit_exception(pc);
906 #if INCLUDE_JVMCI
907 }
908 #endif // INCLUDE_JVMCI
909 // If there's an unexpected fault, target_pc might be NULL,
910 // in which case we want to fall through into the normal
911 // error handling code.
912 }
913
914 break; // fall through
915 }
916
917
918 case IMPLICIT_DIVIDE_BY_ZERO: {
919 CompiledMethod* cm = CodeCache::find_compiled(pc);
920 guarantee(cm != NULL, "must have containing compiled method for implicit division-by-zero exceptions");
921 #ifndef PRODUCT
922 _implicit_div0_throws++;
923 #endif
924 #if INCLUDE_JVMCI
925 if (cm->is_compiled_by_jvmci() && cm->pc_desc_at(pc) != NULL) {
926 return deoptimize_for_implicit_exception(thread, pc, cm, Deoptimization::Reason_div0_check);
927 } else {
928 #endif // INCLUDE_JVMCI
929 target_pc = cm->continuation_for_implicit_exception(pc);
930 #if INCLUDE_JVMCI
931 }
932 #endif // INCLUDE_JVMCI
933 // If there's an unexpected fault, target_pc might be NULL,
934 // in which case we want to fall through into the normal
935 // error handling code.
936 break; // fall through
937 }
938
939 default: ShouldNotReachHere();
940 }
941
942 assert(exception_kind == IMPLICIT_NULL || exception_kind == IMPLICIT_DIVIDE_BY_ZERO, "wrong implicit exception kind");
943
944 if (exception_kind == IMPLICIT_NULL) {
945 #ifndef PRODUCT
946 // for AbortVMOnException flag
947 Exceptions::debug_check_abort("java.lang.NullPointerException");
948 #endif //PRODUCT
949 Events::log_exception(thread, "Implicit null exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, p2i(pc), p2i(target_pc));
950 } else {
951 #ifndef PRODUCT
952 // for AbortVMOnException flag
953 Exceptions::debug_check_abort("java.lang.ArithmeticException");
954 #endif //PRODUCT
955 Events::log_exception(thread, "Implicit division by zero exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, p2i(pc), p2i(target_pc));
956 }
957 return target_pc;
958 }
959
960 ShouldNotReachHere();
961 return NULL;
962 }
963
964
965 /**
966 * Throws an java/lang/UnsatisfiedLinkError. The address of this method is
967 * installed in the native function entry of all native Java methods before
968 * they get linked to their actual native methods.
969 *
970 * \note
971 * This method actually never gets called! The reason is because
972 * the interpreter's native entries call NativeLookup::lookup() which
973 * throws the exception when the lookup fails. The exception is then
974 * caught and forwarded on the return from NativeLookup::lookup() call
975 * before the call to the native function. This might change in the future.
976 */
977 JNI_ENTRY(void*, throw_unsatisfied_link_error(JNIEnv* env, ...))
978 {
979 // We return a bad value here to make sure that the exception is
980 // forwarded before we look at the return value.
981 THROW_(vmSymbols::java_lang_UnsatisfiedLinkError(), (void*)badJNIHandle);
982 }
983 JNI_END
984
985 address SharedRuntime::native_method_throw_unsatisfied_link_error_entry() {
986 return CAST_FROM_FN_PTR(address, &throw_unsatisfied_link_error);
987 }
988
989 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))
990 assert(obj->is_oop(), "must be a valid oop");
991 #if INCLUDE_JVMCI
992 // This removes the requirement for JVMCI compilers to emit code
993 // performing a dynamic check that obj has a finalizer before
994 // calling this routine. There should be no performance impact
995 // for C1 since it emits a dynamic check. C2 and the interpreter
996 // uses other runtime routines for registering finalizers.
997 if (!obj->klass()->has_finalizer()) {
998 return;
999 }
1000 #endif // INCLUDE_JVMCI
1001 assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
1002 InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
1003 JRT_END
1004
1005
1006 jlong SharedRuntime::get_java_tid(Thread* thread) {
1007 if (thread != NULL) {
1008 if (thread->is_Java_thread()) {
1009 oop obj = ((JavaThread*)thread)->threadObj();
1010 return (obj == NULL) ? 0 : java_lang_Thread::thread_id(obj);
1011 }
1012 }
1013 return 0;
1014 }
1015
1016 /**
1017 * This function ought to be a void function, but cannot be because
1018 * it gets turned into a tail-call on sparc, which runs into dtrace bug
1019 * 6254741. Once that is fixed we can remove the dummy return value.
1020 */
1021 int SharedRuntime::dtrace_object_alloc(oopDesc* o, int size) {
1022 return dtrace_object_alloc_base(Thread::current(), o, size);
1023 }
1024
1025 int SharedRuntime::dtrace_object_alloc_base(Thread* thread, oopDesc* o, int size) {
1026 assert(DTraceAllocProbes, "wrong call");
1027 Klass* klass = o->klass();
1028 Symbol* name = klass->name();
1029 HOTSPOT_OBJECT_ALLOC(
1030 get_java_tid(thread),
1031 (char *) name->bytes(), name->utf8_length(), size * HeapWordSize);
1032 return 0;
1033 }
1034
1035 JRT_LEAF(int, SharedRuntime::dtrace_method_entry(
1036 JavaThread* thread, Method* method))
1037 assert(DTraceMethodProbes, "wrong call");
1038 Symbol* kname = method->klass_name();
1039 Symbol* name = method->name();
1040 Symbol* sig = method->signature();
1041 HOTSPOT_METHOD_ENTRY(
1042 get_java_tid(thread),
1043 (char *) kname->bytes(), kname->utf8_length(),
1044 (char *) name->bytes(), name->utf8_length(),
1045 (char *) sig->bytes(), sig->utf8_length());
1046 return 0;
1047 JRT_END
1048
1049 JRT_LEAF(int, SharedRuntime::dtrace_method_exit(
1050 JavaThread* thread, Method* method))
1051 assert(DTraceMethodProbes, "wrong call");
1052 Symbol* kname = method->klass_name();
1053 Symbol* name = method->name();
1054 Symbol* sig = method->signature();
1055 HOTSPOT_METHOD_RETURN(
1056 get_java_tid(thread),
1057 (char *) kname->bytes(), kname->utf8_length(),
1058 (char *) name->bytes(), name->utf8_length(),
1059 (char *) sig->bytes(), sig->utf8_length());
1060 return 0;
1061 JRT_END
1062
1063
1064 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode)
1065 // for a call current in progress, i.e., arguments has been pushed on stack
1066 // put callee has not been invoked yet. Used by: resolve virtual/static,
1067 // vtable updates, etc. Caller frame must be compiled.
1068 Handle SharedRuntime::find_callee_info(JavaThread* thread, Bytecodes::Code& bc, CallInfo& callinfo, TRAPS) {
1069 ResourceMark rm(THREAD);
1070
1071 // last java frame on stack (which includes native call frames)
1072 vframeStream vfst(thread, true); // Do not skip and javaCalls
1073
1074 return find_callee_info_helper(thread, vfst, bc, callinfo, THREAD);
1075 }
1076
1077 methodHandle SharedRuntime::extract_attached_method(vframeStream& vfst) {
1078 CompiledMethod* caller = vfst.nm();
1079
1080 nmethodLocker caller_lock(caller);
1081
1082 address pc = vfst.frame_pc();
1083 { // Get call instruction under lock because another thread may be busy patching it.
1084 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
1085 return caller->attached_method_before_pc(pc);
1086 }
1087 return NULL;
1088 }
1089
1090 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode
1091 // for a call current in progress, i.e., arguments has been pushed on stack
1092 // but callee has not been invoked yet. Caller frame must be compiled.
1093 Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
1094 vframeStream& vfst,
1095 Bytecodes::Code& bc,
1096 CallInfo& callinfo, TRAPS) {
1097 Handle receiver;
1098 Handle nullHandle; //create a handy null handle for exception returns
1099
1100 assert(!vfst.at_end(), "Java frame must exist");
1101
1102 // Find caller and bci from vframe
1103 methodHandle caller(THREAD, vfst.method());
1104 int bci = vfst.bci();
1105
1106 Bytecode_invoke bytecode(caller, bci);
1107 int bytecode_index = bytecode.index();
1108
1109 methodHandle attached_method = extract_attached_method(vfst);
1110 if (attached_method.not_null()) {
1111 methodHandle callee = bytecode.static_target(CHECK_NH);
1112 vmIntrinsics::ID id = callee->intrinsic_id();
1113 // When VM replaces MH.invokeBasic/linkTo* call with a direct/virtual call,
1114 // it attaches statically resolved method to the call site.
1115 if (MethodHandles::is_signature_polymorphic(id) &&
1116 MethodHandles::is_signature_polymorphic_intrinsic(id)) {
1117 bc = MethodHandles::signature_polymorphic_intrinsic_bytecode(id);
1118
1119 // Adjust invocation mode according to the attached method.
1120 switch (bc) {
1121 case Bytecodes::_invokeinterface:
1122 if (!attached_method->method_holder()->is_interface()) {
1123 bc = Bytecodes::_invokevirtual;
1124 }
1125 break;
1126 case Bytecodes::_invokehandle:
1127 if (!MethodHandles::is_signature_polymorphic_method(attached_method())) {
1128 bc = attached_method->is_static() ? Bytecodes::_invokestatic
1129 : Bytecodes::_invokevirtual;
1130 }
1131 break;
1132 }
1133 }
1134 } else {
1135 bc = bytecode.invoke_code();
1136 }
1137
1138 bool has_receiver = bc != Bytecodes::_invokestatic &&
1139 bc != Bytecodes::_invokedynamic &&
1140 bc != Bytecodes::_invokehandle;
1141
1142 // Find receiver for non-static call
1143 if (has_receiver) {
1144 // This register map must be update since we need to find the receiver for
1145 // compiled frames. The receiver might be in a register.
1146 RegisterMap reg_map2(thread);
1147 frame stubFrame = thread->last_frame();
1148 // Caller-frame is a compiled frame
1149 frame callerFrame = stubFrame.sender(®_map2);
1150
1151 if (attached_method.is_null()) {
1152 methodHandle callee = bytecode.static_target(CHECK_NH);
1153 if (callee.is_null()) {
1154 THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle);
1155 }
1156 }
1157
1158 // Retrieve from a compiled argument list
1159 receiver = Handle(THREAD, callerFrame.retrieve_receiver(®_map2));
1160
1161 if (receiver.is_null()) {
1162 THROW_(vmSymbols::java_lang_NullPointerException(), nullHandle);
1163 }
1164 }
1165
1166 assert(receiver.is_null() || receiver->is_oop(), "wrong receiver");
1167
1168 // Resolve method
1169 if (attached_method.not_null()) {
1170 // Parameterized by attached method.
1171 LinkResolver::resolve_invoke(callinfo, receiver, attached_method, bc, CHECK_NH);
1172 } else {
1173 // Parameterized by bytecode.
1174 constantPoolHandle constants(THREAD, caller->constants());
1175 LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_NH);
1176 }
1177
1178 #ifdef ASSERT
1179 // Check that the receiver klass is of the right subtype and that it is initialized for virtual calls
1180 if (has_receiver) {
1181 assert(receiver.not_null(), "should have thrown exception");
1182 KlassHandle receiver_klass(THREAD, receiver->klass());
1183 Klass* rk = NULL;
1184 if (attached_method.not_null()) {
1185 // In case there's resolved method attached, use its holder during the check.
1186 rk = attached_method->method_holder();
1187 } else {
1188 // Klass is already loaded.
1189 constantPoolHandle constants(THREAD, caller->constants());
1190 rk = constants->klass_ref_at(bytecode_index, CHECK_NH);
1191 }
1192 KlassHandle static_receiver_klass(THREAD, rk);
1193 methodHandle callee = callinfo.selected_method();
1194 assert(receiver_klass->is_subtype_of(static_receiver_klass()),
1195 "actual receiver must be subclass of static receiver klass");
1196 if (receiver_klass->is_instance_klass()) {
1197 if (InstanceKlass::cast(receiver_klass())->is_not_initialized()) {
1198 tty->print_cr("ERROR: Klass not yet initialized!!");
1199 receiver_klass()->print();
1200 }
1201 assert(!InstanceKlass::cast(receiver_klass())->is_not_initialized(), "receiver_klass must be initialized");
1202 }
1203 }
1204 #endif
1205
1206 return receiver;
1207 }
1208
1209 methodHandle SharedRuntime::find_callee_method(JavaThread* thread, TRAPS) {
1210 ResourceMark rm(THREAD);
1211 // We need first to check if any Java activations (compiled, interpreted)
1212 // exist on the stack since last JavaCall. If not, we need
1213 // to get the target method from the JavaCall wrapper.
1214 vframeStream vfst(thread, true); // Do not skip any javaCalls
1215 methodHandle callee_method;
1216 if (vfst.at_end()) {
1217 // No Java frames were found on stack since we did the JavaCall.
1218 // Hence the stack can only contain an entry_frame. We need to
1219 // find the target method from the stub frame.
1220 RegisterMap reg_map(thread, false);
1221 frame fr = thread->last_frame();
1222 assert(fr.is_runtime_frame(), "must be a runtimeStub");
1223 fr = fr.sender(®_map);
1224 assert(fr.is_entry_frame(), "must be");
1225 // fr is now pointing to the entry frame.
1226 callee_method = methodHandle(THREAD, fr.entry_frame_call_wrapper()->callee_method());
1227 assert(fr.entry_frame_call_wrapper()->receiver() == NULL || !callee_method->is_static(), "non-null receiver for static call??");
1228 } else {
1229 Bytecodes::Code bc;
1230 CallInfo callinfo;
1231 find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(methodHandle()));
1232 callee_method = callinfo.selected_method();
1233 }
1234 assert(callee_method()->is_method(), "must be");
1235 return callee_method;
1236 }
1237
1238 // Resolves a call.
1239 methodHandle SharedRuntime::resolve_helper(JavaThread *thread,
1240 bool is_virtual,
1241 bool is_optimized, TRAPS) {
1242 methodHandle callee_method;
1243 callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD);
1244 if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
1245 int retry_count = 0;
1246 while (!HAS_PENDING_EXCEPTION && callee_method->is_old() &&
1247 callee_method->method_holder() != SystemDictionary::Object_klass()) {
1248 // If has a pending exception then there is no need to re-try to
1249 // resolve this method.
1250 // If the method has been redefined, we need to try again.
1251 // Hack: we have no way to update the vtables of arrays, so don't
1252 // require that java.lang.Object has been updated.
1253
1254 // It is very unlikely that method is redefined more than 100 times
1255 // in the middle of resolve. If it is looping here more than 100 times
1256 // means then there could be a bug here.
1257 guarantee((retry_count++ < 100),
1258 "Could not resolve to latest version of redefined method");
1259 // method is redefined in the middle of resolve so re-try.
1260 callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD);
1261 }
1262 }
1263 return callee_method;
1264 }
1265
1266 // Resolves a call. The compilers generate code for calls that go here
1267 // and are patched with the real destination of the call.
1268 methodHandle SharedRuntime::resolve_sub_helper(JavaThread *thread,
1269 bool is_virtual,
1270 bool is_optimized, TRAPS) {
1271
1272 ResourceMark rm(thread);
1273 RegisterMap cbl_map(thread, false);
1274 frame caller_frame = thread->last_frame().sender(&cbl_map);
1275
1276 CodeBlob* caller_cb = caller_frame.cb();
1277 guarantee(caller_cb != NULL && caller_cb->is_compiled(), "must be called from compiled method");
1278 CompiledMethod* caller_nm = caller_cb->as_compiled_method_or_null();
1279
1280 // make sure caller is not getting deoptimized
1281 // and removed before we are done with it.
1282 // CLEANUP - with lazy deopt shouldn't need this lock
1283 nmethodLocker caller_lock(caller_nm);
1284
1285 // determine call info & receiver
1286 // note: a) receiver is NULL for static calls
1287 // b) an exception is thrown if receiver is NULL for non-static calls
1288 CallInfo call_info;
1289 Bytecodes::Code invoke_code = Bytecodes::_illegal;
1290 Handle receiver = find_callee_info(thread, invoke_code,
1291 call_info, CHECK_(methodHandle()));
1292 methodHandle callee_method = call_info.selected_method();
1293
1294 assert((!is_virtual && invoke_code == Bytecodes::_invokestatic ) ||
1295 (!is_virtual && invoke_code == Bytecodes::_invokespecial) ||
1296 (!is_virtual && invoke_code == Bytecodes::_invokehandle ) ||
1297 (!is_virtual && invoke_code == Bytecodes::_invokedynamic) ||
1298 ( is_virtual && invoke_code != Bytecodes::_invokestatic ), "inconsistent bytecode");
1299
1300 assert(caller_nm->is_alive(), "It should be alive");
1301
1302 #ifndef PRODUCT
1303 // tracing/debugging/statistics
1304 int *addr = (is_optimized) ? (&_resolve_opt_virtual_ctr) :
1305 (is_virtual) ? (&_resolve_virtual_ctr) :
1306 (&_resolve_static_ctr);
1307 Atomic::inc(addr);
1308
1309 if (TraceCallFixup) {
1310 ResourceMark rm(thread);
1311 tty->print("resolving %s%s (%s) call to",
1312 (is_optimized) ? "optimized " : "", (is_virtual) ? "virtual" : "static",
1313 Bytecodes::name(invoke_code));
1314 callee_method->print_short_name(tty);
1315 tty->print_cr(" at pc: " INTPTR_FORMAT " to code: " INTPTR_FORMAT,
1316 p2i(caller_frame.pc()), p2i(callee_method->code()));
1317 }
1318 #endif
1319
1320 // JSR 292 key invariant:
1321 // If the resolved method is a MethodHandle invoke target, the call
1322 // site must be a MethodHandle call site, because the lambda form might tail-call
1323 // leaving the stack in a state unknown to either caller or callee
1324 // TODO detune for now but we might need it again
1325 // assert(!callee_method->is_compiled_lambda_form() ||
1326 // caller_nm->is_method_handle_return(caller_frame.pc()), "must be MH call site");
1327
1328 // Compute entry points. This might require generation of C2I converter
1329 // frames, so we cannot be holding any locks here. Furthermore, the
1330 // computation of the entry points is independent of patching the call. We
1331 // always return the entry-point, but we only patch the stub if the call has
1332 // not been deoptimized. Return values: For a virtual call this is an
1333 // (cached_oop, destination address) pair. For a static call/optimized
1334 // virtual this is just a destination address.
1335
1336 StaticCallInfo static_call_info;
1337 CompiledICInfo virtual_call_info;
1338
1339 // Make sure the callee nmethod does not get deoptimized and removed before
1340 // we are done patching the code.
1341 CompiledMethod* callee = callee_method->code();
1342
1343 if (callee != NULL) {
1344 assert(callee->is_compiled(), "must be nmethod for patching");
1345 }
1346
1347 if (callee != NULL && !callee->is_in_use()) {
1348 // Patch call site to C2I adapter if callee nmethod is deoptimized or unloaded.
1349 callee = NULL;
1350 }
1351 nmethodLocker nl_callee(callee);
1352 #ifdef ASSERT
1353 address dest_entry_point = callee == NULL ? 0 : callee->entry_point(); // used below
1354 #endif
1355
1356 if (is_virtual) {
1357 assert(receiver.not_null() || invoke_code == Bytecodes::_invokehandle, "sanity check");
1358 bool static_bound = call_info.resolved_method()->can_be_statically_bound();
1359 KlassHandle h_klass(THREAD, invoke_code == Bytecodes::_invokehandle ? NULL : receiver->klass());
1360 CompiledIC::compute_monomorphic_entry(callee_method, h_klass,
1361 is_optimized, static_bound, virtual_call_info,
1362 CHECK_(methodHandle()));
1363 } else {
1364 // static call
1365 CompiledStaticCall::compute_entry(callee_method, static_call_info);
1366 }
1367
1368 // grab lock, check for deoptimization and potentially patch caller
1369 {
1370 MutexLocker ml_patch(CompiledIC_lock);
1371
1372 // Lock blocks for safepoint during which both nmethods can change state.
1373
1374 // Now that we are ready to patch if the Method* was redefined then
1375 // don't update call site and let the caller retry.
1376 // Don't update call site if callee nmethod was unloaded or deoptimized.
1377 // Don't update call site if callee nmethod was replaced by an other nmethod
1378 // which may happen when multiply alive nmethod (tiered compilation)
1379 // will be supported.
1380 if (!callee_method->is_old() &&
1381 (callee == NULL || callee->is_in_use() && (callee_method->code() == callee))) {
1382 #ifdef ASSERT
1383 // We must not try to patch to jump to an already unloaded method.
1384 if (dest_entry_point != 0) {
1385 CodeBlob* cb = CodeCache::find_blob(dest_entry_point);
1386 assert((cb != NULL) && cb->is_compiled() && (((CompiledMethod*)cb) == callee),
1387 "should not call unloaded nmethod");
1388 }
1389 #endif
1390 if (is_virtual) {
1391 CompiledIC* inline_cache = CompiledIC_before(caller_nm, caller_frame.pc());
1392 if (inline_cache->is_clean()) {
1393 inline_cache->set_to_monomorphic(virtual_call_info);
1394 }
1395 } else {
1396 CompiledStaticCall* ssc = compiledStaticCall_before(caller_frame.pc());
1397 if (ssc->is_clean()) ssc->set(static_call_info);
1398 }
1399 }
1400
1401 } // unlock CompiledIC_lock
1402
1403 return callee_method;
1404 }
1405
1406
1407 // Inline caches exist only in compiled code
1408 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_ic_miss(JavaThread* thread))
1409 #ifdef ASSERT
1410 RegisterMap reg_map(thread, false);
1411 frame stub_frame = thread->last_frame();
1412 assert(stub_frame.is_runtime_frame(), "sanity check");
1413 frame caller_frame = stub_frame.sender(®_map);
1414 assert(!caller_frame.is_interpreted_frame() && !caller_frame.is_entry_frame(), "unexpected frame");
1415 #endif /* ASSERT */
1416
1417 methodHandle callee_method;
1418 JRT_BLOCK
1419 callee_method = SharedRuntime::handle_ic_miss_helper(thread, CHECK_NULL);
1420 // Return Method* through TLS
1421 thread->set_vm_result_2(callee_method());
1422 JRT_BLOCK_END
1423 // return compiled code entry point after potential safepoints
1424 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
1425 return callee_method->verified_code_entry();
1426 JRT_END
1427
1428
1429 // Handle call site that has been made non-entrant
1430 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method(JavaThread* thread))
1431 // 6243940 We might end up in here if the callee is deoptimized
1432 // as we race to call it. We don't want to take a safepoint if
1433 // the caller was interpreted because the caller frame will look
1434 // interpreted to the stack walkers and arguments are now
1435 // "compiled" so it is much better to make this transition
1436 // invisible to the stack walking code. The i2c path will
1437 // place the callee method in the callee_target. It is stashed
1438 // there because if we try and find the callee by normal means a
1439 // safepoint is possible and have trouble gc'ing the compiled args.
1440 RegisterMap reg_map(thread, false);
1441 frame stub_frame = thread->last_frame();
1442 assert(stub_frame.is_runtime_frame(), "sanity check");
1443 frame caller_frame = stub_frame.sender(®_map);
1444
1445 if (caller_frame.is_interpreted_frame() ||
1446 caller_frame.is_entry_frame()) {
1447 Method* callee = thread->callee_target();
1448 guarantee(callee != NULL && callee->is_method(), "bad handshake");
1449 thread->set_vm_result_2(callee);
1450 thread->set_callee_target(NULL);
1451 return callee->get_c2i_entry();
1452 }
1453
1454 // Must be compiled to compiled path which is safe to stackwalk
1455 methodHandle callee_method;
1456 JRT_BLOCK
1457 // Force resolving of caller (if we called from compiled frame)
1458 callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_NULL);
1459 thread->set_vm_result_2(callee_method());
1460 JRT_BLOCK_END
1461 // return compiled code entry point after potential safepoints
1462 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
1463 return callee_method->verified_code_entry();
1464 JRT_END
1465
1466 // Handle abstract method call
1467 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_abstract(JavaThread* thread))
1468 return StubRoutines::throw_AbstractMethodError_entry();
1469 JRT_END
1470
1471
1472 // resolve a static call and patch code
1473 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_static_call_C(JavaThread *thread ))
1474 methodHandle callee_method;
1475 JRT_BLOCK
1476 callee_method = SharedRuntime::resolve_helper(thread, false, false, CHECK_NULL);
1477 thread->set_vm_result_2(callee_method());
1478 JRT_BLOCK_END
1479 // return compiled code entry point after potential safepoints
1480 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
1481 return callee_method->verified_code_entry();
1482 JRT_END
1483
1484
1485 // resolve virtual call and update inline cache to monomorphic
1486 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_virtual_call_C(JavaThread *thread ))
1487 methodHandle callee_method;
1488 JRT_BLOCK
1489 callee_method = SharedRuntime::resolve_helper(thread, true, false, CHECK_NULL);
1490 thread->set_vm_result_2(callee_method());
1491 JRT_BLOCK_END
1492 // return compiled code entry point after potential safepoints
1493 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
1494 return callee_method->verified_code_entry();
1495 JRT_END
1496
1497
1498 // Resolve a virtual call that can be statically bound (e.g., always
1499 // monomorphic, so it has no inline cache). Patch code to resolved target.
1500 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_opt_virtual_call_C(JavaThread *thread))
1501 methodHandle callee_method;
1502 JRT_BLOCK
1503 callee_method = SharedRuntime::resolve_helper(thread, true, true, CHECK_NULL);
1504 thread->set_vm_result_2(callee_method());
1505 JRT_BLOCK_END
1506 // return compiled code entry point after potential safepoints
1507 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
1508 return callee_method->verified_code_entry();
1509 JRT_END
1510
1511
1512 methodHandle SharedRuntime::handle_ic_miss_helper(JavaThread *thread, TRAPS) {
1513 ResourceMark rm(thread);
1514 CallInfo call_info;
1515 Bytecodes::Code bc;
1516
1517 // receiver is NULL for static calls. An exception is thrown for NULL
1518 // receivers for non-static calls
1519 Handle receiver = find_callee_info(thread, bc, call_info,
1520 CHECK_(methodHandle()));
1521 // Compiler1 can produce virtual call sites that can actually be statically bound
1522 // If we fell thru to below we would think that the site was going megamorphic
1523 // when in fact the site can never miss. Worse because we'd think it was megamorphic
1524 // we'd try and do a vtable dispatch however methods that can be statically bound
1525 // don't have vtable entries (vtable_index < 0) and we'd blow up. So we force a
1526 // reresolution of the call site (as if we did a handle_wrong_method and not an
1527 // plain ic_miss) and the site will be converted to an optimized virtual call site
1528 // never to miss again. I don't believe C2 will produce code like this but if it
1529 // did this would still be the correct thing to do for it too, hence no ifdef.
1530 //
1531 if (call_info.resolved_method()->can_be_statically_bound()) {
1532 methodHandle callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_(methodHandle()));
1533 if (TraceCallFixup) {
1534 RegisterMap reg_map(thread, false);
1535 frame caller_frame = thread->last_frame().sender(®_map);
1536 ResourceMark rm(thread);
1537 tty->print("converting IC miss to reresolve (%s) call to", Bytecodes::name(bc));
1538 callee_method->print_short_name(tty);
1539 tty->print_cr(" from pc: " INTPTR_FORMAT, p2i(caller_frame.pc()));
1540 tty->print_cr(" code: " INTPTR_FORMAT, p2i(callee_method->code()));
1541 }
1542 return callee_method;
1543 }
1544
1545 methodHandle callee_method = call_info.selected_method();
1546
1547 bool should_be_mono = false;
1548
1549 #ifndef PRODUCT
1550 Atomic::inc(&_ic_miss_ctr);
1551
1552 // Statistics & Tracing
1553 if (TraceCallFixup) {
1554 ResourceMark rm(thread);
1555 tty->print("IC miss (%s) call to", Bytecodes::name(bc));
1556 callee_method->print_short_name(tty);
1557 tty->print_cr(" code: " INTPTR_FORMAT, p2i(callee_method->code()));
1558 }
1559
1560 if (ICMissHistogram) {
1561 MutexLocker m(VMStatistic_lock);
1562 RegisterMap reg_map(thread, false);
1563 frame f = thread->last_frame().real_sender(®_map);// skip runtime stub
1564 // produce statistics under the lock
1565 trace_ic_miss(f.pc());
1566 }
1567 #endif
1568
1569 // install an event collector so that when a vtable stub is created the
1570 // profiler can be notified via a DYNAMIC_CODE_GENERATED event. The
1571 // event can't be posted when the stub is created as locks are held
1572 // - instead the event will be deferred until the event collector goes
1573 // out of scope.
1574 JvmtiDynamicCodeEventCollector event_collector;
1575
1576 // Update inline cache to megamorphic. Skip update if we are called from interpreted.
1577 { MutexLocker ml_patch (CompiledIC_lock);
1578 RegisterMap reg_map(thread, false);
1579 frame caller_frame = thread->last_frame().sender(®_map);
1580 CodeBlob* cb = caller_frame.cb();
1581 CompiledMethod* caller_nm = cb->as_compiled_method_or_null();
1582 if (cb->is_compiled()) {
1583 CompiledIC* inline_cache = CompiledIC_before(((CompiledMethod*)cb), caller_frame.pc());
1584 bool should_be_mono = false;
1585 if (inline_cache->is_optimized()) {
1586 if (TraceCallFixup) {
1587 ResourceMark rm(thread);
1588 tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc));
1589 callee_method->print_short_name(tty);
1590 tty->print_cr(" code: " INTPTR_FORMAT, p2i(callee_method->code()));
1591 }
1592 should_be_mono = true;
1593 } else if (inline_cache->is_icholder_call()) {
1594 CompiledICHolder* ic_oop = inline_cache->cached_icholder();
1595 if (ic_oop != NULL) {
1596
1597 if (receiver()->klass() == ic_oop->holder_klass()) {
1598 // This isn't a real miss. We must have seen that compiled code
1599 // is now available and we want the call site converted to a
1600 // monomorphic compiled call site.
1601 // We can't assert for callee_method->code() != NULL because it
1602 // could have been deoptimized in the meantime
1603 if (TraceCallFixup) {
1604 ResourceMark rm(thread);
1605 tty->print("FALSE IC miss (%s) converting to compiled call to", Bytecodes::name(bc));
1606 callee_method->print_short_name(tty);
1607 tty->print_cr(" code: " INTPTR_FORMAT, p2i(callee_method->code()));
1608 }
1609 should_be_mono = true;
1610 }
1611 }
1612 }
1613
1614 if (should_be_mono) {
1615
1616 // We have a path that was monomorphic but was going interpreted
1617 // and now we have (or had) a compiled entry. We correct the IC
1618 // by using a new icBuffer.
1619 CompiledICInfo info;
1620 KlassHandle receiver_klass(THREAD, receiver()->klass());
1621 inline_cache->compute_monomorphic_entry(callee_method,
1622 receiver_klass,
1623 inline_cache->is_optimized(),
1624 false,
1625 info, CHECK_(methodHandle()));
1626 inline_cache->set_to_monomorphic(info);
1627 } else if (!inline_cache->is_megamorphic() && !inline_cache->is_clean()) {
1628 // Potential change to megamorphic
1629 bool successful = inline_cache->set_to_megamorphic(&call_info, bc, CHECK_(methodHandle()));
1630 if (!successful) {
1631 inline_cache->set_to_clean();
1632 }
1633 } else {
1634 // Either clean or megamorphic
1635 }
1636 } else {
1637 fatal("Unimplemented");
1638 }
1639 } // Release CompiledIC_lock
1640
1641 return callee_method;
1642 }
1643
1644 //
1645 // Resets a call-site in compiled code so it will get resolved again.
1646 // This routines handles both virtual call sites, optimized virtual call
1647 // sites, and static call sites. Typically used to change a call sites
1648 // destination from compiled to interpreted.
1649 //
1650 methodHandle SharedRuntime::reresolve_call_site(JavaThread *thread, TRAPS) {
1651 ResourceMark rm(thread);
1652 RegisterMap reg_map(thread, false);
1653 frame stub_frame = thread->last_frame();
1654 assert(stub_frame.is_runtime_frame(), "must be a runtimeStub");
1655 frame caller = stub_frame.sender(®_map);
1656
1657 // Do nothing if the frame isn't a live compiled frame.
1658 // nmethod could be deoptimized by the time we get here
1659 // so no update to the caller is needed.
1660
1661 if (caller.is_compiled_frame() && !caller.is_deoptimized_frame()) {
1662
1663 address pc = caller.pc();
1664
1665 // Check for static or virtual call
1666 bool is_static_call = false;
1667 CompiledMethod* caller_nm = CodeCache::find_compiled(pc);
1668
1669 // Default call_addr is the location of the "basic" call.
1670 // Determine the address of the call we a reresolving. With
1671 // Inline Caches we will always find a recognizable call.
1672 // With Inline Caches disabled we may or may not find a
1673 // recognizable call. We will always find a call for static
1674 // calls and for optimized virtual calls. For vanilla virtual
1675 // calls it depends on the state of the UseInlineCaches switch.
1676 //
1677 // With Inline Caches disabled we can get here for a virtual call
1678 // for two reasons:
1679 // 1 - calling an abstract method. The vtable for abstract methods
1680 // will run us thru handle_wrong_method and we will eventually
1681 // end up in the interpreter to throw the ame.
1682 // 2 - a racing deoptimization. We could be doing a vanilla vtable
1683 // call and between the time we fetch the entry address and
1684 // we jump to it the target gets deoptimized. Similar to 1
1685 // we will wind up in the interprter (thru a c2i with c2).
1686 //
1687 address call_addr = NULL;
1688 {
1689 // Get call instruction under lock because another thread may be
1690 // busy patching it.
1691 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
1692 // Location of call instruction
1693 if (NativeCall::is_call_before(pc)) {
1694 NativeCall *ncall = nativeCall_before(pc);
1695 call_addr = ncall->instruction_address();
1696 }
1697 }
1698 // Make sure nmethod doesn't get deoptimized and removed until
1699 // this is done with it.
1700 // CLEANUP - with lazy deopt shouldn't need this lock
1701 nmethodLocker nmlock(caller_nm);
1702
1703 if (call_addr != NULL) {
1704 RelocIterator iter(caller_nm, call_addr, call_addr+1);
1705 int ret = iter.next(); // Get item
1706 if (ret) {
1707 assert(iter.addr() == call_addr, "must find call");
1708 if (iter.type() == relocInfo::static_call_type) {
1709 is_static_call = true;
1710 } else {
1711 assert(iter.type() == relocInfo::virtual_call_type ||
1712 iter.type() == relocInfo::opt_virtual_call_type
1713 , "unexpected relocInfo. type");
1714 }
1715 } else {
1716 assert(!UseInlineCaches, "relocation info. must exist for this address");
1717 }
1718
1719 // Cleaning the inline cache will force a new resolve. This is more robust
1720 // than directly setting it to the new destination, since resolving of calls
1721 // is always done through the same code path. (experience shows that it
1722 // leads to very hard to track down bugs, if an inline cache gets updated
1723 // to a wrong method). It should not be performance critical, since the
1724 // resolve is only done once.
1725
1726 MutexLocker ml(CompiledIC_lock);
1727 if (is_static_call) {
1728 CompiledStaticCall* ssc= compiledStaticCall_at(call_addr);
1729 ssc->set_to_clean();
1730 } else {
1731 // compiled, dispatched call (which used to call an interpreted method)
1732 CompiledIC* inline_cache = CompiledIC_at(caller_nm, call_addr);
1733 inline_cache->set_to_clean();
1734 }
1735 }
1736 }
1737
1738 methodHandle callee_method = find_callee_method(thread, CHECK_(methodHandle()));
1739
1740
1741 #ifndef PRODUCT
1742 Atomic::inc(&_wrong_method_ctr);
1743
1744 if (TraceCallFixup) {
1745 ResourceMark rm(thread);
1746 tty->print("handle_wrong_method reresolving call to");
1747 callee_method->print_short_name(tty);
1748 tty->print_cr(" code: " INTPTR_FORMAT, p2i(callee_method->code()));
1749 }
1750 #endif
1751
1752 return callee_method;
1753 }
1754
1755 address SharedRuntime::handle_unsafe_access(JavaThread* thread, address next_pc) {
1756 // The faulting unsafe accesses should be changed to throw the error
1757 // synchronously instead. Meanwhile the faulting instruction will be
1758 // skipped over (effectively turning it into a no-op) and an
1759 // asynchronous exception will be raised which the thread will
1760 // handle at a later point. If the instruction is a load it will
1761 // return garbage.
1762
1763 // Request an async exception.
1764 thread->set_pending_unsafe_access_error();
1765
1766 // Return address of next instruction to execute.
1767 return next_pc;
1768 }
1769
1770 #ifdef ASSERT
1771 void SharedRuntime::check_member_name_argument_is_last_argument(const methodHandle& method,
1772 const BasicType* sig_bt,
1773 const VMRegPair* regs) {
1774 ResourceMark rm;
1775 const int total_args_passed = method->size_of_parameters();
1776 const VMRegPair* regs_with_member_name = regs;
1777 VMRegPair* regs_without_member_name = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed - 1);
1778
1779 const int member_arg_pos = total_args_passed - 1;
1780 assert(member_arg_pos >= 0 && member_arg_pos < total_args_passed, "oob");
1781 assert(sig_bt[member_arg_pos] == T_OBJECT, "dispatch argument must be an object");
1782
1783 const bool is_outgoing = method->is_method_handle_intrinsic();
1784 int comp_args_on_stack = java_calling_convention(sig_bt, regs_without_member_name, total_args_passed - 1, is_outgoing);
1785
1786 for (int i = 0; i < member_arg_pos; i++) {
1787 VMReg a = regs_with_member_name[i].first();
1788 VMReg b = regs_without_member_name[i].first();
1789 assert(a->value() == b->value(), "register allocation mismatch: a=" INTX_FORMAT ", b=" INTX_FORMAT, a->value(), b->value());
1790 }
1791 assert(regs_with_member_name[member_arg_pos].first()->is_valid(), "bad member arg");
1792 }
1793 #endif
1794
1795 // ---------------------------------------------------------------------------
1796 // We are calling the interpreter via a c2i. Normally this would mean that
1797 // we were called by a compiled method. However we could have lost a race
1798 // where we went int -> i2c -> c2i and so the caller could in fact be
1799 // interpreted. If the caller is compiled we attempt to patch the caller
1800 // so he no longer calls into the interpreter.
1801 IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address caller_pc))
1802 Method* moop(method);
1803
1804 address entry_point = moop->from_compiled_entry_no_trampoline();
1805
1806 // It's possible that deoptimization can occur at a call site which hasn't
1807 // been resolved yet, in which case this function will be called from
1808 // an nmethod that has been patched for deopt and we can ignore the
1809 // request for a fixup.
1810 // Also it is possible that we lost a race in that from_compiled_entry
1811 // is now back to the i2c in that case we don't need to patch and if
1812 // we did we'd leap into space because the callsite needs to use
1813 // "to interpreter" stub in order to load up the Method*. Don't
1814 // ask me how I know this...
1815
1816 CodeBlob* cb = CodeCache::find_blob(caller_pc);
1817 if (!cb->is_compiled() || entry_point == moop->get_c2i_entry()) {
1818 return;
1819 }
1820
1821 // The check above makes sure this is a nmethod.
1822 CompiledMethod* nm = cb->as_compiled_method_or_null();
1823 assert(nm, "must be");
1824
1825 // Get the return PC for the passed caller PC.
1826 address return_pc = caller_pc + frame::pc_return_offset;
1827
1828 // There is a benign race here. We could be attempting to patch to a compiled
1829 // entry point at the same time the callee is being deoptimized. If that is
1830 // the case then entry_point may in fact point to a c2i and we'd patch the
1831 // call site with the same old data. clear_code will set code() to NULL
1832 // at the end of it. If we happen to see that NULL then we can skip trying
1833 // to patch. If we hit the window where the callee has a c2i in the
1834 // from_compiled_entry and the NULL isn't present yet then we lose the race
1835 // and patch the code with the same old data. Asi es la vida.
1836
1837 if (moop->code() == NULL) return;
1838
1839 if (nm->is_in_use()) {
1840
1841 // Expect to find a native call there (unless it was no-inline cache vtable dispatch)
1842 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
1843 if (NativeCall::is_call_before(return_pc)) {
1844 NativeCall *call = nativeCall_before(return_pc);
1845 //
1846 // bug 6281185. We might get here after resolving a call site to a vanilla
1847 // virtual call. Because the resolvee uses the verified entry it may then
1848 // see compiled code and attempt to patch the site by calling us. This would
1849 // then incorrectly convert the call site to optimized and its downhill from
1850 // there. If you're lucky you'll get the assert in the bugid, if not you've
1851 // just made a call site that could be megamorphic into a monomorphic site
1852 // for the rest of its life! Just another racing bug in the life of
1853 // fixup_callers_callsite ...
1854 //
1855 RelocIterator iter(nm, call->instruction_address(), call->next_instruction_address());
1856 iter.next();
1857 assert(iter.has_current(), "must have a reloc at java call site");
1858 relocInfo::relocType typ = iter.reloc()->type();
1859 if (typ != relocInfo::static_call_type &&
1860 typ != relocInfo::opt_virtual_call_type &&
1861 typ != relocInfo::static_stub_type) {
1862 return;
1863 }
1864 address destination = call->destination();
1865 if (destination != entry_point) {
1866 CodeBlob* callee = CodeCache::find_blob(destination);
1867 // callee == cb seems weird. It means calling interpreter thru stub.
1868 if (callee == cb || callee->is_adapter_blob()) {
1869 // static call or optimized virtual
1870 if (TraceCallFixup) {
1871 tty->print("fixup callsite at " INTPTR_FORMAT " to compiled code for", p2i(caller_pc));
1872 moop->print_short_name(tty);
1873 tty->print_cr(" to " INTPTR_FORMAT, p2i(entry_point));
1874 }
1875 call->set_destination_mt_safe(entry_point);
1876 } else {
1877 if (TraceCallFixup) {
1878 tty->print("failed to fixup callsite at " INTPTR_FORMAT " to compiled code for", p2i(caller_pc));
1879 moop->print_short_name(tty);
1880 tty->print_cr(" to " INTPTR_FORMAT, p2i(entry_point));
1881 }
1882 // assert is too strong could also be resolve destinations.
1883 // assert(InlineCacheBuffer::contains(destination) || VtableStubs::contains(destination), "must be");
1884 }
1885 } else {
1886 if (TraceCallFixup) {
1887 tty->print("already patched callsite at " INTPTR_FORMAT " to compiled code for", p2i(caller_pc));
1888 moop->print_short_name(tty);
1889 tty->print_cr(" to " INTPTR_FORMAT, p2i(entry_point));
1890 }
1891 }
1892 }
1893 }
1894 IRT_END
1895
1896
1897 // same as JVM_Arraycopy, but called directly from compiled code
1898 JRT_ENTRY(void, SharedRuntime::slow_arraycopy_C(oopDesc* src, jint src_pos,
1899 oopDesc* dest, jint dest_pos,
1900 jint length,
1901 JavaThread* thread)) {
1902 #ifndef PRODUCT
1903 _slow_array_copy_ctr++;
1904 #endif
1905 // Check if we have null pointers
1906 if (src == NULL || dest == NULL) {
1907 THROW(vmSymbols::java_lang_NullPointerException());
1908 }
1909 // Do the copy. The casts to arrayOop are necessary to the copy_array API,
1910 // even though the copy_array API also performs dynamic checks to ensure
1911 // that src and dest are truly arrays (and are conformable).
1912 // The copy_array mechanism is awkward and could be removed, but
1913 // the compilers don't call this function except as a last resort,
1914 // so it probably doesn't matter.
1915 src->klass()->copy_array((arrayOopDesc*)src, src_pos,
1916 (arrayOopDesc*)dest, dest_pos,
1917 length, thread);
1918 }
1919 JRT_END
1920
1921 // The caller of generate_class_cast_message() (or one of its callers)
1922 // must use a ResourceMark in order to correctly free the result.
1923 char* SharedRuntime::generate_class_cast_message(
1924 JavaThread* thread, Klass* caster_klass) {
1925
1926 // Get target class name from the checkcast instruction
1927 vframeStream vfst(thread, true);
1928 assert(!vfst.at_end(), "Java frame must exist");
1929 Bytecode_checkcast cc(vfst.method(), vfst.method()->bcp_from(vfst.bci()));
1930 Klass* target_klass = vfst.method()->constants()->klass_at(
1931 cc.index(), thread);
1932 return generate_class_cast_message(caster_klass, target_klass);
1933 }
1934
1935 char* SharedRuntime::generate_class_cast_message(
1936 Klass* caster_klass, Klass* target_klass) {
1937
1938 const char* caster_klass_name = caster_klass->external_name();
1939 Klass* c_klass = caster_klass->is_objArray_klass() ?
1940 ObjArrayKlass::cast(caster_klass)->bottom_klass() : caster_klass;
1941 ModuleEntry* caster_module;
1942 const char* caster_module_name;
1943 if (c_klass->is_instance_klass()) {
1944 caster_module = InstanceKlass::cast(c_klass)->module();
1945 caster_module_name = caster_module->is_named() ?
1946 caster_module->name()->as_C_string() : UNNAMED_MODULE;
1947 } else {
1948 caster_module_name = "java.base";
1949 }
1950 const char* target_klass_name = target_klass->external_name();
1951 Klass* t_klass = target_klass->is_objArray_klass() ?
1952 ObjArrayKlass::cast(target_klass)->bottom_klass() : target_klass;
1953 ModuleEntry* target_module;
1954 const char* target_module_name;
1955 if (t_klass->is_instance_klass()) {
1956 target_module = InstanceKlass::cast(t_klass)->module();
1957 target_module_name = target_module->is_named() ?
1958 target_module->name()->as_C_string(): UNNAMED_MODULE;
1959 } else {
1960 target_module_name = "java.base";
1961 }
1962
1963 size_t msglen = strlen(caster_klass_name) + strlen(caster_module_name) +
1964 strlen(target_klass_name) + strlen(target_module_name) + 50;
1965
1966 char* message = NEW_RESOURCE_ARRAY(char, msglen);
1967 if (NULL == message) {
1968 // Shouldn't happen, but don't cause even more problems if it does
1969 message = const_cast<char*>(caster_klass_name);
1970 } else {
1971 jio_snprintf(message, msglen, "%s (in module: %s) cannot be cast to %s (in module: %s)",
1972 caster_klass_name, caster_module_name, target_klass_name, target_module_name);
1973 }
1974 return message;
1975 }
1976
1977 JRT_LEAF(void, SharedRuntime::reguard_yellow_pages())
1978 (void) JavaThread::current()->reguard_stack();
1979 JRT_END
1980
1981
1982 // Handles the uncommon case in locking, i.e., contention or an inflated lock.
1983 JRT_BLOCK_ENTRY(void, SharedRuntime::complete_monitor_locking_C(oopDesc* _obj, BasicLock* lock, JavaThread* thread))
1984 // Disable ObjectSynchronizer::quick_enter() in default config
1985 // on AARCH64 until JDK-8153107 is resolved.
1986 if (AARCH64_ONLY((SyncFlags & 256) != 0 &&) !SafepointSynchronize::is_synchronizing()) {
1987 // Only try quick_enter() if we're not trying to reach a safepoint
1988 // so that the calling thread reaches the safepoint more quickly.
1989 if (ObjectSynchronizer::quick_enter(_obj, thread, lock)) return;
1990 }
1991 // NO_ASYNC required because an async exception on the state transition destructor
1992 // would leave you with the lock held and it would never be released.
1993 // The normal monitorenter NullPointerException is thrown without acquiring a lock
1994 // and the model is that an exception implies the method failed.
1995 JRT_BLOCK_NO_ASYNC
1996 oop obj(_obj);
1997 if (PrintBiasedLockingStatistics) {
1998 Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
1999 }
2000 Handle h_obj(THREAD, obj);
2001 if (UseBiasedLocking) {
2002 // Retry fast entry if bias is revoked to avoid unnecessary inflation
2003 ObjectSynchronizer::fast_enter(h_obj, lock, true, CHECK);
2004 } else {
2005 ObjectSynchronizer::slow_enter(h_obj, lock, CHECK);
2006 }
2007 assert(!HAS_PENDING_EXCEPTION, "Should have no exception here");
2008 JRT_BLOCK_END
2009 JRT_END
2010
2011 // Handles the uncommon cases of monitor unlocking in compiled code
2012 JRT_LEAF(void, SharedRuntime::complete_monitor_unlocking_C(oopDesc* _obj, BasicLock* lock, JavaThread * THREAD))
2013 oop obj(_obj);
2014 assert(JavaThread::current() == THREAD, "invariant");
2015 // I'm not convinced we need the code contained by MIGHT_HAVE_PENDING anymore
2016 // testing was unable to ever fire the assert that guarded it so I have removed it.
2017 assert(!HAS_PENDING_EXCEPTION, "Do we need code below anymore?");
2018 #undef MIGHT_HAVE_PENDING
2019 #ifdef MIGHT_HAVE_PENDING
2020 // Save and restore any pending_exception around the exception mark.
2021 // While the slow_exit must not throw an exception, we could come into
2022 // this routine with one set.
2023 oop pending_excep = NULL;
2024 const char* pending_file;
2025 int pending_line;
2026 if (HAS_PENDING_EXCEPTION) {
2027 pending_excep = PENDING_EXCEPTION;
2028 pending_file = THREAD->exception_file();
2029 pending_line = THREAD->exception_line();
2030 CLEAR_PENDING_EXCEPTION;
2031 }
2032 #endif /* MIGHT_HAVE_PENDING */
2033
2034 {
2035 // Exit must be non-blocking, and therefore no exceptions can be thrown.
2036 EXCEPTION_MARK;
2037 ObjectSynchronizer::slow_exit(obj, lock, THREAD);
2038 }
2039
2040 #ifdef MIGHT_HAVE_PENDING
2041 if (pending_excep != NULL) {
2042 THREAD->set_pending_exception(pending_excep, pending_file, pending_line);
2043 }
2044 #endif /* MIGHT_HAVE_PENDING */
2045 JRT_END
2046
2047 #ifndef PRODUCT
2048
2049 void SharedRuntime::print_statistics() {
2050 ttyLocker ttyl;
2051 if (xtty != NULL) xtty->head("statistics type='SharedRuntime'");
2052
2053 if (_throw_null_ctr) tty->print_cr("%5d implicit null throw", _throw_null_ctr);
2054
2055 SharedRuntime::print_ic_miss_histogram();
2056
2057 if (CountRemovableExceptions) {
2058 if (_nof_removable_exceptions > 0) {
2059 Unimplemented(); // this counter is not yet incremented
2060 tty->print_cr("Removable exceptions: %d", _nof_removable_exceptions);
2061 }
2062 }
2063
2064 // Dump the JRT_ENTRY counters
2065 if (_new_instance_ctr) tty->print_cr("%5d new instance requires GC", _new_instance_ctr);
2066 if (_new_array_ctr) tty->print_cr("%5d new array requires GC", _new_array_ctr);
2067 if (_multi1_ctr) tty->print_cr("%5d multianewarray 1 dim", _multi1_ctr);
2068 if (_multi2_ctr) tty->print_cr("%5d multianewarray 2 dim", _multi2_ctr);
2069 if (_multi3_ctr) tty->print_cr("%5d multianewarray 3 dim", _multi3_ctr);
2070 if (_multi4_ctr) tty->print_cr("%5d multianewarray 4 dim", _multi4_ctr);
2071 if (_multi5_ctr) tty->print_cr("%5d multianewarray 5 dim", _multi5_ctr);
2072
2073 tty->print_cr("%5d inline cache miss in compiled", _ic_miss_ctr);
2074 tty->print_cr("%5d wrong method", _wrong_method_ctr);
2075 tty->print_cr("%5d unresolved static call site", _resolve_static_ctr);
2076 tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr);
2077 tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr);
2078
2079 if (_mon_enter_stub_ctr) tty->print_cr("%5d monitor enter stub", _mon_enter_stub_ctr);
2080 if (_mon_exit_stub_ctr) tty->print_cr("%5d monitor exit stub", _mon_exit_stub_ctr);
2081 if (_mon_enter_ctr) tty->print_cr("%5d monitor enter slow", _mon_enter_ctr);
2082 if (_mon_exit_ctr) tty->print_cr("%5d monitor exit slow", _mon_exit_ctr);
2083 if (_partial_subtype_ctr) tty->print_cr("%5d slow partial subtype", _partial_subtype_ctr);
2084 if (_jbyte_array_copy_ctr) tty->print_cr("%5d byte array copies", _jbyte_array_copy_ctr);
2085 if (_jshort_array_copy_ctr) tty->print_cr("%5d short array copies", _jshort_array_copy_ctr);
2086 if (_jint_array_copy_ctr) tty->print_cr("%5d int array copies", _jint_array_copy_ctr);
2087 if (_jlong_array_copy_ctr) tty->print_cr("%5d long array copies", _jlong_array_copy_ctr);
2088 if (_oop_array_copy_ctr) tty->print_cr("%5d oop array copies", _oop_array_copy_ctr);
2089 if (_checkcast_array_copy_ctr) tty->print_cr("%5d checkcast array copies", _checkcast_array_copy_ctr);
2090 if (_unsafe_array_copy_ctr) tty->print_cr("%5d unsafe array copies", _unsafe_array_copy_ctr);
2091 if (_generic_array_copy_ctr) tty->print_cr("%5d generic array copies", _generic_array_copy_ctr);
2092 if (_slow_array_copy_ctr) tty->print_cr("%5d slow array copies", _slow_array_copy_ctr);
2093 if (_find_handler_ctr) tty->print_cr("%5d find exception handler", _find_handler_ctr);
2094 if (_rethrow_ctr) tty->print_cr("%5d rethrow handler", _rethrow_ctr);
2095
2096 AdapterHandlerLibrary::print_statistics();
2097
2098 if (xtty != NULL) xtty->tail("statistics");
2099 }
2100
2101 inline double percent(int x, int y) {
2102 return 100.0 * x / MAX2(y, 1);
2103 }
2104
2105 class MethodArityHistogram {
2106 public:
2107 enum { MAX_ARITY = 256 };
2108 private:
2109 static int _arity_histogram[MAX_ARITY]; // histogram of #args
2110 static int _size_histogram[MAX_ARITY]; // histogram of arg size in words
2111 static int _max_arity; // max. arity seen
2112 static int _max_size; // max. arg size seen
2113
2114 static void add_method_to_histogram(nmethod* nm) {
2115 Method* m = nm->method();
2116 ArgumentCount args(m->signature());
2117 int arity = args.size() + (m->is_static() ? 0 : 1);
2118 int argsize = m->size_of_parameters();
2119 arity = MIN2(arity, MAX_ARITY-1);
2120 argsize = MIN2(argsize, MAX_ARITY-1);
2121 int count = nm->method()->compiled_invocation_count();
2122 _arity_histogram[arity] += count;
2123 _size_histogram[argsize] += count;
2124 _max_arity = MAX2(_max_arity, arity);
2125 _max_size = MAX2(_max_size, argsize);
2126 }
2127
2128 void print_histogram_helper(int n, int* histo, const char* name) {
2129 const int N = MIN2(5, n);
2130 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):");
2131 double sum = 0;
2132 double weighted_sum = 0;
2133 int i;
2134 for (i = 0; i <= n; i++) { sum += histo[i]; weighted_sum += i*histo[i]; }
2135 double rest = sum;
2136 double percent = sum / 100;
2137 for (i = 0; i <= N; i++) {
2138 rest -= histo[i];
2139 tty->print_cr("%4d: %7d (%5.1f%%)", i, histo[i], histo[i] / percent);
2140 }
2141 tty->print_cr("rest: %7d (%5.1f%%))", (int)rest, rest / percent);
2142 tty->print_cr("(avg. %s = %3.1f, max = %d)", name, weighted_sum / sum, n);
2143 }
2144
2145 void print_histogram() {
2146 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):");
2147 print_histogram_helper(_max_arity, _arity_histogram, "arity");
2148 tty->print_cr("\nSame for parameter size (in words):");
2149 print_histogram_helper(_max_size, _size_histogram, "size");
2150 tty->cr();
2151 }
2152
2153 public:
2154 MethodArityHistogram() {
2155 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
2156 _max_arity = _max_size = 0;
2157 for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram[i] = 0;
2158 CodeCache::nmethods_do(add_method_to_histogram);
2159 print_histogram();
2160 }
2161 };
2162
2163 int MethodArityHistogram::_arity_histogram[MethodArityHistogram::MAX_ARITY];
2164 int MethodArityHistogram::_size_histogram[MethodArityHistogram::MAX_ARITY];
2165 int MethodArityHistogram::_max_arity;
2166 int MethodArityHistogram::_max_size;
2167
2168 void SharedRuntime::print_call_statistics(int comp_total) {
2169 tty->print_cr("Calls from compiled code:");
2170 int total = _nof_normal_calls + _nof_interface_calls + _nof_static_calls;
2171 int mono_c = _nof_normal_calls - _nof_optimized_calls - _nof_megamorphic_calls;
2172 int mono_i = _nof_interface_calls - _nof_optimized_interface_calls - _nof_megamorphic_interface_calls;
2173 tty->print_cr("\t%9d (%4.1f%%) total non-inlined ", total, percent(total, total));
2174 tty->print_cr("\t%9d (%4.1f%%) virtual calls ", _nof_normal_calls, percent(_nof_normal_calls, total));
2175 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_calls, percent(_nof_inlined_calls, _nof_normal_calls));
2176 tty->print_cr("\t %9d (%3.0f%%) optimized ", _nof_optimized_calls, percent(_nof_optimized_calls, _nof_normal_calls));
2177 tty->print_cr("\t %9d (%3.0f%%) monomorphic ", mono_c, percent(mono_c, _nof_normal_calls));
2178 tty->print_cr("\t %9d (%3.0f%%) megamorphic ", _nof_megamorphic_calls, percent(_nof_megamorphic_calls, _nof_normal_calls));
2179 tty->print_cr("\t%9d (%4.1f%%) interface calls ", _nof_interface_calls, percent(_nof_interface_calls, total));
2180 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_interface_calls, percent(_nof_inlined_interface_calls, _nof_interface_calls));
2181 tty->print_cr("\t %9d (%3.0f%%) optimized ", _nof_optimized_interface_calls, percent(_nof_optimized_interface_calls, _nof_interface_calls));
2182 tty->print_cr("\t %9d (%3.0f%%) monomorphic ", mono_i, percent(mono_i, _nof_interface_calls));
2183 tty->print_cr("\t %9d (%3.0f%%) megamorphic ", _nof_megamorphic_interface_calls, percent(_nof_megamorphic_interface_calls, _nof_interface_calls));
2184 tty->print_cr("\t%9d (%4.1f%%) static/special calls", _nof_static_calls, percent(_nof_static_calls, total));
2185 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_static_calls, percent(_nof_inlined_static_calls, _nof_static_calls));
2186 tty->cr();
2187 tty->print_cr("Note 1: counter updates are not MT-safe.");
2188 tty->print_cr("Note 2: %% in major categories are relative to total non-inlined calls;");
2189 tty->print_cr(" %% in nested categories are relative to their category");
2190 tty->print_cr(" (and thus add up to more than 100%% with inlining)");
2191 tty->cr();
2192
2193 MethodArityHistogram h;
2194 }
2195 #endif
2196
2197
2198 // A simple wrapper class around the calling convention information
2199 // that allows sharing of adapters for the same calling convention.
2200 class AdapterFingerPrint : public CHeapObj<mtCode> {
2201 private:
2202 enum {
2203 _basic_type_bits = 4,
2204 _basic_type_mask = right_n_bits(_basic_type_bits),
2205 _basic_types_per_int = BitsPerInt / _basic_type_bits,
2206 _compact_int_count = 3
2207 };
2208 // TO DO: Consider integrating this with a more global scheme for compressing signatures.
2209 // For now, 4 bits per components (plus T_VOID gaps after double/long) is not excessive.
2210
2211 union {
2212 int _compact[_compact_int_count];
2213 int* _fingerprint;
2214 } _value;
2215 int _length; // A negative length indicates the fingerprint is in the compact form,
2216 // Otherwise _value._fingerprint is the array.
2217
2218 // Remap BasicTypes that are handled equivalently by the adapters.
2219 // These are correct for the current system but someday it might be
2220 // necessary to make this mapping platform dependent.
2221 static int adapter_encoding(BasicType in) {
2222 switch (in) {
2223 case T_BOOLEAN:
2224 case T_BYTE:
2225 case T_SHORT:
2226 case T_CHAR:
2227 // There are all promoted to T_INT in the calling convention
2228 return T_INT;
2229
2230 case T_OBJECT:
2231 case T_ARRAY:
2232 // In other words, we assume that any register good enough for
2233 // an int or long is good enough for a managed pointer.
2234 #ifdef _LP64
2235 return T_LONG;
2236 #else
2237 return T_INT;
2238 #endif
2239
2240 case T_INT:
2241 case T_LONG:
2242 case T_FLOAT:
2243 case T_DOUBLE:
2244 case T_VOID:
2245 return in;
2246
2247 default:
2248 ShouldNotReachHere();
2249 return T_CONFLICT;
2250 }
2251 }
2252
2253 public:
2254 AdapterFingerPrint(int total_args_passed, BasicType* sig_bt) {
2255 // The fingerprint is based on the BasicType signature encoded
2256 // into an array of ints with eight entries per int.
2257 int* ptr;
2258 int len = (total_args_passed + (_basic_types_per_int-1)) / _basic_types_per_int;
2259 if (len <= _compact_int_count) {
2260 assert(_compact_int_count == 3, "else change next line");
2261 _value._compact[0] = _value._compact[1] = _value._compact[2] = 0;
2262 // Storing the signature encoded as signed chars hits about 98%
2263 // of the time.
2264 _length = -len;
2265 ptr = _value._compact;
2266 } else {
2267 _length = len;
2268 _value._fingerprint = NEW_C_HEAP_ARRAY(int, _length, mtCode);
2269 ptr = _value._fingerprint;
2270 }
2271
2272 // Now pack the BasicTypes with 8 per int
2273 int sig_index = 0;
2274 for (int index = 0; index < len; index++) {
2275 int value = 0;
2276 for (int byte = 0; byte < _basic_types_per_int; byte++) {
2277 int bt = ((sig_index < total_args_passed)
2278 ? adapter_encoding(sig_bt[sig_index++])
2279 : 0);
2280 assert((bt & _basic_type_mask) == bt, "must fit in 4 bits");
2281 value = (value << _basic_type_bits) | bt;
2282 }
2283 ptr[index] = value;
2284 }
2285 }
2286
2287 ~AdapterFingerPrint() {
2288 if (_length > 0) {
2289 FREE_C_HEAP_ARRAY(int, _value._fingerprint);
2290 }
2291 }
2292
2293 int value(int index) {
2294 if (_length < 0) {
2295 return _value._compact[index];
2296 }
2297 return _value._fingerprint[index];
2298 }
2299 int length() {
2300 if (_length < 0) return -_length;
2301 return _length;
2302 }
2303
2304 bool is_compact() {
2305 return _length <= 0;
2306 }
2307
2308 unsigned int compute_hash() {
2309 int hash = 0;
2310 for (int i = 0; i < length(); i++) {
2311 int v = value(i);
2312 hash = (hash << 8) ^ v ^ (hash >> 5);
2313 }
2314 return (unsigned int)hash;
2315 }
2316
2317 const char* as_string() {
2318 stringStream st;
2319 st.print("0x");
2320 for (int i = 0; i < length(); i++) {
2321 st.print("%08x", value(i));
2322 }
2323 return st.as_string();
2324 }
2325
2326 bool equals(AdapterFingerPrint* other) {
2327 if (other->_length != _length) {
2328 return false;
2329 }
2330 if (_length < 0) {
2331 assert(_compact_int_count == 3, "else change next line");
2332 return _value._compact[0] == other->_value._compact[0] &&
2333 _value._compact[1] == other->_value._compact[1] &&
2334 _value._compact[2] == other->_value._compact[2];
2335 } else {
2336 for (int i = 0; i < _length; i++) {
2337 if (_value._fingerprint[i] != other->_value._fingerprint[i]) {
2338 return false;
2339 }
2340 }
2341 }
2342 return true;
2343 }
2344 };
2345
2346
2347 // A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries
2348 class AdapterHandlerTable : public BasicHashtable<mtCode> {
2349 friend class AdapterHandlerTableIterator;
2350
2351 private:
2352
2353 #ifndef PRODUCT
2354 static int _lookups; // number of calls to lookup
2355 static int _buckets; // number of buckets checked
2356 static int _equals; // number of buckets checked with matching hash
2357 static int _hits; // number of successful lookups
2358 static int _compact; // number of equals calls with compact signature
2359 #endif
2360
2361 AdapterHandlerEntry* bucket(int i) {
2362 return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i);
2363 }
2364
2365 public:
2366 AdapterHandlerTable()
2367 : BasicHashtable<mtCode>(293, (DumpSharedSpaces ? sizeof(CDSAdapterHandlerEntry) : sizeof(AdapterHandlerEntry))) { }
2368
2369 // Create a new entry suitable for insertion in the table
2370 AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
2371 AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash());
2372 entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
2373 if (DumpSharedSpaces) {
2374 ((CDSAdapterHandlerEntry*)entry)->init();
2375 }
2376 return entry;
2377 }
2378
2379 // Insert an entry into the table
2380 void add(AdapterHandlerEntry* entry) {
2381 int index = hash_to_index(entry->hash());
2382 add_entry(index, entry);
2383 }
2384
2385 void free_entry(AdapterHandlerEntry* entry) {
2386 entry->deallocate();
2387 BasicHashtable<mtCode>::free_entry(entry);
2388 }
2389
2390 // Find a entry with the same fingerprint if it exists
2391 AdapterHandlerEntry* lookup(int total_args_passed, BasicType* sig_bt) {
2392 NOT_PRODUCT(_lookups++);
2393 AdapterFingerPrint fp(total_args_passed, sig_bt);
2394 unsigned int hash = fp.compute_hash();
2395 int index = hash_to_index(hash);
2396 for (AdapterHandlerEntry* e = bucket(index); e != NULL; e = e->next()) {
2397 NOT_PRODUCT(_buckets++);
2398 if (e->hash() == hash) {
2399 NOT_PRODUCT(_equals++);
2400 if (fp.equals(e->fingerprint())) {
2401 #ifndef PRODUCT
2402 if (fp.is_compact()) _compact++;
2403 _hits++;
2404 #endif
2405 return e;
2406 }
2407 }
2408 }
2409 return NULL;
2410 }
2411
2412 #ifndef PRODUCT
2413 void print_statistics() {
2414 ResourceMark rm;
2415 int longest = 0;
2416 int empty = 0;
2417 int total = 0;
2418 int nonempty = 0;
2419 for (int index = 0; index < table_size(); index++) {
2420 int count = 0;
2421 for (AdapterHandlerEntry* e = bucket(index); e != NULL; e = e->next()) {
2422 count++;
2423 }
2424 if (count != 0) nonempty++;
2425 if (count == 0) empty++;
2426 if (count > longest) longest = count;
2427 total += count;
2428 }
2429 tty->print_cr("AdapterHandlerTable: empty %d longest %d total %d average %f",
2430 empty, longest, total, total / (double)nonempty);
2431 tty->print_cr("AdapterHandlerTable: lookups %d buckets %d equals %d hits %d compact %d",
2432 _lookups, _buckets, _equals, _hits, _compact);
2433 }
2434 #endif
2435 };
2436
2437
2438 #ifndef PRODUCT
2439
2440 int AdapterHandlerTable::_lookups;
2441 int AdapterHandlerTable::_buckets;
2442 int AdapterHandlerTable::_equals;
2443 int AdapterHandlerTable::_hits;
2444 int AdapterHandlerTable::_compact;
2445
2446 #endif
2447
2448 class AdapterHandlerTableIterator : public StackObj {
2449 private:
2450 AdapterHandlerTable* _table;
2451 int _index;
2452 AdapterHandlerEntry* _current;
2453
2454 void scan() {
2455 while (_index < _table->table_size()) {
2456 AdapterHandlerEntry* a = _table->bucket(_index);
2457 _index++;
2458 if (a != NULL) {
2459 _current = a;
2460 return;
2461 }
2462 }
2463 }
2464
2465 public:
2466 AdapterHandlerTableIterator(AdapterHandlerTable* table): _table(table), _index(0), _current(NULL) {
2467 scan();
2468 }
2469 bool has_next() {
2470 return _current != NULL;
2471 }
2472 AdapterHandlerEntry* next() {
2473 if (_current != NULL) {
2474 AdapterHandlerEntry* result = _current;
2475 _current = _current->next();
2476 if (_current == NULL) scan();
2477 return result;
2478 } else {
2479 return NULL;
2480 }
2481 }
2482 };
2483
2484
2485 // ---------------------------------------------------------------------------
2486 // Implementation of AdapterHandlerLibrary
2487 AdapterHandlerTable* AdapterHandlerLibrary::_adapters = NULL;
2488 AdapterHandlerEntry* AdapterHandlerLibrary::_abstract_method_handler = NULL;
2489 const int AdapterHandlerLibrary_size = 16*K;
2490 BufferBlob* AdapterHandlerLibrary::_buffer = NULL;
2491
2492 BufferBlob* AdapterHandlerLibrary::buffer_blob() {
2493 // Should be called only when AdapterHandlerLibrary_lock is active.
2494 if (_buffer == NULL) // Initialize lazily
2495 _buffer = BufferBlob::create("adapters", AdapterHandlerLibrary_size);
2496 return _buffer;
2497 }
2498
2499 extern "C" void unexpected_adapter_call() {
2500 ShouldNotCallThis();
2501 }
2502
2503 void AdapterHandlerLibrary::initialize() {
2504 if (_adapters != NULL) return;
2505 _adapters = new AdapterHandlerTable();
2506
2507 if (!CodeCacheExtensions::skip_compiler_support()) {
2508 // Create a special handler for abstract methods. Abstract methods
2509 // are never compiled so an i2c entry is somewhat meaningless, but
2510 // throw AbstractMethodError just in case.
2511 // Pass wrong_method_abstract for the c2i transitions to return
2512 // AbstractMethodError for invalid invocations.
2513 address wrong_method_abstract = SharedRuntime::get_handle_wrong_method_abstract_stub();
2514 _abstract_method_handler = AdapterHandlerLibrary::new_entry(new AdapterFingerPrint(0, NULL),
2515 StubRoutines::throw_AbstractMethodError_entry(),
2516 wrong_method_abstract, wrong_method_abstract);
2517 } else {
2518 // Adapters are not supposed to be used.
2519 // Generate a special one to cause an error if used (and store this
2520 // singleton in place of the useless _abstract_method_error adapter).
2521 address entry = (address) &unexpected_adapter_call;
2522 _abstract_method_handler = AdapterHandlerLibrary::new_entry(new AdapterFingerPrint(0, NULL),
2523 entry,
2524 entry,
2525 entry);
2526
2527 }
2528 }
2529
2530 AdapterHandlerEntry* AdapterHandlerLibrary::new_entry(AdapterFingerPrint* fingerprint,
2531 address i2c_entry,
2532 address c2i_entry,
2533 address c2i_unverified_entry) {
2534 return _adapters->new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
2535 }
2536
2537 AdapterHandlerEntry* AdapterHandlerLibrary::get_adapter(const methodHandle& method) {
2538 AdapterHandlerEntry* entry = get_adapter0(method);
2539 if (method->is_shared()) {
2540 MutexLocker mu(AdapterHandlerLibrary_lock);
2541 if (method->adapter() == NULL) {
2542 method->update_adapter_trampoline(entry);
2543 }
2544 address trampoline = method->from_compiled_entry();
2545 if (*(int*)trampoline == 0) {
2546 CodeBuffer buffer(trampoline, (int)SharedRuntime::trampoline_size());
2547 MacroAssembler _masm(&buffer);
2548 SharedRuntime::generate_trampoline(&_masm, entry->get_c2i_entry());
2549
2550 if (PrintInterpreter) {
2551 Disassembler::decode(buffer.insts_begin(), buffer.insts_end());
2552 }
2553 }
2554 }
2555
2556 return entry;
2557 }
2558
2559 AdapterHandlerEntry* AdapterHandlerLibrary::get_adapter0(const methodHandle& method) {
2560 // Use customized signature handler. Need to lock around updates to
2561 // the AdapterHandlerTable (it is not safe for concurrent readers
2562 // and a single writer: this could be fixed if it becomes a
2563 // problem).
2564
2565 ResourceMark rm;
2566
2567 NOT_PRODUCT(int insts_size);
2568 AdapterBlob* new_adapter = NULL;
2569 AdapterHandlerEntry* entry = NULL;
2570 AdapterFingerPrint* fingerprint = NULL;
2571 {
2572 MutexLocker mu(AdapterHandlerLibrary_lock);
2573 // make sure data structure is initialized
2574 initialize();
2575
2576 // during dump time, always generate adapters, even if the
2577 // compiler has been turned off.
2578 if (!DumpSharedSpaces && CodeCacheExtensions::skip_compiler_support()) {
2579 // adapters are useless and should not be used, including the
2580 // abstract_method_handler. However, some callers check that
2581 // an adapter was installed.
2582 // Return the singleton adapter, stored into _abstract_method_handler
2583 // and modified to cause an error if we ever call it.
2584 return _abstract_method_handler;
2585 }
2586
2587 if (method->is_abstract()) {
2588 return _abstract_method_handler;
2589 }
2590
2591 // Fill in the signature array, for the calling-convention call.
2592 int total_args_passed = method->size_of_parameters(); // All args on stack
2593
2594 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
2595 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
2596 int i = 0;
2597 if (!method->is_static()) // Pass in receiver first
2598 sig_bt[i++] = T_OBJECT;
2599 for (SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
2600 sig_bt[i++] = ss.type(); // Collect remaining bits of signature
2601 if (ss.type() == T_LONG || ss.type() == T_DOUBLE)
2602 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots
2603 }
2604 assert(i == total_args_passed, "");
2605
2606 // Lookup method signature's fingerprint
2607 entry = _adapters->lookup(total_args_passed, sig_bt);
2608
2609 #ifdef ASSERT
2610 AdapterHandlerEntry* shared_entry = NULL;
2611 // Start adapter sharing verification only after the VM is booted.
2612 if (VerifyAdapterSharing && (entry != NULL)) {
2613 shared_entry = entry;
2614 entry = NULL;
2615 }
2616 #endif
2617
2618 if (entry != NULL) {
2619 return entry;
2620 }
2621
2622 // Get a description of the compiled java calling convention and the largest used (VMReg) stack slot usage
2623 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
2624
2625 // Make a C heap allocated version of the fingerprint to store in the adapter
2626 fingerprint = new AdapterFingerPrint(total_args_passed, sig_bt);
2627
2628 // StubRoutines::code2() is initialized after this function can be called. As a result,
2629 // VerifyAdapterCalls and VerifyAdapterSharing can fail if we re-use code that generated
2630 // prior to StubRoutines::code2() being set. Checks refer to checks generated in an I2C
2631 // stub that ensure that an I2C stub is called from an interpreter frame.
2632 bool contains_all_checks = StubRoutines::code2() != NULL;
2633
2634 // Create I2C & C2I handlers
2635 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
2636 if (buf != NULL) {
2637 CodeBuffer buffer(buf);
2638 short buffer_locs[20];
2639 buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
2640 sizeof(buffer_locs)/sizeof(relocInfo));
2641
2642 MacroAssembler _masm(&buffer);
2643 entry = SharedRuntime::generate_i2c2i_adapters(&_masm,
2644 total_args_passed,
2645 comp_args_on_stack,
2646 sig_bt,
2647 regs,
2648 fingerprint);
2649 #ifdef ASSERT
2650 if (VerifyAdapterSharing) {
2651 if (shared_entry != NULL) {
2652 assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size()), "code must match");
2653 // Release the one just created and return the original
2654 _adapters->free_entry(entry);
2655 return shared_entry;
2656 } else {
2657 entry->save_code(buf->code_begin(), buffer.insts_size());
2658 }
2659 }
2660 #endif
2661
2662 new_adapter = AdapterBlob::create(&buffer);
2663 NOT_PRODUCT(insts_size = buffer.insts_size());
2664 }
2665 if (new_adapter == NULL) {
2666 // CodeCache is full, disable compilation
2667 // Ought to log this but compile log is only per compile thread
2668 // and we're some non descript Java thread.
2669 return NULL; // Out of CodeCache space
2670 }
2671 entry->relocate(new_adapter->content_begin());
2672 #ifndef PRODUCT
2673 // debugging suppport
2674 if (PrintAdapterHandlers || PrintStubCode) {
2675 ttyLocker ttyl;
2676 entry->print_adapter_on(tty);
2677 tty->print_cr("i2c argument handler #%d for: %s %s %s (%d bytes generated)",
2678 _adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"),
2679 method->signature()->as_C_string(), fingerprint->as_string(), insts_size);
2680 tty->print_cr("c2i argument handler starts at %p", entry->get_c2i_entry());
2681 if (Verbose || PrintStubCode) {
2682 address first_pc = entry->base_address();
2683 if (first_pc != NULL) {
2684 Disassembler::decode(first_pc, first_pc + insts_size);
2685 tty->cr();
2686 }
2687 }
2688 }
2689 #endif
2690 // Add the entry only if the entry contains all required checks (see sharedRuntime_xxx.cpp)
2691 // The checks are inserted only if -XX:+VerifyAdapterCalls is specified.
2692 if (contains_all_checks || !VerifyAdapterCalls) {
2693 _adapters->add(entry);
2694 }
2695 }
2696 // Outside of the lock
2697 if (new_adapter != NULL) {
2698 char blob_id[256];
2699 jio_snprintf(blob_id,
2700 sizeof(blob_id),
2701 "%s(%s)@" PTR_FORMAT,
2702 new_adapter->name(),
2703 fingerprint->as_string(),
2704 new_adapter->content_begin());
2705 Forte::register_stub(blob_id, new_adapter->content_begin(), new_adapter->content_end());
2706
2707 if (JvmtiExport::should_post_dynamic_code_generated()) {
2708 JvmtiExport::post_dynamic_code_generated(blob_id, new_adapter->content_begin(), new_adapter->content_end());
2709 }
2710 }
2711 return entry;
2712 }
2713
2714 address AdapterHandlerEntry::base_address() {
2715 address base = _i2c_entry;
2716 if (base == NULL) base = _c2i_entry;
2717 assert(base <= _c2i_entry || _c2i_entry == NULL, "");
2718 assert(base <= _c2i_unverified_entry || _c2i_unverified_entry == NULL, "");
2719 return base;
2720 }
2721
2722 void AdapterHandlerEntry::relocate(address new_base) {
2723 address old_base = base_address();
2724 assert(old_base != NULL, "");
2725 ptrdiff_t delta = new_base - old_base;
2726 if (_i2c_entry != NULL)
2727 _i2c_entry += delta;
2728 if (_c2i_entry != NULL)
2729 _c2i_entry += delta;
2730 if (_c2i_unverified_entry != NULL)
2731 _c2i_unverified_entry += delta;
2732 assert(base_address() == new_base, "");
2733 }
2734
2735
2736 void AdapterHandlerEntry::deallocate() {
2737 delete _fingerprint;
2738 #ifdef ASSERT
2739 if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code);
2740 #endif
2741 }
2742
2743
2744 #ifdef ASSERT
2745 // Capture the code before relocation so that it can be compared
2746 // against other versions. If the code is captured after relocation
2747 // then relative instructions won't be equivalent.
2748 void AdapterHandlerEntry::save_code(unsigned char* buffer, int length) {
2749 _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode);
2750 _saved_code_length = length;
2751 memcpy(_saved_code, buffer, length);
2752 }
2753
2754
2755 bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length) {
2756 if (length != _saved_code_length) {
2757 return false;
2758 }
2759
2760 return (memcmp(buffer, _saved_code, length) == 0) ? true : false;
2761 }
2762 #endif
2763
2764
2765 /**
2766 * Create a native wrapper for this native method. The wrapper converts the
2767 * Java-compiled calling convention to the native convention, handles
2768 * arguments, and transitions to native. On return from the native we transition
2769 * back to java blocking if a safepoint is in progress.
2770 */
2771 void AdapterHandlerLibrary::create_native_wrapper(const methodHandle& method) {
2772 ResourceMark rm;
2773 nmethod* nm = NULL;
2774
2775 assert(method->is_native(), "must be native");
2776 assert(method->is_method_handle_intrinsic() ||
2777 method->has_native_function(), "must have something valid to call!");
2778
2779 {
2780 // Perform the work while holding the lock, but perform any printing outside the lock
2781 MutexLocker mu(AdapterHandlerLibrary_lock);
2782 // See if somebody beat us to it
2783 if (method->code() != NULL) {
2784 return;
2785 }
2786
2787 const int compile_id = CompileBroker::assign_compile_id(method, CompileBroker::standard_entry_bci);
2788 assert(compile_id > 0, "Must generate native wrapper");
2789
2790
2791 ResourceMark rm;
2792 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
2793 if (buf != NULL) {
2794 CodeBuffer buffer(buf);
2795 double locs_buf[20];
2796 buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
2797 MacroAssembler _masm(&buffer);
2798
2799 // Fill in the signature array, for the calling-convention call.
2800 const int total_args_passed = method->size_of_parameters();
2801
2802 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
2803 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
2804 int i=0;
2805 if (!method->is_static()) // Pass in receiver first
2806 sig_bt[i++] = T_OBJECT;
2807 SignatureStream ss(method->signature());
2808 for (; !ss.at_return_type(); ss.next()) {
2809 sig_bt[i++] = ss.type(); // Collect remaining bits of signature
2810 if (ss.type() == T_LONG || ss.type() == T_DOUBLE)
2811 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots
2812 }
2813 assert(i == total_args_passed, "");
2814 BasicType ret_type = ss.type();
2815
2816 // Now get the compiled-Java layout as input (or output) arguments.
2817 // NOTE: Stubs for compiled entry points of method handle intrinsics
2818 // are just trampolines so the argument registers must be outgoing ones.
2819 const bool is_outgoing = method->is_method_handle_intrinsic();
2820 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing);
2821
2822 // Generate the compiled-to-native wrapper code
2823 nm = SharedRuntime::generate_native_wrapper(&_masm, method, compile_id, sig_bt, regs, ret_type);
2824
2825 if (nm != NULL) {
2826 method->set_code(method, nm);
2827
2828 DirectiveSet* directive = DirectivesStack::getDefaultDirective(CompileBroker::compiler(CompLevel_simple));
2829 if (directive->PrintAssemblyOption) {
2830 nm->print_code();
2831 }
2832 DirectivesStack::release(directive);
2833 }
2834 }
2835 } // Unlock AdapterHandlerLibrary_lock
2836
2837
2838 // Install the generated code.
2839 if (nm != NULL) {
2840 if (PrintCompilation) {
2841 ttyLocker ttyl;
2842 CompileTask::print(tty, nm, method->is_static() ? "(static)" : "");
2843 }
2844 nm->post_compiled_method_load_event();
2845 }
2846 }
2847
2848 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::block_for_jni_critical(JavaThread* thread))
2849 assert(thread == JavaThread::current(), "must be");
2850 // The code is about to enter a JNI lazy critical native method and
2851 // _needs_gc is true, so if this thread is already in a critical
2852 // section then just return, otherwise this thread should block
2853 // until needs_gc has been cleared.
2854 if (thread->in_critical()) {
2855 return;
2856 }
2857 // Lock and unlock a critical section to give the system a chance to block
2858 GCLocker::lock_critical(thread);
2859 GCLocker::unlock_critical(thread);
2860 JRT_END
2861
2862 // -------------------------------------------------------------------------
2863 // Java-Java calling convention
2864 // (what you use when Java calls Java)
2865
2866 //------------------------------name_for_receiver----------------------------------
2867 // For a given signature, return the VMReg for parameter 0.
2868 VMReg SharedRuntime::name_for_receiver() {
2869 VMRegPair regs;
2870 BasicType sig_bt = T_OBJECT;
2871 (void) java_calling_convention(&sig_bt, ®s, 1, true);
2872 // Return argument 0 register. In the LP64 build pointers
2873 // take 2 registers, but the VM wants only the 'main' name.
2874 return regs.first();
2875 }
2876
2877 VMRegPair *SharedRuntime::find_callee_arguments(Symbol* sig, bool has_receiver, bool has_appendix, int* arg_size) {
2878 // This method is returning a data structure allocating as a
2879 // ResourceObject, so do not put any ResourceMarks in here.
2880 char *s = sig->as_C_string();
2881 int len = (int)strlen(s);
2882 s++; len--; // Skip opening paren
2883 char *t = s+len;
2884 while (*(--t) != ')'); // Find close paren
2885
2886 BasicType *sig_bt = NEW_RESOURCE_ARRAY(BasicType, 256);
2887 VMRegPair *regs = NEW_RESOURCE_ARRAY(VMRegPair, 256);
2888 int cnt = 0;
2889 if (has_receiver) {
2890 sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature
2891 }
2892
2893 while (s < t) {
2894 switch (*s++) { // Switch on signature character
2895 case 'B': sig_bt[cnt++] = T_BYTE; break;
2896 case 'C': sig_bt[cnt++] = T_CHAR; break;
2897 case 'D': sig_bt[cnt++] = T_DOUBLE; sig_bt[cnt++] = T_VOID; break;
2898 case 'F': sig_bt[cnt++] = T_FLOAT; break;
2899 case 'I': sig_bt[cnt++] = T_INT; break;
2900 case 'J': sig_bt[cnt++] = T_LONG; sig_bt[cnt++] = T_VOID; break;
2901 case 'S': sig_bt[cnt++] = T_SHORT; break;
2902 case 'Z': sig_bt[cnt++] = T_BOOLEAN; break;
2903 case 'V': sig_bt[cnt++] = T_VOID; break;
2904 case 'L': // Oop
2905 while (*s++ != ';'); // Skip signature
2906 sig_bt[cnt++] = T_OBJECT;
2907 break;
2908 case '[': { // Array
2909 do { // Skip optional size
2910 while (*s >= '0' && *s <= '9') s++;
2911 } while (*s++ == '['); // Nested arrays?
2912 // Skip element type
2913 if (s[-1] == 'L')
2914 while (*s++ != ';'); // Skip signature
2915 sig_bt[cnt++] = T_ARRAY;
2916 break;
2917 }
2918 default : ShouldNotReachHere();
2919 }
2920 }
2921
2922 if (has_appendix) {
2923 sig_bt[cnt++] = T_OBJECT;
2924 }
2925
2926 assert(cnt < 256, "grow table size");
2927
2928 int comp_args_on_stack;
2929 comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true);
2930
2931 // the calling convention doesn't count out_preserve_stack_slots so
2932 // we must add that in to get "true" stack offsets.
2933
2934 if (comp_args_on_stack) {
2935 for (int i = 0; i < cnt; i++) {
2936 VMReg reg1 = regs[i].first();
2937 if (reg1->is_stack()) {
2938 // Yuck
2939 reg1 = reg1->bias(out_preserve_stack_slots());
2940 }
2941 VMReg reg2 = regs[i].second();
2942 if (reg2->is_stack()) {
2943 // Yuck
2944 reg2 = reg2->bias(out_preserve_stack_slots());
2945 }
2946 regs[i].set_pair(reg2, reg1);
2947 }
2948 }
2949
2950 // results
2951 *arg_size = cnt;
2952 return regs;
2953 }
2954
2955 // OSR Migration Code
2956 //
2957 // This code is used convert interpreter frames into compiled frames. It is
2958 // called from very start of a compiled OSR nmethod. A temp array is
2959 // allocated to hold the interesting bits of the interpreter frame. All
2960 // active locks are inflated to allow them to move. The displaced headers and
2961 // active interpreter locals are copied into the temp buffer. Then we return
2962 // back to the compiled code. The compiled code then pops the current
2963 // interpreter frame off the stack and pushes a new compiled frame. Then it
2964 // copies the interpreter locals and displaced headers where it wants.
2965 // Finally it calls back to free the temp buffer.
2966 //
2967 // All of this is done NOT at any Safepoint, nor is any safepoint or GC allowed.
2968
2969 JRT_LEAF(intptr_t*, SharedRuntime::OSR_migration_begin( JavaThread *thread) )
2970
2971 //
2972 // This code is dependent on the memory layout of the interpreter local
2973 // array and the monitors. On all of our platforms the layout is identical
2974 // so this code is shared. If some platform lays the their arrays out
2975 // differently then this code could move to platform specific code or
2976 // the code here could be modified to copy items one at a time using
2977 // frame accessor methods and be platform independent.
2978
2979 frame fr = thread->last_frame();
2980 assert(fr.is_interpreted_frame(), "");
2981 assert(fr.interpreter_frame_expression_stack_size()==0, "only handle empty stacks");
2982
2983 // Figure out how many monitors are active.
2984 int active_monitor_count = 0;
2985 for (BasicObjectLock *kptr = fr.interpreter_frame_monitor_end();
2986 kptr < fr.interpreter_frame_monitor_begin();
2987 kptr = fr.next_monitor_in_interpreter_frame(kptr) ) {
2988 if (kptr->obj() != NULL) active_monitor_count++;
2989 }
2990
2991 // QQQ we could place number of active monitors in the array so that compiled code
2992 // could double check it.
2993
2994 Method* moop = fr.interpreter_frame_method();
2995 int max_locals = moop->max_locals();
2996 // Allocate temp buffer, 1 word per local & 2 per active monitor
2997 int buf_size_words = max_locals + active_monitor_count * BasicObjectLock::size();
2998 intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words, mtCode);
2999
3000 // Copy the locals. Order is preserved so that loading of longs works.
3001 // Since there's no GC I can copy the oops blindly.
3002 assert(sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
3003 Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
3004 (HeapWord*)&buf[0],
3005 max_locals);
3006
3007 // Inflate locks. Copy the displaced headers. Be careful, there can be holes.
3008 int i = max_locals;
3009 for (BasicObjectLock *kptr2 = fr.interpreter_frame_monitor_end();
3010 kptr2 < fr.interpreter_frame_monitor_begin();
3011 kptr2 = fr.next_monitor_in_interpreter_frame(kptr2) ) {
3012 if (kptr2->obj() != NULL) { // Avoid 'holes' in the monitor array
3013 BasicLock *lock = kptr2->lock();
3014 // Inflate so the displaced header becomes position-independent
3015 if (lock->displaced_header()->is_unlocked())
3016 ObjectSynchronizer::inflate_helper(kptr2->obj());
3017 // Now the displaced header is free to move
3018 buf[i++] = (intptr_t)lock->displaced_header();
3019 buf[i++] = cast_from_oop<intptr_t>(kptr2->obj());
3020 }
3021 }
3022 assert(i - max_locals == active_monitor_count*2, "found the expected number of monitors");
3023
3024 return buf;
3025 JRT_END
3026
3027 JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) )
3028 FREE_C_HEAP_ARRAY(intptr_t, buf);
3029 JRT_END
3030
3031 bool AdapterHandlerLibrary::contains(const CodeBlob* b) {
3032 AdapterHandlerTableIterator iter(_adapters);
3033 while (iter.has_next()) {
3034 AdapterHandlerEntry* a = iter.next();
3035 if (b == CodeCache::find_blob(a->get_i2c_entry())) return true;
3036 }
3037 return false;
3038 }
3039
3040 void AdapterHandlerLibrary::print_handler_on(outputStream* st, const CodeBlob* b) {
3041 AdapterHandlerTableIterator iter(_adapters);
3042 while (iter.has_next()) {
3043 AdapterHandlerEntry* a = iter.next();
3044 if (b == CodeCache::find_blob(a->get_i2c_entry())) {
3045 st->print("Adapter for signature: ");
3046 a->print_adapter_on(tty);
3047 return;
3048 }
3049 }
3050 assert(false, "Should have found handler");
3051 }
3052
3053 void AdapterHandlerEntry::print_adapter_on(outputStream* st) const {
3054 st->print_cr("AHE@" INTPTR_FORMAT ": %s i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT,
3055 p2i(this), fingerprint()->as_string(),
3056 p2i(get_i2c_entry()), p2i(get_c2i_entry()), p2i(get_c2i_unverified_entry()));
3057
3058 }
3059
3060 #if INCLUDE_CDS
3061
3062 void CDSAdapterHandlerEntry::init() {
3063 assert(DumpSharedSpaces, "used during dump time only");
3064 _c2i_entry_trampoline = (address)MetaspaceShared::misc_data_space_alloc(SharedRuntime::trampoline_size());
3065 _adapter_trampoline = (AdapterHandlerEntry**)MetaspaceShared::misc_data_space_alloc(sizeof(AdapterHandlerEntry*));
3066 };
3067
3068 #endif // INCLUDE_CDS
3069
3070
3071 #ifndef PRODUCT
3072
3073 void AdapterHandlerLibrary::print_statistics() {
3074 _adapters->print_statistics();
3075 }
3076
3077 #endif /* PRODUCT */
3078
3079 JRT_LEAF(void, SharedRuntime::enable_stack_reserved_zone(JavaThread* thread))
3080 assert(thread->is_Java_thread(), "Only Java threads have a stack reserved zone");
3081 thread->enable_stack_reserved_zone();
3082 thread->set_reserved_stack_activation(thread->stack_base());
3083 JRT_END
3084
3085 frame SharedRuntime::look_for_reserved_stack_annotated_method(JavaThread* thread, frame fr) {
3086 frame activation;
3087 CompiledMethod* nm = NULL;
3088 int count = 1;
3089
3090 assert(fr.is_java_frame(), "Must start on Java frame");
3091
3092 while (true) {
3093 Method* method = NULL;
3094 if (fr.is_interpreted_frame()) {
3095 method = fr.interpreter_frame_method();
3096 } else {
3097 CodeBlob* cb = fr.cb();
3098 if (cb != NULL && cb->is_compiled()) {
3099 nm = cb->as_compiled_method();
3100 method = nm->method();
3101 }
3102 }
3103 if ((method != NULL) && method->has_reserved_stack_access()) {
3104 ResourceMark rm(thread);
3105 activation = fr;
3106 warning("Potentially dangerous stack overflow in "
3107 "ReservedStackAccess annotated method %s [%d]",
3108 method->name_and_sig_as_C_string(), count++);
3109 EventReservedStackActivation event;
3110 if (event.should_commit()) {
3111 event.set_method(method);
3112 event.commit();
3113 }
3114 }
3115 if (fr.is_first_java_frame()) {
3116 break;
3117 } else {
3118 fr = fr.java_sender();
3119 }
3120 }
3121 return activation;
3122 }
3123