139 if (element_klass->oop_is_instance()) {
140 InstanceKlass* ik = InstanceKlass::cast(element_klass());
141 ik->set_array_name(name);
142 }
143 }
144
145 // Initialize instance variables
146 ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
147
148 // Add all classes to our internal class loader list here,
149 // including classes in the bootstrap (NULL) class loader.
150 // GC walks these as strong roots.
151 loader_data->add_class(oak);
152
153 // Call complete_create_array_klass after all instance variables has been initialized.
154 ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
155
156 return oak;
157 }
158
159 ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name) {
160 this->set_dimension(n);
161 this->set_element_klass(element_klass());
162 // decrement refcount because object arrays are not explicitly freed. The
163 // InstanceKlass array_name() keeps the name counted while the klass is
164 // loaded.
165 name->decrement_refcount();
166
167 Klass* bk;
168 if (element_klass->oop_is_objArray()) {
169 bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
170 } else {
171 bk = element_klass();
172 }
173 assert(bk != NULL && (bk->oop_is_instance() || bk->oop_is_typeArray()), "invalid bottom klass");
174 this->set_bottom_klass(bk);
175 this->set_class_loader_data(bk->class_loader_data());
176
177 this->set_layout_helper(array_layout_helper(T_OBJECT));
178 assert(this->oop_is_array(), "sanity");
179 assert(this->oop_is_objArray(), "sanity");
395 Klass* array_super = elem_super->array_klass_or_null();
396 assert(array_super != NULL, "must already have been created");
397 secondaries->push(array_super);
398 }
399 return secondaries;
400 }
401 }
402
403 bool ObjArrayKlass::compute_is_subtype_of(Klass* k) {
404 if (!k->oop_is_objArray())
405 return ArrayKlass::compute_is_subtype_of(k);
406
407 ObjArrayKlass* oak = ObjArrayKlass::cast(k);
408 return element_klass()->is_subtype_of(oak->element_klass());
409 }
410
411 void ObjArrayKlass::initialize(TRAPS) {
412 bottom_klass()->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass
413 }
414
415 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
416 { \
417 T* p = (T*)(a)->base(); \
418 T* const end = p + (a)->length(); \
419 while (p < end) { \
420 do_oop; \
421 p++; \
422 } \
423 }
424
425 #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \
426 { \
427 T* const l = (T*)(low); \
428 T* const h = (T*)(high); \
429 T* p = (T*)(a)->base(); \
430 T* end = p + (a)->length(); \
431 if (p < l) p = l; \
432 if (end > h) end = h; \
433 while (p < end) { \
434 do_oop; \
435 ++p; \
436 } \
437 }
438
439 #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop) \
440 if (UseCompressedOops) { \
441 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
442 a, p, do_oop) \
443 } else { \
444 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \
445 a, p, do_oop) \
446 }
447
448 #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \
449 if (UseCompressedOops) { \
450 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
451 a, p, low, high, do_oop) \
452 } else { \
453 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
454 a, p, low, high, do_oop) \
455 }
456
457 void ObjArrayKlass::oop_follow_contents(oop obj) {
458 assert (obj->is_array(), "obj must be array");
459 MarkSweep::follow_klass(obj->klass());
460 if (UseCompressedOops) {
461 objarray_follow_contents<narrowOop>(obj, 0);
462 } else {
463 objarray_follow_contents<oop>(obj, 0);
464 }
465 }
466
467 #if INCLUDE_ALL_GCS
468 void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
469 oop obj) {
470 assert(obj->is_array(), "obj must be array");
471 PSParallelCompact::follow_klass(cm, obj->klass());
472 if (UseCompressedOops) {
473 objarray_follow_contents<narrowOop>(cm, obj, 0);
474 } else {
475 objarray_follow_contents<oop>(cm, obj, 0);
476 }
477 }
478 #endif // INCLUDE_ALL_GCS
479
480 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
481 \
482 int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \
483 OopClosureType* closure) { \
484 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
485 assert (obj->is_array(), "obj must be array"); \
486 objArrayOop a = objArrayOop(obj); \
487 /* Get size before changing pointers. */ \
488 /* Don't call size() or oop_size() since that is a virtual call. */ \
489 int size = a->object_size(); \
490 if_do_metadata_checked(closure, nv_suffix) { \
491 closure->do_klass##nv_suffix(obj->klass()); \
492 } \
493 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \
494 return size; \
495 }
496
497 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
498 \
499 int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
500 OopClosureType* closure, \
501 MemRegion mr) { \
502 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
503 assert(obj->is_array(), "obj must be array"); \
504 objArrayOop a = objArrayOop(obj); \
505 /* Get size before changing pointers. */ \
506 /* Don't call size() or oop_size() since that is a virtual call */ \
507 int size = a->object_size(); \
508 if_do_metadata_checked(closure, nv_suffix) { \
509 /* SSS: Do we need to pass down mr here? */ \
510 closure->do_klass##nv_suffix(a->klass()); \
511 } \
512 ObjArrayKlass_BOUNDED_OOP_ITERATE( \
513 a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p)) \
514 return size; \
515 }
516
517 // Like oop_oop_iterate but only iterates over a specified range and only used
518 // for objArrayOops.
519 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \
520 \
521 int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \
522 OopClosureType* closure, \
523 int start, int end) { \
524 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
525 assert(obj->is_array(), "obj must be array"); \
526 objArrayOop a = objArrayOop(obj); \
527 /* Get size before changing pointers. */ \
528 /* Don't call size() or oop_size() since that is a virtual call */ \
529 int size = a->object_size(); \
530 if (UseCompressedOops) { \
531 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);\
532 /* this might be wierd if end needs to be aligned on HeapWord boundary */ \
533 HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end); \
534 MemRegion mr(low, high); \
535 if_do_metadata_checked(closure, nv_suffix) { \
536 /* SSS: Do we need to pass down mr here? */ \
537 closure->do_klass##nv_suffix(a->klass()); \
538 } \
539 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
540 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
541 } else { \
542 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start); \
543 HeapWord* high = (HeapWord*)((oop*)a->base() + end); \
544 MemRegion mr(low, high); \
545 if_do_metadata_checked(closure, nv_suffix) { \
546 /* SSS: Do we need to pass down mr here? */ \
547 closure->do_klass##nv_suffix(a->klass()); \
548 } \
549 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
550 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
551 } \
552 return size; \
553 }
554
555 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
556 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
557 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
558 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
559 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
560 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
561
562 int ObjArrayKlass::oop_adjust_pointers(oop obj) {
563 assert(obj->is_objArray(), "obj must be obj array");
564 objArrayOop a = objArrayOop(obj);
565 // Get size before changing pointers.
566 // Don't call size() or oop_size() since that is a virtual call.
567 int size = a->object_size();
568 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
569 return size;
570 }
571
572 #if INCLUDE_ALL_GCS
573 void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
574 assert(obj->is_objArray(), "obj must be obj array");
575 ObjArrayKlass_OOP_ITERATE( \
576 objArrayOop(obj), p, \
577 if (PSScavenge::should_scavenge(p)) { \
578 pm->claim_or_forward_depth(p); \
579 })
580 }
|
139 if (element_klass->oop_is_instance()) {
140 InstanceKlass* ik = InstanceKlass::cast(element_klass());
141 ik->set_array_name(name);
142 }
143 }
144
145 // Initialize instance variables
146 ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
147
148 // Add all classes to our internal class loader list here,
149 // including classes in the bootstrap (NULL) class loader.
150 // GC walks these as strong roots.
151 loader_data->add_class(oak);
152
153 // Call complete_create_array_klass after all instance variables has been initialized.
154 ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
155
156 return oak;
157 }
158
159 ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name, _obj_array) {
160 this->set_dimension(n);
161 this->set_element_klass(element_klass());
162 // decrement refcount because object arrays are not explicitly freed. The
163 // InstanceKlass array_name() keeps the name counted while the klass is
164 // loaded.
165 name->decrement_refcount();
166
167 Klass* bk;
168 if (element_klass->oop_is_objArray()) {
169 bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
170 } else {
171 bk = element_klass();
172 }
173 assert(bk != NULL && (bk->oop_is_instance() || bk->oop_is_typeArray()), "invalid bottom klass");
174 this->set_bottom_klass(bk);
175 this->set_class_loader_data(bk->class_loader_data());
176
177 this->set_layout_helper(array_layout_helper(T_OBJECT));
178 assert(this->oop_is_array(), "sanity");
179 assert(this->oop_is_objArray(), "sanity");
395 Klass* array_super = elem_super->array_klass_or_null();
396 assert(array_super != NULL, "must already have been created");
397 secondaries->push(array_super);
398 }
399 return secondaries;
400 }
401 }
402
403 bool ObjArrayKlass::compute_is_subtype_of(Klass* k) {
404 if (!k->oop_is_objArray())
405 return ArrayKlass::compute_is_subtype_of(k);
406
407 ObjArrayKlass* oak = ObjArrayKlass::cast(k);
408 return element_klass()->is_subtype_of(oak->element_klass());
409 }
410
411 void ObjArrayKlass::initialize(TRAPS) {
412 bottom_klass()->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass
413 }
414
415 void ObjArrayKlass::oop_follow_contents(oop obj) {
416 assert (obj->is_array(), "obj must be array");
417 MarkSweep::follow_klass(obj->klass());
418 if (UseCompressedOops) {
419 objarray_follow_contents<narrowOop>(obj, 0);
420 } else {
421 objarray_follow_contents<oop>(obj, 0);
422 }
423 }
424
425 #if INCLUDE_ALL_GCS
426 void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
427 oop obj) {
428 assert(obj->is_array(), "obj must be array");
429 PSParallelCompact::follow_klass(cm, obj->klass());
430 if (UseCompressedOops) {
431 objarray_follow_contents<narrowOop>(cm, obj, 0);
432 } else {
433 objarray_follow_contents<oop>(cm, obj, 0);
434 }
435 }
436 #endif // INCLUDE_ALL_GCS
437
438 int ObjArrayKlass::oop_adjust_pointers(oop obj) {
439 assert(obj->is_objArray(), "obj must be obj array");
440 objArrayOop a = objArrayOop(obj);
441 // Get size before changing pointers.
442 // Don't call size() or oop_size() since that is a virtual call.
443 int size = a->object_size();
444 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
445 return size;
446 }
447
448 #if INCLUDE_ALL_GCS
449 void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
450 assert(obj->is_objArray(), "obj must be obj array");
451 ObjArrayKlass_OOP_ITERATE( \
452 objArrayOop(obj), p, \
453 if (PSScavenge::should_scavenge(p)) { \
454 pm->claim_or_forward_depth(p); \
455 })
456 }
|