--- old/src/hotspot/share/oops/valueArrayKlass.cpp	2019-03-27 16:10:46.683307117 +0100
+++ new/src/hotspot/share/oops/valueArrayKlass.cpp	2019-03-27 16:10:46.379302086 +0100
@@ -99,14 +99,14 @@
     Klass* element_super = element_klass->super();
     if (element_super != NULL) {
       // The element type has a direct super.  E.g., String[] has direct super of Object[].
-      super_klass = element_super->array_klass_or_null();
+      super_klass = element_super->array_klass_or_null(ArrayStorageProperties::empty);
       bool supers_exist = super_klass != NULL;
       // Also, see if the element has secondary supertypes.
       // We need an array type for each.
       Array<Klass*>* element_supers = element_klass->secondary_supers();
       for( int i = element_supers->length()-1; i >= 0; i-- ) {
         Klass* elem_super = element_supers->at(i);
-        if (elem_super->array_klass_or_null() == NULL) {
+        if (elem_super->array_klass_or_null(ArrayStorageProperties::empty) == NULL) {
           supers_exist = false;
           break;
         }
@@ -122,7 +122,7 @@
             elem_super->array_klass(CHECK_0);
           }
           // Now retry from the beginning
-          ek = element_klass->array_klass(1, CHECK_0);
+          ek = element_klass->array_klass(ArrayStorageProperties::flattened_and_null_free, 1, CHECK_0);
         }  // re-lock
         return ValueArrayKlass::cast(ek);
       }
@@ -146,8 +146,9 @@
   return vak;
 }
 
-ValueArrayKlass* ValueArrayKlass::allocate_klass(Klass* element_klass, TRAPS) {
-  Symbol* name = ArrayKlass::create_element_klass_array_name(element_klass, CHECK_NULL);
+ValueArrayKlass* ValueArrayKlass::allocate_klass(ArrayStorageProperties storage_props, Klass* element_klass, TRAPS) {
+  assert(storage_props.is_flattened(), "Expected flat storage");
+  Symbol* name = ArrayKlass::create_element_klass_array_name(true, element_klass, CHECK_NULL);
   return allocate_klass(element_klass, name, THREAD);
 }
 
@@ -321,8 +322,8 @@
 }
 
 
-Klass* ValueArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
-
+Klass* ValueArrayKlass::array_klass_impl(ArrayStorageProperties storage_props, bool or_null, int n, TRAPS) {
+  assert(storage_props.is_flattened() || n > 1, "Expected flat storage");
   assert(dimension() <= n, "check order of chain");
   int dim = dimension();
   if (dim == n) return this;
@@ -341,7 +342,7 @@
 
         // Create multi-dim klass object and link them together
         Klass* k =
-          ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
+          ObjArrayKlass::allocate_objArray_klass(storage_props, dim + 1, this, CHECK_NULL);
         ObjArrayKlass* ak = ObjArrayKlass::cast(k);
         ak->set_lower_dimension(this);
         OrderAccess::storestore();
@@ -355,13 +356,13 @@
 
   ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension());
   if (or_null) {
-    return ak->array_klass_or_null(n);
+    return ak->array_klass_or_null(storage_props, n);
   }
-  return ak->array_klass(n, THREAD);
+  return ak->array_klass(storage_props, n, THREAD);
 }
 
-Klass* ValueArrayKlass::array_klass_impl(bool or_null, TRAPS) {
-  return array_klass_impl(or_null, dimension() +  1, THREAD);
+Klass* ValueArrayKlass::array_klass_impl(ArrayStorageProperties storage_props, bool or_null, TRAPS) {
+  return array_klass_impl(storage_props, or_null, dimension() +  1, THREAD);
 }
 
 ModuleEntry* ValueArrayKlass::module() const {
@@ -396,7 +397,7 @@
     secondaries->push(SystemDictionary::Serializable_klass());
     for (int i = 0; i < num_elem_supers; i++) {
       Klass* elem_super = (Klass*) elem_supers->at(i);
-      Klass* array_super = elem_super->array_klass_or_null();
+      Klass* array_super = elem_super->array_klass_or_null(ArrayStorageProperties::empty);
       assert(array_super != NULL, "must already have been created");
       secondaries->push(array_super);
     }