< prev index next >

src/share/vm/oops/arrayOop.hpp

Print this page




  33 // in each instance, which we don't want.
  34 
  35 // The layout of array Oops is:
  36 //
  37 //  markOop
  38 //  Klass*    // 32 bits if compressed but declared 64 in LP64.
  39 //  length    // shares klass memory or allocated after declared fields.
  40 
  41 
  42 class arrayOopDesc : public oopDesc {
  43   friend class VMStructs;
  44   friend class arrayOopDescTest;
  45 
  46   // Interpreter/Compiler offsets
  47 
  48   // Header size computation.
  49   // The header is considered the oop part of this type plus the length.
  50   // Returns the aligned header_size_in_bytes.  This is not equivalent to
  51   // sizeof(arrayOopDesc) which should not appear in the code.
  52   static int header_size_in_bytes() {
  53     size_t hs = align_size_up(length_offset_in_bytes() + sizeof(int),
  54                               HeapWordSize);
  55 #ifdef ASSERT
  56     // make sure it isn't called before UseCompressedOops is initialized.
  57     static size_t arrayoopdesc_hs = 0;
  58     if (arrayoopdesc_hs == 0) arrayoopdesc_hs = hs;
  59     assert(arrayoopdesc_hs == hs, "header size can't change");
  60 #endif // ASSERT
  61     return (int)hs;
  62   }
  63 
  64  public:
  65   // The _length field is not declared in C++.  It is allocated after the
  66   // declared nonstatic fields in arrayOopDesc if not compressed, otherwise
  67   // it occupies the second half of the _klass field in oopDesc.
  68   static int length_offset_in_bytes() {
  69     return UseCompressedClassPointers ? klass_gap_offset_in_bytes() :
  70                                sizeof(arrayOopDesc);
  71   }
  72 
  73   // Returns the offset of the first element.


  95   // Should only be called with constants as argument
  96   // (will not constant fold otherwise)
  97   // Returns the header size in words aligned to the requirements of the
  98   // array object type.
  99   static int header_size(BasicType type) {
 100     size_t typesize_in_bytes = header_size_in_bytes();
 101     return (int)(Universe::element_type_should_be_aligned(type)
 102       ? align_object_offset(typesize_in_bytes/HeapWordSize)
 103       : typesize_in_bytes/HeapWordSize);
 104   }
 105 
 106   // Return the maximum length of an array of BasicType.  The length can passed
 107   // to typeArrayOop::object_size(scale, length, header_size) without causing an
 108   // overflow. We also need to make sure that this will not overflow a size_t on
 109   // 32 bit platforms when we convert it to a byte size.
 110   static int32_t max_array_length(BasicType type) {
 111     assert(type >= 0 && type < T_CONFLICT, "wrong type");
 112     assert(type2aelembytes(type) != 0, "wrong type");
 113 
 114     const size_t max_element_words_per_size_t =
 115       align_size_down((SIZE_MAX/HeapWordSize - header_size(type)), MinObjAlignment);
 116     const size_t max_elements_per_size_t =
 117       HeapWordSize * max_element_words_per_size_t / type2aelembytes(type);
 118     if ((size_t)max_jint < max_elements_per_size_t) {
 119       // It should be ok to return max_jint here, but parts of the code
 120       // (CollectedHeap, Klass::oop_oop_iterate(), and more) uses an int for
 121       // passing around the size (in words) of an object. So, we need to avoid
 122       // overflowing an int when we add the header. See CRs 4718400 and 7110613.
 123       return align_size_down(max_jint - header_size(type), MinObjAlignment);
 124     }
 125     return (int32_t)max_elements_per_size_t;
 126   }
 127 
 128 };
 129 
 130 #endif // SHARE_VM_OOPS_ARRAYOOP_HPP


  33 // in each instance, which we don't want.
  34 
  35 // The layout of array Oops is:
  36 //
  37 //  markOop
  38 //  Klass*    // 32 bits if compressed but declared 64 in LP64.
  39 //  length    // shares klass memory or allocated after declared fields.
  40 
  41 
  42 class arrayOopDesc : public oopDesc {
  43   friend class VMStructs;
  44   friend class arrayOopDescTest;
  45 
  46   // Interpreter/Compiler offsets
  47 
  48   // Header size computation.
  49   // The header is considered the oop part of this type plus the length.
  50   // Returns the aligned header_size_in_bytes.  This is not equivalent to
  51   // sizeof(arrayOopDesc) which should not appear in the code.
  52   static int header_size_in_bytes() {
  53     size_t hs = align_up(length_offset_in_bytes() + sizeof(int),
  54                               HeapWordSize);
  55 #ifdef ASSERT
  56     // make sure it isn't called before UseCompressedOops is initialized.
  57     static size_t arrayoopdesc_hs = 0;
  58     if (arrayoopdesc_hs == 0) arrayoopdesc_hs = hs;
  59     assert(arrayoopdesc_hs == hs, "header size can't change");
  60 #endif // ASSERT
  61     return (int)hs;
  62   }
  63 
  64  public:
  65   // The _length field is not declared in C++.  It is allocated after the
  66   // declared nonstatic fields in arrayOopDesc if not compressed, otherwise
  67   // it occupies the second half of the _klass field in oopDesc.
  68   static int length_offset_in_bytes() {
  69     return UseCompressedClassPointers ? klass_gap_offset_in_bytes() :
  70                                sizeof(arrayOopDesc);
  71   }
  72 
  73   // Returns the offset of the first element.


  95   // Should only be called with constants as argument
  96   // (will not constant fold otherwise)
  97   // Returns the header size in words aligned to the requirements of the
  98   // array object type.
  99   static int header_size(BasicType type) {
 100     size_t typesize_in_bytes = header_size_in_bytes();
 101     return (int)(Universe::element_type_should_be_aligned(type)
 102       ? align_object_offset(typesize_in_bytes/HeapWordSize)
 103       : typesize_in_bytes/HeapWordSize);
 104   }
 105 
 106   // Return the maximum length of an array of BasicType.  The length can passed
 107   // to typeArrayOop::object_size(scale, length, header_size) without causing an
 108   // overflow. We also need to make sure that this will not overflow a size_t on
 109   // 32 bit platforms when we convert it to a byte size.
 110   static int32_t max_array_length(BasicType type) {
 111     assert(type >= 0 && type < T_CONFLICT, "wrong type");
 112     assert(type2aelembytes(type) != 0, "wrong type");
 113 
 114     const size_t max_element_words_per_size_t =
 115       align_down((SIZE_MAX/HeapWordSize - header_size(type)), MinObjAlignment);
 116     const size_t max_elements_per_size_t =
 117       HeapWordSize * max_element_words_per_size_t / type2aelembytes(type);
 118     if ((size_t)max_jint < max_elements_per_size_t) {
 119       // It should be ok to return max_jint here, but parts of the code
 120       // (CollectedHeap, Klass::oop_oop_iterate(), and more) uses an int for
 121       // passing around the size (in words) of an object. So, we need to avoid
 122       // overflowing an int when we add the header. See CRs 4718400 and 7110613.
 123       return align_down(max_jint - header_size(type), MinObjAlignment);
 124     }
 125     return (int32_t)max_elements_per_size_t;
 126   }
 127 
 128 };
 129 
 130 #endif // SHARE_VM_OOPS_ARRAYOOP_HPP
< prev index next >