365 oop MemAllocator::allocate() const {
366   oop obj = nullptr;
367   {
368     Allocation allocation(*this, &obj);
369     HeapWord* mem = mem_allocate(allocation);
370     if (mem != nullptr) {
371       obj = initialize(mem);
372     } else {
373       // The unhandled oop detector will poison local variable obj,
374       // so reset it to null if mem is null.
375       obj = nullptr;
376     }
377   }
378   return obj;
379 }
380 
381 void MemAllocator::mem_clear(HeapWord* mem) const {
382   assert(mem != nullptr, "cannot initialize null object");
383   const size_t hs = oopDesc::header_size();
384   assert(_word_size >= hs, "unexpected object size");
385   oopDesc::set_klass_gap(mem, 0);


386   Copy::fill_to_aligned_words(mem + hs, _word_size - hs);
387 }
388 
389 oop MemAllocator::finish(HeapWord* mem) const {
390   assert(mem != nullptr, "null object pointer");
391   // May be bootstrapping
392   oopDesc::set_mark(mem, markWord::prototype());
393   // Need a release store to ensure array/class length, mark word, and
394   // object zeroing are visible before setting the klass non-null, for
395   // concurrent collectors.
396   oopDesc::release_set_klass(mem, _klass);





397   return cast_to_oop(mem);
398 }
399 
400 oop ObjAllocator::initialize(HeapWord* mem) const {
401   mem_clear(mem);
402   return finish(mem);
403 }
404 
405 oop ObjArrayAllocator::initialize(HeapWord* mem) const {
406   // Set array length before setting the _klass field because a
407   // non-null klass field indicates that the object is parsable by
408   // concurrent GC.
409   assert(_length >= 0, "length should be non-negative");
410   if (_do_zero) {
411     mem_clear(mem);
412     mem_zap_end_padding(mem);
413   }
414   arrayOopDesc::set_length(mem, _length);
415   return finish(mem);
416 }

365 oop MemAllocator::allocate() const {
366   oop obj = nullptr;
367   {
368     Allocation allocation(*this, &obj);
369     HeapWord* mem = mem_allocate(allocation);
370     if (mem != nullptr) {
371       obj = initialize(mem);
372     } else {
373       // The unhandled oop detector will poison local variable obj,
374       // so reset it to null if mem is null.
375       obj = nullptr;
376     }
377   }
378   return obj;
379 }
380 
381 void MemAllocator::mem_clear(HeapWord* mem) const {
382   assert(mem != nullptr, "cannot initialize null object");
383   const size_t hs = oopDesc::header_size();
384   assert(_word_size >= hs, "unexpected object size");
385   if (!UseCompactObjectHeaders) {
386     oopDesc::set_klass_gap(mem, 0);
387   }
388   Copy::fill_to_aligned_words(mem + hs, _word_size - hs);
389 }
390 
391 oop MemAllocator::finish(HeapWord* mem) const {
392   assert(mem != nullptr, "null object pointer");


393   // Need a release store to ensure array/class length, mark word, and
394   // object zeroing are visible before setting the klass non-null, for
395   // concurrent collectors.
396   if (UseCompactObjectHeaders) {
397     oopDesc::release_set_mark(mem, _klass->prototype_header());
398   } else {
399     oopDesc::set_mark(mem, markWord::prototype());
400     oopDesc::release_set_klass(mem, _klass);
401   }
402   return cast_to_oop(mem);
403 }
404 
405 oop ObjAllocator::initialize(HeapWord* mem) const {
406   mem_clear(mem);
407   return finish(mem);
408 }
409 
410 oop ObjArrayAllocator::initialize(HeapWord* mem) const {
411   // Set array length before setting the _klass field because a
412   // non-null klass field indicates that the object is parsable by
413   // concurrent GC.
414   assert(_length >= 0, "length should be non-negative");
415   if (_do_zero) {
416     mem_clear(mem);
417     mem_zap_end_padding(mem);
418   }
419   arrayOopDesc::set_length(mem, _length);
420   return finish(mem);
421 }