src/hotspot/share/cds/aotMappedHeapWriter.cpp

@@ -41,10 +41,11 @@
  #include "oops/objArrayOop.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "oops/oopHandle.inline.hpp"
  #include "oops/typeArrayKlass.hpp"
  #include "oops/typeArrayOop.hpp"
+ #include "runtime/arguments.hpp"
  #include "runtime/java.hpp"
  #include "runtime/mutexLocker.hpp"
  #include "utilities/bitMap.inline.hpp"
  #if INCLUDE_G1GC
  #include "gc/g1/g1CollectedHeap.hpp"

@@ -292,16 +293,17 @@
    _buffer->at_grow(to_array_index(min_bytes));
  }
  
  objArrayOop AOTMappedHeapWriter::allocate_root_segment(size_t offset, int element_count) {
    HeapWord* mem = offset_to_buffered_address<HeapWord *>(offset);
-   memset(mem, 0, objArrayOopDesc::object_size(element_count));
+   memset(mem, 0, refArrayOopDesc::object_size(element_count));
  
    // The initialization code is copied from MemAllocator::finish and ObjArrayAllocator::initialize.
    if (UseCompactObjectHeaders) {
      oopDesc::release_set_mark(mem, Universe::objectArrayKlass()->prototype_header());
    } else {
+     assert(!Arguments::is_valhalla_enabled() || Universe::objectArrayKlass()->prototype_header() == markWord::prototype(), "should be the same");
      oopDesc::set_mark(mem, markWord::prototype());
      oopDesc::release_set_klass(mem, Universe::objectArrayKlass());
    }
    arrayOopDesc::set_length(mem, element_count);
    return objArrayOop(cast_to_oop(mem));

@@ -328,11 +330,11 @@
  
    assert((_buffer_used % MIN_GC_REGION_ALIGNMENT) == 0,
           "Pre-condition: Roots start at aligned boundary: %zu", _buffer_used);
  
    int max_elem_count = ((MIN_GC_REGION_ALIGNMENT - arrayOopDesc::header_size_in_bytes()) / heapOopSize);
-   assert(objArrayOopDesc::object_size(max_elem_count)*HeapWordSize == MIN_GC_REGION_ALIGNMENT,
+   assert(refArrayOopDesc::object_size(max_elem_count)*HeapWordSize == MIN_GC_REGION_ALIGNMENT,
           "Should match exactly");
  
    HeapRootSegments segments(_buffer_used,
                              roots->length(),
                              MIN_GC_REGION_ALIGNMENT,

@@ -443,11 +445,11 @@
    log_info(aot)("Size of heap region = %zu bytes, %d objects, %d roots, %d native ptrs",
                  _buffer_used, _source_objs->length() + 1, roots->length(), _num_native_ptrs);
  }
  
  size_t AOTMappedHeapWriter::filler_array_byte_size(int length) {
-   size_t byte_size = objArrayOopDesc::object_size(length) * HeapWordSize;
+   size_t byte_size = refArrayOopDesc::object_size(length) * HeapWordSize;
    return byte_size;
  }
  
  int AOTMappedHeapWriter::filler_array_length(size_t fill_bytes) {
    assert(is_object_aligned(fill_bytes), "must be");

@@ -472,10 +474,11 @@
    memset(mem, 0, fill_bytes);
    narrowKlass nk = ArchiveBuilder::current()->get_requested_narrow_klass(oak);
    if (UseCompactObjectHeaders) {
      oopDesc::release_set_mark(mem, markWord::prototype().set_narrow_klass(nk));
    } else {
+     assert(!Arguments::is_valhalla_enabled() || Universe::objectArrayKlass()->prototype_header() == markWord::prototype(), "should be the same");
      oopDesc::set_mark(mem, markWord::prototype());
      cast_to_oop(mem)->set_narrow_klass(nk);
    }
    arrayOopDesc::set_length(mem, array_length);
    return mem;

@@ -726,24 +729,27 @@
    narrowKlass nk = ArchiveBuilder::current()->get_requested_narrow_klass(src_klass);
    address buffered_addr = requested_addr_to_buffered_addr(cast_from_oop<address>(requested_obj));
  
    oop fake_oop = cast_to_oop(buffered_addr);
    if (UseCompactObjectHeaders) {
-     fake_oop->set_mark(markWord::prototype().set_narrow_klass(nk));
+     markWord prototype_header = src_klass->prototype_header().set_narrow_klass(nk);
+     fake_oop->set_mark(prototype_header);
    } else {
      fake_oop->set_narrow_klass(nk);
    }
  
    if (src_obj == nullptr) {
      return;
    }
    // We need to retain the identity_hash, because it may have been used by some hashtables
    // in the shared heap.
-   if (!src_obj->fast_no_hash_check()) {
+   if (!src_obj->fast_no_hash_check() && (!(Arguments::is_valhalla_enabled() && src_obj->mark().is_inline_type()))) {
      intptr_t src_hash = src_obj->identity_hash();
      if (UseCompactObjectHeaders) {
-       fake_oop->set_mark(markWord::prototype().set_narrow_klass(nk).copy_set_hash(src_hash));
+       fake_oop->set_mark(fake_oop->mark().copy_set_hash(src_hash));
+     } else if (Arguments::is_valhalla_enabled()) {
+       fake_oop->set_mark(src_klass->prototype_header().copy_set_hash(src_hash));
      } else {
        fake_oop->set_mark(markWord::prototype().copy_set_hash(src_hash));
      }
      assert(fake_oop->mark().is_unlocked(), "sanity");