src/hotspot/share/memory/oopFactory.cpp

@@ -27,15 +27,21 @@
  #include "classfile/vmSymbols.hpp"
  #include "gc/shared/collectedHeap.inline.hpp"
  #include "memory/oopFactory.hpp"
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
+ #include "oops/arrayKlass.hpp"
+ #include "oops/flatArrayKlass.hpp"
+ #include "oops/flatArrayOop.hpp"
+ #include "oops/flatArrayOop.inline.hpp"
  #include "oops/instanceKlass.hpp"
  #include "oops/instanceOop.hpp"
  #include "oops/objArrayKlass.hpp"
  #include "oops/objArrayOop.hpp"
+ #include "oops/objArrayOop.inline.hpp"
  #include "oops/oop.inline.hpp"
+ #include "oops/refArrayKlass.hpp"
  #include "oops/typeArrayKlass.hpp"
  #include "oops/typeArrayOop.inline.hpp"
  #include "runtime/handles.inline.hpp"
  #include "utilities/utf8.hpp"
  

@@ -71,11 +77,11 @@
    return Universe::longArrayKlass()->allocate_instance(length, THREAD);
  }
  
  // create java.lang.Object[]
  objArrayOop oopFactory::new_objectArray(int length, TRAPS)  {
-   return Universe::objectArrayKlass()->allocate_instance(length, THREAD);
+   return Universe::objectArrayKlass()->allocate_instance(length, ArrayKlass::ArrayProperties::DEFAULT, THREAD);
  }
  
  typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {
    int length = utf8_str == nullptr ? 0 : UTF8::unicode_length(utf8_str);
    typeArrayOop result = new_charArray(length, CHECK_NULL);

@@ -102,17 +108,39 @@
  typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) {
    TypeArrayKlass* klass = Universe::typeArrayKlass(type);
    return klass->allocate_common(length, false, THREAD);
  }
  
+ objArrayOop oopFactory::new_objArray(Klass* klass, int length, ArrayKlass::ArrayProperties properties, TRAPS) {
+   assert(!klass->is_array_klass() || properties == ArrayKlass::ArrayProperties::DEFAULT, "properties only apply to single dimension arrays");
+   ArrayKlass* ak = klass->array_klass(CHECK_NULL);
+   return ObjArrayKlass::cast(ak)->allocate_instance(length, properties, THREAD);
+ }
+ 
+ objArrayOop oopFactory::new_refArray(Klass* array_klass, int length, TRAPS) {
+   RefArrayKlass* rak = RefArrayKlass::cast(array_klass);  // asserts is refArray_klass().
+   return rak->allocate_instance(length, rak->properties(), THREAD);
+ }
  
  objArrayOop oopFactory::new_objArray(Klass* klass, int length, TRAPS) {
-   if (klass->is_array_klass()) {
-     return ArrayKlass::cast(klass)->allocate_arrayArray(1, length, THREAD);
-   } else {
-     return InstanceKlass::cast(klass)->allocate_objArray(1, length, THREAD);
-   }
+   return  new_objArray(klass, length, ArrayKlass::ArrayProperties::DEFAULT, THREAD);
+ }
+ 
+ flatArrayOop oopFactory::new_flatArray(Klass* k, int length, ArrayKlass::ArrayProperties props, LayoutKind lk, TRAPS) {
+   InlineKlass* klass = InlineKlass::cast(k);
+ 
+   ArrayKlass* array_type = klass->array_klass(CHECK_NULL);
+   ObjArrayKlass* oak = ObjArrayKlass::cast(array_type)->klass_with_properties(props, CHECK_NULL);
+ 
+   assert(oak->is_flatArray_klass(), "Expected to be");
+   assert(FlatArrayKlass::cast(oak)->layout_kind() == lk, "Unexpected layout kind");
+ 
+   flatArrayOop oop = (flatArrayOop)FlatArrayKlass::cast(oak)->allocate_instance(length, props, CHECK_NULL);
+   assert(oop == nullptr || oop->is_flatArray(), "sanity");
+   assert(oop == nullptr || oop->klass()->is_flatArray_klass(), "sanity");
+ 
+   return oop;
  }
  
  objArrayHandle oopFactory::new_objArray_handle(Klass* klass, int length, TRAPS) {
    objArrayOop obj = new_objArray(klass, length, CHECK_(objArrayHandle()));
    return objArrayHandle(THREAD, obj);