--- old/hotspot/src/share/vm/oops/arrayOop.hpp	2009-08-01 04:12:40.094832899 +0100
+++ new/hotspot/src/share/vm/oops/arrayOop.hpp	2009-08-01 04:12:40.012110729 +0100
@@ -2,7 +2,7 @@
 #pragma ident "@(#)arrayOop.hpp	1.35 07/05/05 17:06:00 JVM"
 #endif
 /*
- * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,49 +25,94 @@
  *  
  */
 
-// arrayOopDesc is the abstract baseclass for all arrays.
+// arrayOopDesc is the abstract baseclass for all arrays.  It doesn't
+// declare pure virtual to enforce this because that would allocate a vtbl
+// in each instance, which we don't want.
+
+// The layout of array Oops is:
+//
+//  markOop
+//  klassOop  // 32 bits if compressed but declared 64 in LP64.
+//  length    // shares klass memory or allocated after declared fields.
+
 
 class arrayOopDesc : public oopDesc {
   friend class VMStructs;
- private:
-  int _length; // number of elements in the array
 
- public:
   // Interpreter/Compiler offsets
-  static int length_offset_in_bytes()             { return offset_of(arrayOopDesc, _length); }
-  static int base_offset_in_bytes(BasicType type) { return header_size(type) * HeapWordSize; }
+
+  // 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() {
+    size_t hs = align_size_up(length_offset_in_bytes() + sizeof(int),
+                              HeapWordSize);
+#ifdef ASSERT
+    // make sure it isn't called before UseCompressedOops is initialized.
+    static size_t arrayoopdesc_hs = 0;
+    if (arrayoopdesc_hs == 0) arrayoopdesc_hs = hs;
+    assert(arrayoopdesc_hs == hs, "header size can't change");
+#endif // ASSERT
+    return (int)hs;
+  }
+
+ public:
+  // The _length field is not declared in C++.  It is allocated after the
+  // declared nonstatic fields in arrayOopDesc if not compressed, otherwise
+  // it occupies the second half of the _klass field in oopDesc.
+  static int length_offset_in_bytes() {
+    return UseCompressedOops ? klass_gap_offset_in_bytes() :
+                               sizeof(arrayOopDesc);
+  }
+
+  // Returns the offset of the first element.
+  static int base_offset_in_bytes(BasicType type) {
+    return header_size(type) * HeapWordSize;
+  }
 
   // Returns the address of the first element.
-  void* base(BasicType type) const              { return (void*) (((intptr_t) this) + base_offset_in_bytes(type)); }
+  void* base(BasicType type) const {
+    return (void*) (((intptr_t) this) + base_offset_in_bytes(type));
+  }
 
   // Tells whether index is within bounds.
   bool is_within_bounds(int index) const	{ return 0 <= index && index < length(); }
 
-  // Accessores for instance variable
-  int length() const				{ return _length;   }
-  void set_length(int length)			{ _length = length; }
+  // Accessors for instance variable which is not a C++ declared nonstatic
+  // field.
+  int length() const {
+    return *(int*)(((intptr_t)this) + length_offset_in_bytes());
+  }
+  void set_length(int length) {
+    *(int*)(((intptr_t)this) + length_offset_in_bytes()) = length;
+  }
 
-  // Header size computation. 
-  // Should only be called with constants as argument (will not constant fold otherwise)
+  // Should only be called with constants as argument
+  // (will not constant fold otherwise)
+  // Returns the header size in words aligned to the requirements of the
+  // array object type.
   static int header_size(BasicType type) {
-    return Universe::element_type_should_be_aligned(type) 
-      ? align_object_size(sizeof(arrayOopDesc)/HeapWordSize) 
-      : sizeof(arrayOopDesc)/HeapWordSize; 
+    size_t typesize_in_bytes = header_size_in_bytes();
+    return (int)(Universe::element_type_should_be_aligned(type)
+      ? align_object_size(typesize_in_bytes/HeapWordSize)
+      : typesize_in_bytes/HeapWordSize);
   }
 
-  // This method returns the  maximum length that can passed into
-  // typeArrayOop::object_size(scale, length, header_size) without causing an
-  // overflow. We substract an extra 2*wordSize to guard against double word
-  // alignments.  It gets the scale from the type2aelembytes array.
-  static int32_t max_array_length(BasicType type) { 
+  // 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.
+  static int32_t max_array_length(BasicType type) {
     assert(type >= 0 && type < T_CONFLICT, "wrong type");
-    assert(type2aelembytes[type] != 0, "wrong type");
-    // We use max_jint, since object_size is internally represented by an 'int'
-    // This gives us an upper bound of max_jint words for the size of the oop.
-    int32_t max_words = (max_jint - header_size(type) - 2);
-    int elembytes = (type == T_OBJECT) ? T_OBJECT_aelem_bytes : type2aelembytes[type]; 
-    jlong len = ((jlong)max_words * HeapWordSize) / elembytes;
-    return (len > max_jint) ? max_jint : (int32_t)len;
+    assert(type2aelembytes(type) != 0, "wrong type");
+    const int bytes_per_element = type2aelembytes(type);
+    if (bytes_per_element < HeapWordSize) {
+      return max_jint;
+    }
+
+    const int32_t max_words = align_size_down(max_jint, MinObjAlignment);
+    const int32_t max_element_words = max_words - header_size(type);
+    const int32_t words_per_element = bytes_per_element >> LogHeapWordSize;
+    return max_element_words / words_per_element;
   }
-
 };