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