1 /*
2 * Copyright (c) 1998, 2011, 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/systemDictionary.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "code/compiledIC.hpp"
29 #include "code/icBuffer.hpp"
30 #include "code/nmethod.hpp"
31 #include "code/pcDesc.hpp"
32 #include "code/scopeDesc.hpp"
33 #include "code/vtableStubs.hpp"
34 #include "compiler/compileBroker.hpp"
35 #include "compiler/compilerOracle.hpp"
36 #include "compiler/oopMap.hpp"
37 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
38 #include "gc_implementation/g1/heapRegion.hpp"
39 #include "gc_interface/collectedHeap.hpp"
40 #include "interpreter/bytecode.hpp"
41 #include "interpreter/interpreter.hpp"
42 #include "interpreter/linkResolver.hpp"
43 #include "memory/barrierSet.hpp"
44 #include "memory/gcLocker.inline.hpp"
45 #include "memory/oopFactory.hpp"
46 #include "oops/objArrayKlass.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "opto/addnode.hpp"
49 #include "opto/callnode.hpp"
50 #include "opto/cfgnode.hpp"
51 #include "opto/connode.hpp"
52 #include "opto/graphKit.hpp"
53 #include "opto/machnode.hpp"
54 #include "opto/matcher.hpp"
55 #include "opto/memnode.hpp"
56 #include "opto/mulnode.hpp"
57 #include "opto/runtime.hpp"
58 #include "opto/subnode.hpp"
59 #include "runtime/fprofiler.hpp"
60 #include "runtime/handles.inline.hpp"
61 #include "runtime/interfaceSupport.hpp"
62 #include "runtime/javaCalls.hpp"
63 #include "runtime/sharedRuntime.hpp"
64 #include "runtime/signature.hpp"
65 #include "runtime/threadCritical.hpp"
66 #include "runtime/vframe.hpp"
67 #include "runtime/vframeArray.hpp"
68 #include "runtime/vframe_hp.hpp"
69 #include "utilities/copy.hpp"
70 #include "utilities/preserveException.hpp"
71 #ifdef TARGET_ARCH_MODEL_x86_32
72 # include "adfiles/ad_x86_32.hpp"
73 #endif
74 #ifdef TARGET_ARCH_MODEL_x86_64
75 # include "adfiles/ad_x86_64.hpp"
76 #endif
77 #ifdef TARGET_ARCH_MODEL_sparc
78 # include "adfiles/ad_sparc.hpp"
79 #endif
80 #ifdef TARGET_ARCH_MODEL_zero
81 # include "adfiles/ad_zero.hpp"
82 #endif
83 #ifdef TARGET_ARCH_MODEL_arm
84 # include "adfiles/ad_arm.hpp"
85 #endif
86 #ifdef TARGET_ARCH_MODEL_ppc
87 # include "adfiles/ad_ppc.hpp"
88 #endif
89
90
91 // For debugging purposes:
92 // To force FullGCALot inside a runtime function, add the following two lines
93 //
94 // Universe::release_fullgc_alot_dummy();
95 // MarkSweep::invoke(0, "Debugging");
96 //
97 // At command line specify the parameters: -XX:+FullGCALot -XX:FullGCALotStart=100000000
98
99
100
101
102 // Compiled code entry points
103 address OptoRuntime::_new_instance_Java = NULL;
104 address OptoRuntime::_new_array_Java = NULL;
105 address OptoRuntime::_multianewarray2_Java = NULL;
106 address OptoRuntime::_multianewarray3_Java = NULL;
107 address OptoRuntime::_multianewarray4_Java = NULL;
108 address OptoRuntime::_multianewarray5_Java = NULL;
109 address OptoRuntime::_multianewarrayN_Java = NULL;
110 address OptoRuntime::_g1_wb_pre_Java = NULL;
111 address OptoRuntime::_g1_wb_post_Java = NULL;
112 address OptoRuntime::_vtable_must_compile_Java = NULL;
113 address OptoRuntime::_complete_monitor_locking_Java = NULL;
114 address OptoRuntime::_rethrow_Java = NULL;
115
116 address OptoRuntime::_slow_arraycopy_Java = NULL;
117 address OptoRuntime::_register_finalizer_Java = NULL;
118
119 # ifdef ENABLE_ZAP_DEAD_LOCALS
120 address OptoRuntime::_zap_dead_Java_locals_Java = NULL;
121 address OptoRuntime::_zap_dead_native_locals_Java = NULL;
122 # endif
123
124 ExceptionBlob* OptoRuntime::_exception_blob;
125
126 // This should be called in an assertion at the start of OptoRuntime routines
127 // which are entered from compiled code (all of them)
128 #ifndef PRODUCT
129 static bool check_compiled_frame(JavaThread* thread) {
130 assert(thread->last_frame().is_runtime_frame(), "cannot call runtime directly from compiled code");
131 #ifdef ASSERT
132 RegisterMap map(thread, false);
133 frame caller = thread->last_frame().sender(&map);
134 assert(caller.is_compiled_frame(), "not being called from compiled like code");
135 #endif /* ASSERT */
136 return true;
137 }
138 #endif
139
140
141 #define gen(env, var, type_func_gen, c_func, fancy_jump, pass_tls, save_arg_regs, return_pc) \
142 var = generate_stub(env, type_func_gen, CAST_FROM_FN_PTR(address, c_func), #var, fancy_jump, pass_tls, save_arg_regs, return_pc)
143
144 void OptoRuntime::generate(ciEnv* env) {
145
146 generate_exception_blob();
147
148 // Note: tls: Means fetching the return oop out of the thread-local storage
149 //
150 // variable/name type-function-gen , runtime method ,fncy_jp, tls,save_args,retpc
151 // -------------------------------------------------------------------------------------------------------------------------------
152 gen(env, _new_instance_Java , new_instance_Type , new_instance_C , 0 , true , false, false);
153 gen(env, _new_array_Java , new_array_Type , new_array_C , 0 , true , false, false);
154 gen(env, _multianewarray2_Java , multianewarray2_Type , multianewarray2_C , 0 , true , false, false);
155 gen(env, _multianewarray3_Java , multianewarray3_Type , multianewarray3_C , 0 , true , false, false);
156 gen(env, _multianewarray4_Java , multianewarray4_Type , multianewarray4_C , 0 , true , false, false);
157 gen(env, _multianewarray5_Java , multianewarray5_Type , multianewarray5_C , 0 , true , false, false);
158 gen(env, _multianewarrayN_Java , multianewarrayN_Type , multianewarrayN_C , 0 , true , false, false);
159 gen(env, _g1_wb_pre_Java , g1_wb_pre_Type , SharedRuntime::g1_wb_pre , 0 , false, false, false);
160 gen(env, _g1_wb_post_Java , g1_wb_post_Type , SharedRuntime::g1_wb_post , 0 , false, false, false);
161 gen(env, _complete_monitor_locking_Java , complete_monitor_enter_Type , SharedRuntime::complete_monitor_locking_C , 0 , false, false, false);
162 gen(env, _rethrow_Java , rethrow_Type , rethrow_C , 2 , true , false, true );
163
164 gen(env, _slow_arraycopy_Java , slow_arraycopy_Type , SharedRuntime::slow_arraycopy_C , 0 , false, false, false);
165 gen(env, _register_finalizer_Java , register_finalizer_Type , register_finalizer , 0 , false, false, false);
166
167 # ifdef ENABLE_ZAP_DEAD_LOCALS
168 gen(env, _zap_dead_Java_locals_Java , zap_dead_locals_Type , zap_dead_Java_locals_C , 0 , false, true , false );
169 gen(env, _zap_dead_native_locals_Java , zap_dead_locals_Type , zap_dead_native_locals_C , 0 , false, true , false );
170 # endif
171
172 }
173
174 #undef gen
175
176
177 // Helper method to do generation of RunTimeStub's
178 address OptoRuntime::generate_stub( ciEnv* env,
179 TypeFunc_generator gen, address C_function,
180 const char *name, int is_fancy_jump,
181 bool pass_tls,
182 bool save_argument_registers,
183 bool return_pc ) {
184 ResourceMark rm;
185 Compile C( env, gen, C_function, name, is_fancy_jump, pass_tls, save_argument_registers, return_pc );
186 return C.stub_entry_point();
187 }
188
189 const char* OptoRuntime::stub_name(address entry) {
190 #ifndef PRODUCT
191 CodeBlob* cb = CodeCache::find_blob(entry);
192 RuntimeStub* rs =(RuntimeStub *)cb;
193 assert(rs != NULL && rs->is_runtime_stub(), "not a runtime stub");
194 return rs->name();
195 #else
196 // Fast implementation for product mode (maybe it should be inlined too)
197 return "runtime stub";
198 #endif
199 }
200
201
202 //=============================================================================
203 // Opto compiler runtime routines
204 //=============================================================================
205
206
207 //=============================allocation======================================
208 // We failed the fast-path allocation. Now we need to do a scavenge or GC
209 // and try allocation again.
210
211 void OptoRuntime::new_store_pre_barrier(JavaThread* thread) {
212 // After any safepoint, just before going back to compiled code,
213 // we inform the GC that we will be doing initializing writes to
214 // this object in the future without emitting card-marks, so
215 // GC may take any compensating steps.
216 // NOTE: Keep this code consistent with GraphKit::store_barrier.
217
218 oop new_obj = thread->vm_result();
219 if (new_obj == NULL) return;
220
221 assert(Universe::heap()->can_elide_tlab_store_barriers(),
222 "compiler must check this first");
223 // GC may decide to give back a safer copy of new_obj.
224 new_obj = Universe::heap()->new_store_pre_barrier(thread, new_obj);
225 thread->set_vm_result(new_obj);
226 }
227
228 // object allocation
229 JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(klassOopDesc* klass, JavaThread* thread))
230 JRT_BLOCK;
231 #ifndef PRODUCT
232 SharedRuntime::_new_instance_ctr++; // new instance requires GC
233 #endif
234 assert(check_compiled_frame(thread), "incorrect caller");
235
236 // These checks are cheap to make and support reflective allocation.
237 int lh = Klass::cast(klass)->layout_helper();
238 if (Klass::layout_helper_needs_slow_path(lh)
239 || !instanceKlass::cast(klass)->is_initialized()) {
240 KlassHandle kh(THREAD, klass);
241 kh->check_valid_for_instantiation(false, THREAD);
242 if (!HAS_PENDING_EXCEPTION) {
243 instanceKlass::cast(kh())->initialize(THREAD);
244 }
245 if (!HAS_PENDING_EXCEPTION) {
246 klass = kh();
247 } else {
248 klass = NULL;
249 }
250 }
251
252 if (klass != NULL) {
253 // Scavenge and allocate an instance.
254 oop result = instanceKlass::cast(klass)->allocate_instance(THREAD);
255 thread->set_vm_result(result);
256
257 // Pass oops back through thread local storage. Our apparent type to Java
258 // is that we return an oop, but we can block on exit from this routine and
259 // a GC can trash the oop in C's return register. The generated stub will
260 // fetch the oop from TLS after any possible GC.
261 }
262
263 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
264 JRT_BLOCK_END;
265
266 if (GraphKit::use_ReduceInitialCardMarks()) {
267 // inform GC that we won't do card marks for initializing writes.
268 new_store_pre_barrier(thread);
269 }
270 JRT_END
271
272
273 // array allocation
274 JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_C(klassOopDesc* array_type, int len, JavaThread *thread))
275 JRT_BLOCK;
276 #ifndef PRODUCT
277 SharedRuntime::_new_array_ctr++; // new array requires GC
278 #endif
279 assert(check_compiled_frame(thread), "incorrect caller");
280
281 // Scavenge and allocate an instance.
282 oop result;
283
284 if (Klass::cast(array_type)->oop_is_typeArray()) {
285 // The oopFactory likes to work with the element type.
286 // (We could bypass the oopFactory, since it doesn't add much value.)
287 BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
288 result = oopFactory::new_typeArray(elem_type, len, THREAD);
289 } else {
290 // Although the oopFactory likes to work with the elem_type,
291 // the compiler prefers the array_type, since it must already have
292 // that latter value in hand for the fast path.
293 klassOopDesc* elem_type = objArrayKlass::cast(array_type)->element_klass();
294 result = oopFactory::new_objArray(elem_type, len, THREAD);
295 }
296
297 // Pass oops back through thread local storage. Our apparent type to Java
298 // is that we return an oop, but we can block on exit from this routine and
299 // a GC can trash the oop in C's return register. The generated stub will
300 // fetch the oop from TLS after any possible GC.
301 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
302 thread->set_vm_result(result);
303 JRT_BLOCK_END;
304
305 if (GraphKit::use_ReduceInitialCardMarks()) {
306 // inform GC that we won't do card marks for initializing writes.
307 new_store_pre_barrier(thread);
308 }
309 JRT_END
310
311 // Note: multianewarray for one dimension is handled inline by GraphKit::new_array.
312
313 // multianewarray for 2 dimensions
314 JRT_ENTRY(void, OptoRuntime::multianewarray2_C(klassOopDesc* elem_type, int len1, int len2, JavaThread *thread))
315 #ifndef PRODUCT
316 SharedRuntime::_multi2_ctr++; // multianewarray for 1 dimension
317 #endif
318 assert(check_compiled_frame(thread), "incorrect caller");
319 assert(oop(elem_type)->is_klass(), "not a class");
320 jint dims[2];
321 dims[0] = len1;
322 dims[1] = len2;
323 oop obj = arrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
324 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
325 thread->set_vm_result(obj);
326 JRT_END
327
328 // multianewarray for 3 dimensions
329 JRT_ENTRY(void, OptoRuntime::multianewarray3_C(klassOopDesc* elem_type, int len1, int len2, int len3, JavaThread *thread))
330 #ifndef PRODUCT
331 SharedRuntime::_multi3_ctr++; // multianewarray for 1 dimension
332 #endif
333 assert(check_compiled_frame(thread), "incorrect caller");
334 assert(oop(elem_type)->is_klass(), "not a class");
335 jint dims[3];
336 dims[0] = len1;
337 dims[1] = len2;
338 dims[2] = len3;
339 oop obj = arrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);
340 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
341 thread->set_vm_result(obj);
342 JRT_END
343
344 // multianewarray for 4 dimensions
345 JRT_ENTRY(void, OptoRuntime::multianewarray4_C(klassOopDesc* elem_type, int len1, int len2, int len3, int len4, JavaThread *thread))
346 #ifndef PRODUCT
347 SharedRuntime::_multi4_ctr++; // multianewarray for 1 dimension
348 #endif
349 assert(check_compiled_frame(thread), "incorrect caller");
350 assert(oop(elem_type)->is_klass(), "not a class");
351 jint dims[4];
352 dims[0] = len1;
353 dims[1] = len2;
354 dims[2] = len3;
355 dims[3] = len4;
356 oop obj = arrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);
357 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
358 thread->set_vm_result(obj);
359 JRT_END
360
361 // multianewarray for 5 dimensions
362 JRT_ENTRY(void, OptoRuntime::multianewarray5_C(klassOopDesc* elem_type, int len1, int len2, int len3, int len4, int len5, JavaThread *thread))
363 #ifndef PRODUCT
364 SharedRuntime::_multi5_ctr++; // multianewarray for 1 dimension
365 #endif
366 assert(check_compiled_frame(thread), "incorrect caller");
367 assert(oop(elem_type)->is_klass(), "not a class");
368 jint dims[5];
369 dims[0] = len1;
370 dims[1] = len2;
371 dims[2] = len3;
372 dims[3] = len4;
373 dims[4] = len5;
374 oop obj = arrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);
375 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
376 thread->set_vm_result(obj);
377 JRT_END
378
379 JRT_ENTRY(void, OptoRuntime::multianewarrayN_C(klassOopDesc* elem_type, arrayOopDesc* dims, JavaThread *thread))
380 assert(check_compiled_frame(thread), "incorrect caller");
381 assert(oop(elem_type)->is_klass(), "not a class");
382 assert(oop(dims)->is_typeArray(), "not an array");
383
384 ResourceMark rm;
385 jint len = dims->length();
386 assert(len > 0, "Dimensions array should contain data");
387 jint *j_dims = typeArrayOop(dims)->int_at_addr(0);
388 jint *c_dims = NEW_RESOURCE_ARRAY(jint, len);
389 Copy::conjoint_jints_atomic(j_dims, c_dims, len);
390
391 oop obj = arrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
392 deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
393 thread->set_vm_result(obj);
394 JRT_END
395
396
397 const TypeFunc *OptoRuntime::new_instance_Type() {
398 // create input type (domain)
399 const Type **fields = TypeTuple::fields(1);
400 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
401 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
402
403 // create result type (range)
404 fields = TypeTuple::fields(1);
405 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
406
407 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
408
409 return TypeFunc::make(domain, range);
410 }
411
412
413 const TypeFunc *OptoRuntime::athrow_Type() {
414 // create input type (domain)
415 const Type **fields = TypeTuple::fields(1);
416 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
417 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
418
419 // create result type (range)
420 fields = TypeTuple::fields(0);
421
422 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
423
424 return TypeFunc::make(domain, range);
425 }
426
427
428 const TypeFunc *OptoRuntime::new_array_Type() {
429 // create input type (domain)
430 const Type **fields = TypeTuple::fields(2);
431 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
432 fields[TypeFunc::Parms+1] = TypeInt::INT; // array size
433 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
434
435 // create result type (range)
436 fields = TypeTuple::fields(1);
437 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
438
439 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
440
441 return TypeFunc::make(domain, range);
442 }
443
444 const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
445 // create input type (domain)
446 const int nargs = ndim + 1;
447 const Type **fields = TypeTuple::fields(nargs);
448 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
449 for( int i = 1; i < nargs; i++ )
450 fields[TypeFunc::Parms + i] = TypeInt::INT; // array size
451 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+nargs, fields);
452
453 // create result type (range)
454 fields = TypeTuple::fields(1);
455 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
456 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
457
458 return TypeFunc::make(domain, range);
459 }
460
461 const TypeFunc *OptoRuntime::multianewarray2_Type() {
462 return multianewarray_Type(2);
463 }
464
465 const TypeFunc *OptoRuntime::multianewarray3_Type() {
466 return multianewarray_Type(3);
467 }
468
469 const TypeFunc *OptoRuntime::multianewarray4_Type() {
470 return multianewarray_Type(4);
471 }
472
473 const TypeFunc *OptoRuntime::multianewarray5_Type() {
474 return multianewarray_Type(5);
475 }
476
477 const TypeFunc *OptoRuntime::multianewarrayN_Type() {
478 // create input type (domain)
479 const Type **fields = TypeTuple::fields(2);
480 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
481 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // array of dim sizes
482 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
483
484 // create result type (range)
485 fields = TypeTuple::fields(1);
486 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
487 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
488
489 return TypeFunc::make(domain, range);
490 }
491
492 const TypeFunc *OptoRuntime::g1_wb_pre_Type() {
493 const Type **fields = TypeTuple::fields(2);
494 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value
495 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
496 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
497
498 // create result type (range)
499 fields = TypeTuple::fields(0);
500 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
501
502 return TypeFunc::make(domain, range);
503 }
504
505 const TypeFunc *OptoRuntime::g1_wb_post_Type() {
506
507 const Type **fields = TypeTuple::fields(2);
508 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Card addr
509 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
510 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
511
512 // create result type (range)
513 fields = TypeTuple::fields(0);
514 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
515
516 return TypeFunc::make(domain, range);
517 }
518
519 const TypeFunc *OptoRuntime::uncommon_trap_Type() {
520 // create input type (domain)
521 const Type **fields = TypeTuple::fields(1);
522 // Symbol* name of class to be loaded
523 fields[TypeFunc::Parms+0] = TypeInt::INT;
524 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
525
526 // create result type (range)
527 fields = TypeTuple::fields(0);
528 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
529
530 return TypeFunc::make(domain, range);
531 }
532
533 # ifdef ENABLE_ZAP_DEAD_LOCALS
534 // Type used for stub generation for zap_dead_locals.
535 // No inputs or outputs
536 const TypeFunc *OptoRuntime::zap_dead_locals_Type() {
537 // create input type (domain)
538 const Type **fields = TypeTuple::fields(0);
539 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms,fields);
540
541 // create result type (range)
542 fields = TypeTuple::fields(0);
543 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms,fields);
544
545 return TypeFunc::make(domain,range);
546 }
547 # endif
548
549
550 //-----------------------------------------------------------------------------
551 // Monitor Handling
552 const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {
553 // create input type (domain)
554 const Type **fields = TypeTuple::fields(2);
555 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
556 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
557 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
558
559 // create result type (range)
560 fields = TypeTuple::fields(0);
561
562 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
563
564 return TypeFunc::make(domain,range);
565 }
566
567
568 //-----------------------------------------------------------------------------
569 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
570 // create input type (domain)
571 const Type **fields = TypeTuple::fields(2);
572 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
573 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
574 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
575
576 // create result type (range)
577 fields = TypeTuple::fields(0);
578
579 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
580
581 return TypeFunc::make(domain,range);
582 }
583
584 const TypeFunc* OptoRuntime::flush_windows_Type() {
585 // create input type (domain)
586 const Type** fields = TypeTuple::fields(1);
587 fields[TypeFunc::Parms+0] = NULL; // void
588 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
589
590 // create result type
591 fields = TypeTuple::fields(1);
592 fields[TypeFunc::Parms+0] = NULL; // void
593 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
594
595 return TypeFunc::make(domain, range);
596 }
597
598 const TypeFunc* OptoRuntime::l2f_Type() {
599 // create input type (domain)
600 const Type **fields = TypeTuple::fields(2);
601 fields[TypeFunc::Parms+0] = TypeLong::LONG;
602 fields[TypeFunc::Parms+1] = Type::HALF;
603 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
604
605 // create result type (range)
606 fields = TypeTuple::fields(1);
607 fields[TypeFunc::Parms+0] = Type::FLOAT;
608 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
609
610 return TypeFunc::make(domain, range);
611 }
612
613 const TypeFunc* OptoRuntime::modf_Type() {
614 const Type **fields = TypeTuple::fields(2);
615 fields[TypeFunc::Parms+0] = Type::FLOAT;
616 fields[TypeFunc::Parms+1] = Type::FLOAT;
617 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
618
619 // create result type (range)
620 fields = TypeTuple::fields(1);
621 fields[TypeFunc::Parms+0] = Type::FLOAT;
622
623 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
624
625 return TypeFunc::make(domain, range);
626 }
627
628 const TypeFunc *OptoRuntime::Math_D_D_Type() {
629 // create input type (domain)
630 const Type **fields = TypeTuple::fields(2);
631 // Symbol* name of class to be loaded
632 fields[TypeFunc::Parms+0] = Type::DOUBLE;
633 fields[TypeFunc::Parms+1] = Type::HALF;
634 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
635
636 // create result type (range)
637 fields = TypeTuple::fields(2);
638 fields[TypeFunc::Parms+0] = Type::DOUBLE;
639 fields[TypeFunc::Parms+1] = Type::HALF;
640 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
641
642 return TypeFunc::make(domain, range);
643 }
644
645 const TypeFunc* OptoRuntime::Math_DD_D_Type() {
646 const Type **fields = TypeTuple::fields(4);
647 fields[TypeFunc::Parms+0] = Type::DOUBLE;
648 fields[TypeFunc::Parms+1] = Type::HALF;
649 fields[TypeFunc::Parms+2] = Type::DOUBLE;
650 fields[TypeFunc::Parms+3] = Type::HALF;
651 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+4, fields);
652
653 // create result type (range)
654 fields = TypeTuple::fields(2);
655 fields[TypeFunc::Parms+0] = Type::DOUBLE;
656 fields[TypeFunc::Parms+1] = Type::HALF;
657 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
658
659 return TypeFunc::make(domain, range);
660 }
661
662 //-------------- currentTimeMillis
663
664 const TypeFunc* OptoRuntime::current_time_millis_Type() {
665 // create input type (domain)
666 const Type **fields = TypeTuple::fields(0);
667 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+0, fields);
668
669 // create result type (range)
670 fields = TypeTuple::fields(2);
671 fields[TypeFunc::Parms+0] = TypeLong::LONG;
672 fields[TypeFunc::Parms+1] = Type::HALF;
673 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
674
675 return TypeFunc::make(domain, range);
676 }
677
678 // arraycopy stub variations:
679 enum ArrayCopyType {
680 ac_fast, // void(ptr, ptr, size_t)
681 ac_checkcast, // int(ptr, ptr, size_t, size_t, ptr)
682 ac_slow, // void(ptr, int, ptr, int, int)
683 ac_generic // int(ptr, int, ptr, int, int)
684 };
685
686 static const TypeFunc* make_arraycopy_Type(ArrayCopyType act) {
687 // create input type (domain)
688 int num_args = (act == ac_fast ? 3 : 5);
689 int num_size_args = (act == ac_fast ? 1 : act == ac_checkcast ? 2 : 0);
690 int argcnt = num_args;
691 LP64_ONLY(argcnt += num_size_args); // halfwords for lengths
692 const Type** fields = TypeTuple::fields(argcnt);
693 int argp = TypeFunc::Parms;
694 fields[argp++] = TypePtr::NOTNULL; // src
695 if (num_size_args == 0) {
696 fields[argp++] = TypeInt::INT; // src_pos
697 }
698 fields[argp++] = TypePtr::NOTNULL; // dest
699 if (num_size_args == 0) {
700 fields[argp++] = TypeInt::INT; // dest_pos
701 fields[argp++] = TypeInt::INT; // length
702 }
703 while (num_size_args-- > 0) {
704 fields[argp++] = TypeX_X; // size in whatevers (size_t)
705 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
706 }
707 if (act == ac_checkcast) {
708 fields[argp++] = TypePtr::NOTNULL; // super_klass
709 }
710 assert(argp == TypeFunc::Parms+argcnt, "correct decoding of act");
711 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
712
713 // create result type if needed
714 int retcnt = (act == ac_checkcast || act == ac_generic ? 1 : 0);
715 fields = TypeTuple::fields(1);
716 if (retcnt == 0)
717 fields[TypeFunc::Parms+0] = NULL; // void
718 else
719 fields[TypeFunc::Parms+0] = TypeInt::INT; // status result, if needed
720 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+retcnt, fields);
721 return TypeFunc::make(domain, range);
722 }
723
724 const TypeFunc* OptoRuntime::fast_arraycopy_Type() {
725 // This signature is simple: Two base pointers and a size_t.
726 return make_arraycopy_Type(ac_fast);
727 }
728
729 const TypeFunc* OptoRuntime::checkcast_arraycopy_Type() {
730 // An extension of fast_arraycopy_Type which adds type checking.
731 return make_arraycopy_Type(ac_checkcast);
732 }
733
734 const TypeFunc* OptoRuntime::slow_arraycopy_Type() {
735 // This signature is exactly the same as System.arraycopy.
736 // There are no intptr_t (int/long) arguments.
737 return make_arraycopy_Type(ac_slow);
738 }
739
740 const TypeFunc* OptoRuntime::generic_arraycopy_Type() {
741 // This signature is like System.arraycopy, except that it returns status.
742 return make_arraycopy_Type(ac_generic);
743 }
744
745
746 const TypeFunc* OptoRuntime::array_fill_Type() {
747 // create input type (domain): pointer, int, size_t
748 const Type** fields = TypeTuple::fields(3 LP64_ONLY( + 1));
749 int argp = TypeFunc::Parms;
750 fields[argp++] = TypePtr::NOTNULL;
751 fields[argp++] = TypeInt::INT;
752 fields[argp++] = TypeX_X; // size in whatevers (size_t)
753 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
754 const TypeTuple *domain = TypeTuple::make(argp, fields);
755
756 // create result type
757 fields = TypeTuple::fields(1);
758 fields[TypeFunc::Parms+0] = NULL; // void
759 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
760
761 return TypeFunc::make(domain, range);
762 }
763
764 //------------- Interpreter state access for on stack replacement
765 const TypeFunc* OptoRuntime::osr_end_Type() {
766 // create input type (domain)
767 const Type **fields = TypeTuple::fields(1);
768 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // OSR temp buf
769 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
770
771 // create result type
772 fields = TypeTuple::fields(1);
773 // fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // locked oop
774 fields[TypeFunc::Parms+0] = NULL; // void
775 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
776 return TypeFunc::make(domain, range);
777 }
778
779 //-------------- methodData update helpers
780
781 const TypeFunc* OptoRuntime::profile_receiver_type_Type() {
782 // create input type (domain)
783 const Type **fields = TypeTuple::fields(2);
784 fields[TypeFunc::Parms+0] = TypeAryPtr::NOTNULL; // methodData pointer
785 fields[TypeFunc::Parms+1] = TypeInstPtr::BOTTOM; // receiver oop
786 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
787
788 // create result type
789 fields = TypeTuple::fields(1);
790 fields[TypeFunc::Parms+0] = NULL; // void
791 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
792 return TypeFunc::make(domain,range);
793 }
794
795 JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
796 if (receiver == NULL) return;
797 klassOop receiver_klass = receiver->klass();
798
799 intptr_t* mdp = ((intptr_t*)(data)) + DataLayout::header_size_in_cells();
800 int empty_row = -1; // free row, if any is encountered
801
802 // ReceiverTypeData* vc = new ReceiverTypeData(mdp);
803 for (uint row = 0; row < ReceiverTypeData::row_limit(); row++) {
804 // if (vc->receiver(row) == receiver_klass)
805 int receiver_off = ReceiverTypeData::receiver_cell_index(row);
806 intptr_t row_recv = *(mdp + receiver_off);
807 if (row_recv == (intptr_t) receiver_klass) {
808 // vc->set_receiver_count(row, vc->receiver_count(row) + DataLayout::counter_increment);
809 int count_off = ReceiverTypeData::receiver_count_cell_index(row);
810 *(mdp + count_off) += DataLayout::counter_increment;
811 return;
812 } else if (row_recv == 0) {
813 // else if (vc->receiver(row) == NULL)
814 empty_row = (int) row;
815 }
816 }
817
818 if (empty_row != -1) {
819 int receiver_off = ReceiverTypeData::receiver_cell_index(empty_row);
820 // vc->set_receiver(empty_row, receiver_klass);
821 *(mdp + receiver_off) = (intptr_t) receiver_klass;
822 // vc->set_receiver_count(empty_row, DataLayout::counter_increment);
823 int count_off = ReceiverTypeData::receiver_count_cell_index(empty_row);
824 *(mdp + count_off) = DataLayout::counter_increment;
825 } else {
826 // Receiver did not match any saved receiver and there is no empty row for it.
827 // Increment total counter to indicate polymorphic case.
828 intptr_t* count_p = (intptr_t*)(((byte*)(data)) + in_bytes(CounterData::count_offset()));
829 *count_p += DataLayout::counter_increment;
830 }
831 JRT_END
832
833 //-----------------------------------------------------------------------------
834 // implicit exception support.
835
836 static void report_null_exception_in_code_cache(address exception_pc) {
837 ResourceMark rm;
838 CodeBlob* n = CodeCache::find_blob(exception_pc);
839 if (n != NULL) {
840 tty->print_cr("#");
841 tty->print_cr("# HotSpot Runtime Error, null exception in generated code");
842 tty->print_cr("#");
843 tty->print_cr("# pc where exception happened = " INTPTR_FORMAT, exception_pc);
844
845 if (n->is_nmethod()) {
846 methodOop method = ((nmethod*)n)->method();
847 tty->print_cr("# Method where it happened %s.%s ", Klass::cast(method->method_holder())->name()->as_C_string(), method->name()->as_C_string());
848 tty->print_cr("#");
849 if (ShowMessageBoxOnError && UpdateHotSpotCompilerFileOnError) {
850 const char* title = "HotSpot Runtime Error";
851 const char* question = "Do you want to exclude compilation of this method in future runs?";
852 if (os::message_box(title, question)) {
853 CompilerOracle::append_comment_to_file("");
854 CompilerOracle::append_comment_to_file("Null exception in compiled code resulted in the following exclude");
855 CompilerOracle::append_comment_to_file("");
856 CompilerOracle::append_exclude_to_file(method);
857 tty->print_cr("#");
858 tty->print_cr("# %s has been updated to exclude the specified method", CompileCommandFile);
859 tty->print_cr("#");
860 }
861 }
862 fatal("Implicit null exception happened in compiled method");
863 } else {
864 n->print();
865 fatal("Implicit null exception happened in generated stub");
866 }
867 }
868 fatal("Implicit null exception at wrong place");
869 }
870
871
872 //-------------------------------------------------------------------------------------
873 // register policy
874
875 bool OptoRuntime::is_callee_saved_register(MachRegisterNumbers reg) {
876 assert(reg >= 0 && reg < _last_Mach_Reg, "must be a machine register");
877 switch (register_save_policy[reg]) {
878 case 'C': return false; //SOC
879 case 'E': return true ; //SOE
880 case 'N': return false; //NS
881 case 'A': return false; //AS
882 }
883 ShouldNotReachHere();
884 return false;
885 }
886
887 //-----------------------------------------------------------------------
888 // Exceptions
889 //
890
891 static void trace_exception(oop exception_oop, address exception_pc, const char* msg) PRODUCT_RETURN;
892
893 // The method is an entry that is always called by a C++ method not
894 // directly from compiled code. Compiled code will call the C++ method following.
895 // We can't allow async exception to be installed during exception processing.
896 JRT_ENTRY_NO_ASYNC(address, OptoRuntime::handle_exception_C_helper(JavaThread* thread, nmethod* &nm))
897
898 // Do not confuse exception_oop with pending_exception. The exception_oop
899 // is only used to pass arguments into the method. Not for general
900 // exception handling. DO NOT CHANGE IT to use pending_exception, since
901 // the runtime stubs checks this on exit.
902 assert(thread->exception_oop() != NULL, "exception oop is found");
903 address handler_address = NULL;
904
905 Handle exception(thread, thread->exception_oop());
906
907 if (TraceExceptions) {
908 trace_exception(exception(), thread->exception_pc(), "");
909 }
910 // for AbortVMOnException flag
911 NOT_PRODUCT(Exceptions::debug_check_abort(exception));
912
913 #ifdef ASSERT
914 if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
915 // should throw an exception here
916 ShouldNotReachHere();
917 }
918 #endif
919
920
921 // new exception handling: this method is entered only from adapters
922 // exceptions from compiled java methods are handled in compiled code
923 // using rethrow node
924
925 address pc = thread->exception_pc();
926 nm = CodeCache::find_nmethod(pc);
927 assert(nm != NULL, "No NMethod found");
928 if (nm->is_native_method()) {
929 fatal("Native mathod should not have path to exception handling");
930 } else {
931 // we are switching to old paradigm: search for exception handler in caller_frame
932 // instead in exception handler of caller_frame.sender()
933
934 if (JvmtiExport::can_post_on_exceptions()) {
935 // "Full-speed catching" is not necessary here,
936 // since we're notifying the VM on every catch.
937 // Force deoptimization and the rest of the lookup
938 // will be fine.
939 deoptimize_caller_frame(thread, true);
940 }
941
942 // Check the stack guard pages. If enabled, look for handler in this frame;
943 // otherwise, forcibly unwind the frame.
944 //
945 // 4826555: use default current sp for reguard_stack instead of &nm: it's more accurate.
946 bool force_unwind = !thread->reguard_stack();
947 bool deopting = false;
948 if (nm->is_deopt_pc(pc)) {
949 deopting = true;
950 RegisterMap map(thread, false);
951 frame deoptee = thread->last_frame().sender(&map);
952 assert(deoptee.is_deoptimized_frame(), "must be deopted");
953 // Adjust the pc back to the original throwing pc
954 pc = deoptee.pc();
955 }
956
957 // If we are forcing an unwind because of stack overflow then deopt is
958 // irrelevant sice we are throwing the frame away anyway.
959
960 if (deopting && !force_unwind) {
961 handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();
962 } else {
963
964 handler_address =
965 force_unwind ? NULL : nm->handler_for_exception_and_pc(exception, pc);
966
967 if (handler_address == NULL) {
968 handler_address = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, force_unwind, true);
969 assert (handler_address != NULL, "must have compiled handler");
970 // Update the exception cache only when the unwind was not forced.
971 if (!force_unwind) {
972 nm->add_handler_for_exception_and_pc(exception,pc,handler_address);
973 }
974 } else {
975 assert(handler_address == SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, force_unwind, true), "Must be the same");
976 }
977 }
978
979 thread->set_exception_pc(pc);
980 thread->set_exception_handler_pc(handler_address);
981 thread->set_exception_stack_size(0);
982
983 // Check if the exception PC is a MethodHandle call site.
984 thread->set_is_method_handle_return(nm->is_method_handle_return(pc));
985 }
986
987 // Restore correct return pc. Was saved above.
988 thread->set_exception_oop(exception());
989 return handler_address;
990
991 JRT_END
992
993 // We are entering here from exception_blob
994 // If there is a compiled exception handler in this method, we will continue there;
995 // otherwise we will unwind the stack and continue at the caller of top frame method
996 // Note we enter without the usual JRT wrapper. We will call a helper routine that
997 // will do the normal VM entry. We do it this way so that we can see if the nmethod
998 // we looked up the handler for has been deoptimized in the meantime. If it has been
999 // we must not use the handler and instread return the deopt blob.
1000 address OptoRuntime::handle_exception_C(JavaThread* thread) {
1001 //
1002 // We are in Java not VM and in debug mode we have a NoHandleMark
1003 //
1004 #ifndef PRODUCT
1005 SharedRuntime::_find_handler_ctr++; // find exception handler
1006 #endif
1007 debug_only(NoHandleMark __hm;)
1008 nmethod* nm = NULL;
1009 address handler_address = NULL;
1010 {
1011 // Enter the VM
1012
1013 ResetNoHandleMark rnhm;
1014 handler_address = handle_exception_C_helper(thread, nm);
1015 }
1016
1017 // Back in java: Use no oops, DON'T safepoint
1018
1019 // Now check to see if the handler we are returning is in a now
1020 // deoptimized frame
1021
1022 if (nm != NULL) {
1023 RegisterMap map(thread, false);
1024 frame caller = thread->last_frame().sender(&map);
1025 #ifdef ASSERT
1026 assert(caller.is_compiled_frame(), "must be");
1027 #endif // ASSERT
1028 if (caller.is_deoptimized_frame()) {
1029 handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();
1030 }
1031 }
1032 return handler_address;
1033 }
1034
1035 //------------------------------rethrow----------------------------------------
1036 // We get here after compiled code has executed a 'RethrowNode'. The callee
1037 // is either throwing or rethrowing an exception. The callee-save registers
1038 // have been restored, synchronized objects have been unlocked and the callee
1039 // stack frame has been removed. The return address was passed in.
1040 // Exception oop is passed as the 1st argument. This routine is then called
1041 // from the stub. On exit, we know where to jump in the caller's code.
1042 // After this C code exits, the stub will pop his frame and end in a jump
1043 // (instead of a return). We enter the caller's default handler.
1044 //
1045 // This must be JRT_LEAF:
1046 // - caller will not change its state as we cannot block on exit,
1047 // therefore raw_exception_handler_for_return_address is all it takes
1048 // to handle deoptimized blobs
1049 //
1050 // However, there needs to be a safepoint check in the middle! So compiled
1051 // safepoints are completely watertight.
1052 //
1053 // Thus, it cannot be a leaf since it contains the No_GC_Verifier.
1054 //
1055 // *THIS IS NOT RECOMMENDED PROGRAMMING STYLE*
1056 //
1057 address OptoRuntime::rethrow_C(oopDesc* exception, JavaThread* thread, address ret_pc) {
1058 #ifndef PRODUCT
1059 SharedRuntime::_rethrow_ctr++; // count rethrows
1060 #endif
1061 assert (exception != NULL, "should have thrown a NULLPointerException");
1062 #ifdef ASSERT
1063 if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {
1064 // should throw an exception here
1065 ShouldNotReachHere();
1066 }
1067 #endif
1068
1069 thread->set_vm_result(exception);
1070 // Frame not compiled (handles deoptimization blob)
1071 return SharedRuntime::raw_exception_handler_for_return_address(thread, ret_pc);
1072 }
1073
1074
1075 const TypeFunc *OptoRuntime::rethrow_Type() {
1076 // create input type (domain)
1077 const Type **fields = TypeTuple::fields(1);
1078 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
1079 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
1080
1081 // create result type (range)
1082 fields = TypeTuple::fields(1);
1083 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
1084 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
1085
1086 return TypeFunc::make(domain, range);
1087 }
1088
1089
1090 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
1091 // Deoptimize frame
1092 if (doit) {
1093 // Called from within the owner thread, so no need for safepoint
1094 RegisterMap reg_map(thread);
1095 frame stub_frame = thread->last_frame();
1096 assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");
1097 frame caller_frame = stub_frame.sender(®_map);
1098
1099 // bypass VM_DeoptimizeFrame and deoptimize the frame directly
1100 Deoptimization::deoptimize_frame(thread, caller_frame.id());
1101 }
1102 }
1103
1104
1105 const TypeFunc *OptoRuntime::register_finalizer_Type() {
1106 // create input type (domain)
1107 const Type **fields = TypeTuple::fields(1);
1108 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // oop; Receiver
1109 // // The JavaThread* is passed to each routine as the last argument
1110 // fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // JavaThread *; Executing thread
1111 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
1112
1113 // create result type (range)
1114 fields = TypeTuple::fields(0);
1115
1116 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1117
1118 return TypeFunc::make(domain,range);
1119 }
1120
1121
1122 //-----------------------------------------------------------------------------
1123 // Dtrace support. entry and exit probes have the same signature
1124 const TypeFunc *OptoRuntime::dtrace_method_entry_exit_Type() {
1125 // create input type (domain)
1126 const Type **fields = TypeTuple::fields(2);
1127 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
1128 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // methodOop; Method we are entering
1129 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
1130
1131 // create result type (range)
1132 fields = TypeTuple::fields(0);
1133
1134 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1135
1136 return TypeFunc::make(domain,range);
1137 }
1138
1139 const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
1140 // create input type (domain)
1141 const Type **fields = TypeTuple::fields(2);
1142 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
1143 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // oop; newly allocated object
1144
1145 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
1146
1147 // create result type (range)
1148 fields = TypeTuple::fields(0);
1149
1150 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1151
1152 return TypeFunc::make(domain,range);
1153 }
1154
1155
1156 JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))
1157 assert(obj->is_oop(), "must be a valid oop");
1158 assert(obj->klass()->klass_part()->has_finalizer(), "shouldn't be here otherwise");
1159 instanceKlass::register_finalizer(instanceOop(obj), CHECK);
1160 JRT_END
1161
1162 //-----------------------------------------------------------------------------
1163
1164 NamedCounter * volatile OptoRuntime::_named_counters = NULL;
1165
1166 //
1167 // dump the collected NamedCounters.
1168 //
1169 void OptoRuntime::print_named_counters() {
1170 int total_lock_count = 0;
1171 int eliminated_lock_count = 0;
1172
1173 NamedCounter* c = _named_counters;
1174 while (c) {
1175 if (c->tag() == NamedCounter::LockCounter || c->tag() == NamedCounter::EliminatedLockCounter) {
1176 int count = c->count();
1177 if (count > 0) {
1178 bool eliminated = c->tag() == NamedCounter::EliminatedLockCounter;
1179 if (Verbose) {
1180 tty->print_cr("%d %s%s", count, c->name(), eliminated ? " (eliminated)" : "");
1181 }
1182 total_lock_count += count;
1183 if (eliminated) {
1184 eliminated_lock_count += count;
1185 }
1186 }
1187 } else if (c->tag() == NamedCounter::BiasedLockingCounter) {
1188 BiasedLockingCounters* blc = ((BiasedLockingNamedCounter*)c)->counters();
1189 if (blc->nonzero()) {
1190 tty->print_cr("%s", c->name());
1191 blc->print_on(tty);
1192 }
1193 }
1194 c = c->next();
1195 }
1196 if (total_lock_count > 0) {
1197 tty->print_cr("dynamic locks: %d", total_lock_count);
1198 if (eliminated_lock_count) {
1199 tty->print_cr("eliminated locks: %d (%d%%)", eliminated_lock_count,
1200 (int)(eliminated_lock_count * 100.0 / total_lock_count));
1201 }
1202 }
1203 }
1204
1205 //
1206 // Allocate a new NamedCounter. The JVMState is used to generate the
1207 // name which consists of method@line for the inlining tree.
1208 //
1209
1210 NamedCounter* OptoRuntime::new_named_counter(JVMState* youngest_jvms, NamedCounter::CounterTag tag) {
1211 int max_depth = youngest_jvms->depth();
1212
1213 // Visit scopes from youngest to oldest.
1214 bool first = true;
1215 stringStream st;
1216 for (int depth = max_depth; depth >= 1; depth--) {
1217 JVMState* jvms = youngest_jvms->of_depth(depth);
1218 ciMethod* m = jvms->has_method() ? jvms->method() : NULL;
1219 if (!first) {
1220 st.print(" ");
1221 } else {
1222 first = false;
1223 }
1224 int bci = jvms->bci();
1225 if (bci < 0) bci = 0;
1226 st.print("%s.%s@%d", m->holder()->name()->as_utf8(), m->name()->as_utf8(), bci);
1227 // To print linenumbers instead of bci use: m->line_number_from_bci(bci)
1228 }
1229 NamedCounter* c;
1230 if (tag == NamedCounter::BiasedLockingCounter) {
1231 c = new BiasedLockingNamedCounter(strdup(st.as_string()));
1232 } else {
1233 c = new NamedCounter(strdup(st.as_string()), tag);
1234 }
1235
1236 // atomically add the new counter to the head of the list. We only
1237 // add counters so this is safe.
1238 NamedCounter* head;
1239 do {
1240 head = _named_counters;
1241 c->set_next(head);
1242 } while (Atomic::cmpxchg_ptr(c, &_named_counters, head) != head);
1243 return c;
1244 }
1245
1246 //-----------------------------------------------------------------------------
1247 // Non-product code
1248 #ifndef PRODUCT
1249
1250 int trace_exception_counter = 0;
1251 static void trace_exception(oop exception_oop, address exception_pc, const char* msg) {
1252 ttyLocker ttyl;
1253 trace_exception_counter++;
1254 tty->print("%d [Exception (%s): ", trace_exception_counter, msg);
1255 exception_oop->print_value();
1256 tty->print(" in ");
1257 CodeBlob* blob = CodeCache::find_blob(exception_pc);
1258 if (blob->is_nmethod()) {
1259 ((nmethod*)blob)->method()->print_value();
1260 } else if (blob->is_runtime_stub()) {
1261 tty->print("<runtime-stub>");
1262 } else {
1263 tty->print("<unknown>");
1264 }
1265 tty->print(" at " INTPTR_FORMAT, exception_pc);
1266 tty->print_cr("]");
1267 }
1268
1269 #endif // PRODUCT
1270
1271
1272 # ifdef ENABLE_ZAP_DEAD_LOCALS
1273 // Called from call sites in compiled code with oop maps (actually safepoints)
1274 // Zaps dead locals in first java frame.
1275 // Is entry because may need to lock to generate oop maps
1276 // Currently, only used for compiler frames, but someday may be used
1277 // for interpreter frames, too.
1278
1279 int OptoRuntime::ZapDeadCompiledLocals_count = 0;
1280
1281 // avoid pointers to member funcs with these helpers
1282 static bool is_java_frame( frame* f) { return f->is_java_frame(); }
1283 static bool is_native_frame(frame* f) { return f->is_native_frame(); }
1284
1285
1286 void OptoRuntime::zap_dead_java_or_native_locals(JavaThread* thread,
1287 bool (*is_this_the_right_frame_to_zap)(frame*)) {
1288 assert(JavaThread::current() == thread, "is this needed?");
1289
1290 if ( !ZapDeadCompiledLocals ) return;
1291
1292 bool skip = false;
1293
1294 if ( ZapDeadCompiledLocalsFirst == 0 ) ; // nothing special
1295 else if ( ZapDeadCompiledLocalsFirst > ZapDeadCompiledLocals_count ) skip = true;
1296 else if ( ZapDeadCompiledLocalsFirst == ZapDeadCompiledLocals_count )
1297 warning("starting zapping after skipping");
1298
1299 if ( ZapDeadCompiledLocalsLast == -1 ) ; // nothing special
1300 else if ( ZapDeadCompiledLocalsLast < ZapDeadCompiledLocals_count ) skip = true;
1301 else if ( ZapDeadCompiledLocalsLast == ZapDeadCompiledLocals_count )
1302 warning("about to zap last zap");
1303
1304 ++ZapDeadCompiledLocals_count; // counts skipped zaps, too
1305
1306 if ( skip ) return;
1307
1308 // find java frame and zap it
1309
1310 for (StackFrameStream sfs(thread); !sfs.is_done(); sfs.next()) {
1311 if (is_this_the_right_frame_to_zap(sfs.current()) ) {
1312 sfs.current()->zap_dead_locals(thread, sfs.register_map());
1313 return;
1314 }
1315 }
1316 warning("no frame found to zap in zap_dead_Java_locals_C");
1317 }
1318
1319 JRT_LEAF(void, OptoRuntime::zap_dead_Java_locals_C(JavaThread* thread))
1320 zap_dead_java_or_native_locals(thread, is_java_frame);
1321 JRT_END
1322
1323 // The following does not work because for one thing, the
1324 // thread state is wrong; it expects java, but it is native.
1325 // Also, the invariants in a native stub are different and
1326 // I'm not sure it is safe to have a MachCalRuntimeDirectNode
1327 // in there.
1328 // So for now, we do not zap in native stubs.
1329
1330 JRT_LEAF(void, OptoRuntime::zap_dead_native_locals_C(JavaThread* thread))
1331 zap_dead_java_or_native_locals(thread, is_native_frame);
1332 JRT_END
1333
1334 # endif