366 }
367 return obj;
368 }
369
370 void MemAllocator::mem_clear(HeapWord* mem) const {
371 assert(mem != nullptr, "cannot initialize null object");
372 const size_t hs = oopDesc::header_size();
373 assert(_word_size >= hs, "unexpected object size");
374 if (oopDesc::has_klass_gap()) {
375 oopDesc::set_klass_gap(mem, 0);
376 }
377 Copy::fill_to_aligned_words(mem + hs, _word_size - hs);
378 }
379
380 oop MemAllocator::finish(HeapWord* mem) const {
381 assert(mem != nullptr, "null object pointer");
382 // Need a release store to ensure array/class length, mark word, and
383 // object zeroing are visible before setting the klass non-null, for
384 // concurrent collectors.
385 if (UseCompactObjectHeaders) {
386 oopDesc::release_set_mark(mem, _klass->prototype_header());
387 } else {
388 oopDesc::set_mark(mem, markWord::prototype());
389 oopDesc::release_set_klass(mem, _klass);
390 }
391 return cast_to_oop(mem);
392 }
393
394 oop ObjAllocator::initialize(HeapWord* mem) const {
395 mem_clear(mem);
396 return finish(mem);
397 }
398
399 oop ObjArrayAllocator::initialize(HeapWord* mem) const {
400 // Set array length before setting the _klass field because a
401 // non-null klass field indicates that the object is parsable by
402 // concurrent GC.
403 assert(_length >= 0, "length should be non-negative");
404 if (_do_zero) {
405 mem_clear(mem);
406 mem_zap_start_padding(mem);
407 mem_zap_end_padding(mem);
408 }
409 arrayOopDesc::set_length(mem, _length);
410 return finish(mem);
411 }
412
413 #ifndef PRODUCT
414 void ObjArrayAllocator::mem_zap_start_padding(HeapWord* mem) const {
415 const BasicType element_type = ArrayKlass::cast(_klass)->element_type();
416 const size_t base_offset_in_bytes = arrayOopDesc::base_offset_in_bytes(element_type);
417 const size_t header_size_in_bytes = arrayOopDesc::header_size_in_bytes();
418
|
366 }
367 return obj;
368 }
369
370 void MemAllocator::mem_clear(HeapWord* mem) const {
371 assert(mem != nullptr, "cannot initialize null object");
372 const size_t hs = oopDesc::header_size();
373 assert(_word_size >= hs, "unexpected object size");
374 if (oopDesc::has_klass_gap()) {
375 oopDesc::set_klass_gap(mem, 0);
376 }
377 Copy::fill_to_aligned_words(mem + hs, _word_size - hs);
378 }
379
380 oop MemAllocator::finish(HeapWord* mem) const {
381 assert(mem != nullptr, "null object pointer");
382 // Need a release store to ensure array/class length, mark word, and
383 // object zeroing are visible before setting the klass non-null, for
384 // concurrent collectors.
385 if (UseCompactObjectHeaders) {
386 oopDesc::release_set_mark(mem, Klass::default_prototype_header(_klass));
387 } else {
388 if (EnableValhalla) {
389 oopDesc::set_mark(mem, Klass::default_prototype_header(_klass));
390 } else {
391 oopDesc::set_mark(mem, markWord::prototype());
392 }
393 oopDesc::release_set_klass(mem, _klass);
394 }
395 return cast_to_oop(mem);
396 }
397
398 oop ObjAllocator::initialize(HeapWord* mem) const {
399 mem_clear(mem);
400 return finish(mem);
401 }
402
403 oop ObjBufferAllocator::initialize(HeapWord* mem) const {
404 mem_clear(mem);
405 return finish(mem);
406 }
407
408
409 oop ObjArrayAllocator::initialize(HeapWord* mem) const {
410 // Set array length before setting the _klass field because a
411 // non-null klass field indicates that the object is parsable by
412 // concurrent GC.
413 assert(_length >= 0, "length should be non-negative");
414 if (_do_zero) {
415 mem_clear(mem);
416 mem_zap_start_padding(mem);
417 mem_zap_end_padding(mem);
418 }
419 arrayOopDesc::set_length(mem, _length);
420 return finish(mem);
421 }
422
423 #ifndef PRODUCT
424 void ObjArrayAllocator::mem_zap_start_padding(HeapWord* mem) const {
425 const BasicType element_type = ArrayKlass::cast(_klass)->element_type();
426 const size_t base_offset_in_bytes = arrayOopDesc::base_offset_in_bytes(element_type);
427 const size_t header_size_in_bytes = arrayOopDesc::header_size_in_bytes();
428
|