src/hotspot/share/oops/arrayOop.hpp

@@ -43,11 +43,11 @@
 class arrayOopDesc : public oopDesc {
   friend class VMStructs;
   friend class arrayOopDescTest;
 
   // Interpreter/Compiler offsets
-
+protected:
   // Header size computation.
   // The header is considered the oop part of this type plus the length.
   // Returns the aligned header_size_in_bytes.  This is not equivalent to
   // sizeof(arrayOopDesc) which should not appear in the code.
   static int header_size_in_bytes() {

@@ -64,11 +64,11 @@
 
   // Check whether an element of a typeArrayOop with the given type must be
   // aligned 0 mod 8.  The typeArrayOop itself must be aligned at least this
   // strongly.
   static bool element_type_should_be_aligned(BasicType type) {
-    return type == T_DOUBLE || type == T_LONG;
+    return type == T_DOUBLE || type == T_LONG || type == T_VALUETYPE;
   }
 
  public:
   // The _length field is not declared in C++.  It is allocated after the
   // declared nonstatic fields in arrayOopDesc if not compressed, otherwise

@@ -124,10 +124,25 @@
     return (int)(element_type_should_be_aligned(type)
       ? align_object_offset(typesize_in_bytes/HeapWordSize)
       : typesize_in_bytes/HeapWordSize);
   }
 
+  static int32_t max_array_length(int header_size, int elembytes) {
+    const size_t max_element_words_per_size_t =
+        align_down((SIZE_MAX/HeapWordSize - header_size), MinObjAlignment);
+    const size_t max_elements_per_size_t =
+        HeapWordSize * max_element_words_per_size_t / elembytes;
+    if ((size_t)max_jint < max_elements_per_size_t) {
+      // It should be ok to return max_jint here, but parts of the code
+      // (CollectedHeap, Klass::oop_oop_iterate(), and more) uses an int for
+      // passing around the size (in words) of an object. So, we need to avoid
+      // overflowing an int when we add the header. See CRs 4718400 and 7110613.
+      return align_down(max_jint - header_size, MinObjAlignment);
+    }
+    return (int32_t)max_elements_per_size_t;
+  }
+
   // Return the maximum length of an array of BasicType.  The length can passed
   // to typeArrayOop::object_size(scale, length, header_size) without causing an
   // overflow. We also need to make sure that this will not overflow a size_t on
   // 32 bit platforms when we convert it to a byte size.
   static int32_t max_array_length(BasicType type) {