43 #include "runtime/handles.inline.hpp" |
41 #include "runtime/handles.inline.hpp" |
44 #include "runtime/mutexLocker.hpp" |
42 #include "runtime/mutexLocker.hpp" |
45 #include "runtime/orderAccess.inline.hpp" |
43 #include "runtime/orderAccess.inline.hpp" |
46 #include "utilities/copy.hpp" |
44 #include "utilities/copy.hpp" |
47 #include "utilities/macros.hpp" |
45 #include "utilities/macros.hpp" |
48 #if INCLUDE_ALL_GCS |
|
49 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp" |
|
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
|
51 #include "gc_implementation/g1/g1OopClosures.inline.hpp" |
|
52 #include "gc_implementation/g1/g1RemSet.inline.hpp" |
|
53 #include "gc_implementation/g1/heapRegionManager.inline.hpp" |
|
54 #include "gc_implementation/parNew/parOopClosures.inline.hpp" |
|
55 #include "gc_implementation/parallelScavenge/psCompactionManager.hpp" |
|
56 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" |
|
57 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" |
|
58 #endif // INCLUDE_ALL_GCS |
|
59 |
46 |
60 ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) { |
47 ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) { |
61 assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(), |
48 assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(), |
62 "array klasses must be same size as InstanceKlass"); |
49 "array klasses must be same size as InstanceKlass"); |
63 |
50 |
408 |
395 |
409 void ObjArrayKlass::initialize(TRAPS) { |
396 void ObjArrayKlass::initialize(TRAPS) { |
410 bottom_klass()->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass |
397 bottom_klass()->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass |
411 } |
398 } |
412 |
399 |
413 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \ |
|
414 { \ |
|
415 T* p = (T*)(a)->base(); \ |
|
416 T* const end = p + (a)->length(); \ |
|
417 while (p < end) { \ |
|
418 do_oop; \ |
|
419 p++; \ |
|
420 } \ |
|
421 } |
|
422 |
|
423 #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \ |
|
424 { \ |
|
425 T* const l = (T*)(low); \ |
|
426 T* const h = (T*)(high); \ |
|
427 T* p = (T*)(a)->base(); \ |
|
428 T* end = p + (a)->length(); \ |
|
429 if (p < l) p = l; \ |
|
430 if (end > h) end = h; \ |
|
431 while (p < end) { \ |
|
432 do_oop; \ |
|
433 ++p; \ |
|
434 } \ |
|
435 } |
|
436 |
|
437 #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop) \ |
|
438 if (UseCompressedOops) { \ |
|
439 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \ |
|
440 a, p, do_oop) \ |
|
441 } else { \ |
|
442 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \ |
|
443 a, p, do_oop) \ |
|
444 } |
|
445 |
|
446 #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \ |
|
447 if (UseCompressedOops) { \ |
|
448 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ |
|
449 a, p, low, high, do_oop) \ |
|
450 } else { \ |
|
451 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ |
|
452 a, p, low, high, do_oop) \ |
|
453 } |
|
454 |
|
455 void ObjArrayKlass::oop_follow_contents(oop obj) { |
|
456 assert (obj->is_array(), "obj must be array"); |
|
457 MarkSweep::follow_klass(obj->klass()); |
|
458 if (UseCompressedOops) { |
|
459 objarray_follow_contents<narrowOop>(obj, 0); |
|
460 } else { |
|
461 objarray_follow_contents<oop>(obj, 0); |
|
462 } |
|
463 } |
|
464 |
|
465 #if INCLUDE_ALL_GCS |
|
466 void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm, |
|
467 oop obj) { |
|
468 assert(obj->is_array(), "obj must be array"); |
|
469 PSParallelCompact::follow_klass(cm, obj->klass()); |
|
470 if (UseCompressedOops) { |
|
471 objarray_follow_contents<narrowOop>(cm, obj, 0); |
|
472 } else { |
|
473 objarray_follow_contents<oop>(cm, obj, 0); |
|
474 } |
|
475 } |
|
476 #endif // INCLUDE_ALL_GCS |
|
477 |
|
478 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
|
479 \ |
|
480 int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \ |
|
481 OopClosureType* closure) { \ |
|
482 assert (obj->is_array(), "obj must be array"); \ |
|
483 objArrayOop a = objArrayOop(obj); \ |
|
484 /* Get size before changing pointers. */ \ |
|
485 /* Don't call size() or oop_size() since that is a virtual call. */ \ |
|
486 int size = a->object_size(); \ |
|
487 if_do_metadata_checked(closure, nv_suffix) { \ |
|
488 closure->do_klass##nv_suffix(obj->klass()); \ |
|
489 } \ |
|
490 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \ |
|
491 return size; \ |
|
492 } |
|
493 |
|
494 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ |
|
495 \ |
|
496 int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \ |
|
497 OopClosureType* closure, \ |
|
498 MemRegion mr) { \ |
|
499 assert(obj->is_array(), "obj must be array"); \ |
|
500 objArrayOop a = objArrayOop(obj); \ |
|
501 /* Get size before changing pointers. */ \ |
|
502 /* Don't call size() or oop_size() since that is a virtual call */ \ |
|
503 int size = a->object_size(); \ |
|
504 if_do_metadata_checked(closure, nv_suffix) { \ |
|
505 /* SSS: Do we need to pass down mr here? */ \ |
|
506 closure->do_klass##nv_suffix(a->klass()); \ |
|
507 } \ |
|
508 ObjArrayKlass_BOUNDED_OOP_ITERATE( \ |
|
509 a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p)) \ |
|
510 return size; \ |
|
511 } |
|
512 |
|
513 // Like oop_oop_iterate but only iterates over a specified range and only used |
|
514 // for objArrayOops. |
|
515 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \ |
|
516 \ |
|
517 int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \ |
|
518 OopClosureType* closure, \ |
|
519 int start, int end) { \ |
|
520 assert(obj->is_array(), "obj must be array"); \ |
|
521 objArrayOop a = objArrayOop(obj); \ |
|
522 /* Get size before changing pointers. */ \ |
|
523 /* Don't call size() or oop_size() since that is a virtual call */ \ |
|
524 int size = a->object_size(); \ |
|
525 if (UseCompressedOops) { \ |
|
526 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);\ |
|
527 /* this might be wierd if end needs to be aligned on HeapWord boundary */ \ |
|
528 HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end); \ |
|
529 MemRegion mr(low, high); \ |
|
530 if_do_metadata_checked(closure, nv_suffix) { \ |
|
531 /* SSS: Do we need to pass down mr here? */ \ |
|
532 closure->do_klass##nv_suffix(a->klass()); \ |
|
533 } \ |
|
534 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ |
|
535 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ |
|
536 } else { \ |
|
537 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start); \ |
|
538 HeapWord* high = (HeapWord*)((oop*)a->base() + end); \ |
|
539 MemRegion mr(low, high); \ |
|
540 if_do_metadata_checked(closure, nv_suffix) { \ |
|
541 /* SSS: Do we need to pass down mr here? */ \ |
|
542 closure->do_klass##nv_suffix(a->klass()); \ |
|
543 } \ |
|
544 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ |
|
545 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ |
|
546 } \ |
|
547 return size; \ |
|
548 } |
|
549 |
|
550 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN) |
|
551 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN) |
|
552 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) |
|
553 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) |
|
554 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) |
|
555 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) |
|
556 |
|
557 int ObjArrayKlass::oop_adjust_pointers(oop obj) { |
|
558 assert(obj->is_objArray(), "obj must be obj array"); |
|
559 objArrayOop a = objArrayOop(obj); |
|
560 // Get size before changing pointers. |
|
561 // Don't call size() or oop_size() since that is a virtual call. |
|
562 int size = a->object_size(); |
|
563 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p)) |
|
564 return size; |
|
565 } |
|
566 |
|
567 #if INCLUDE_ALL_GCS |
|
568 void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { |
|
569 assert(obj->is_objArray(), "obj must be obj array"); |
|
570 ObjArrayKlass_OOP_ITERATE( \ |
|
571 objArrayOop(obj), p, \ |
|
572 if (PSScavenge::should_scavenge(p)) { \ |
|
573 pm->claim_or_forward_depth(p); \ |
|
574 }) |
|
575 } |
|
576 |
|
577 int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { |
|
578 assert (obj->is_objArray(), "obj must be obj array"); |
|
579 objArrayOop a = objArrayOop(obj); |
|
580 int size = a->object_size(); |
|
581 ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p)) |
|
582 return size; |
|
583 } |
|
584 #endif // INCLUDE_ALL_GCS |
|
585 |
|
586 // JVM support |
400 // JVM support |
587 |
401 |
588 jint ObjArrayKlass::compute_modifier_flags(TRAPS) const { |
402 jint ObjArrayKlass::compute_modifier_flags(TRAPS) const { |
589 // The modifier for an objectArray is the same as its element |
403 // The modifier for an objectArray is the same as its element |
590 if (element_klass() == NULL) { |
404 if (element_klass() == NULL) { |