src/share/vm/utilities/array.hpp

*** 23,32 ****
--- 23,33 ----
   */
  
  #ifndef SHARE_VM_UTILITIES_ARRAY_HPP
  #define SHARE_VM_UTILITIES_ARRAY_HPP
  
+ #include "classfile/classLoaderData.hpp"
  #include "memory/allocation.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/metaspace.hpp"
  #include "runtime/orderAccess.hpp"
  
*** 303,312 ****
--- 304,314 ----
  template <typename T>
  class Array: public MetaspaceObj {
    friend class MetadataFactory;
    friend class VMStructs;
    friend class MethodHandleCompiler;           // special case
+   friend class WhiteBox;
  protected:
    int _length;                                 // the number of array elements
    T   _data[1];                                // the array memory
  
    void initialize(int length) {
*** 324,333 ****
--- 326,358 ----
                                         MetaspaceObj::array_type(sizeof(T)), CHECK_NULL);
    }
  
    static size_t byte_sizeof(int length) { return sizeof(Array<T>) + MAX2(length - 1, 0) * sizeof(T); }
  
+   // WhiteBox API helper.
+   static int bytes_to_length(size_t bytes)       {
+     assert(is_size_aligned(bytes, BytesPerWord), "Must be, for now");
+ 
+     if (sizeof(Array<T>) >= bytes) {
+       return 0;
+     }
+ 
+     size_t left = bytes - sizeof(Array<T>);
+     assert(is_size_aligned(left, sizeof(T)), "Must be");
+ 
+     size_t elements = left / sizeof(T);
+     assert(elements <= (size_t)INT_MAX, err_msg("number of elements " SIZE_FORMAT "doesn't fit into an int.", elements));
+ 
+     int length = (int)elements;
+ 
+     assert((size_t)size(length) * BytesPerWord == bytes,
+         err_msg("Expected: " SIZE_FORMAT " got: " SIZE_FORMAT,
+                 bytes, (size_t)size(length) * BytesPerWord));
+ 
+     return length;
+   }
+ 
    explicit Array(int length) : _length(length) {
      assert(length >= 0, "illegal length");
    }
  
    Array(int length, T init) : _length(length) {