src/hotspot/share/oops/typeArrayKlass.cpp

*** 93,103 ****
    return (typeArrayOop)Universe::heap()->array_allocate(this, (int)size, length,
                                                          do_zero, CHECK_NULL);
  }
  
  oop TypeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
-   // For typeArrays this is only called for the last dimension
    assert(rank == 1, "just checking");
    int length = *last_size;
    return allocate(length, THREAD);
  }
  
--- 93,102 ----
*** 169,179 ****
    size_t dst_offset = arrayOopDesc::base_offset_in_bytes(element_type()) + ((size_t)dst_pos << l2es);
    ArrayAccess<ARRAYCOPY_ATOMIC>::arraycopy<void>(s, src_offset, d, dst_offset, (size_t)length << l2es);
  }
  
  // create a klass of array holding typeArrays
! Klass* TypeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
    int dim = dimension();
    assert(dim <= n, "check order of chain");
      if (dim == n)
        return this;
  
--- 168,179 ----
    size_t dst_offset = arrayOopDesc::base_offset_in_bytes(element_type()) + ((size_t)dst_pos << l2es);
    ArrayAccess<ARRAYCOPY_ATOMIC>::arraycopy<void>(s, src_offset, d, dst_offset, (size_t)length << l2es);
  }
  
  // create a klass of array holding typeArrays
! Klass* TypeArrayKlass::array_klass_impl(ArrayStorageProperties storage_props, bool or_null, int n, TRAPS) {
!   assert(storage_props.is_empty(), "Didn't expect storage properties");
    int dim = dimension();
    assert(dim <= n, "check order of chain");
      if (dim == n)
        return this;
  
*** 187,197 ****
        // Atomic create higher dimension and link into list
        MutexLocker mu(MultiArray_lock, THREAD);
  
        if (higher_dimension() == NULL) {
          Klass* oak = ObjArrayKlass::allocate_objArray_klass(
!               class_loader_data(), dim + 1, this, CHECK_NULL);
          ObjArrayKlass* h_ak = ObjArrayKlass::cast(oak);
          h_ak->set_lower_dimension(this);
          // use 'release' to pair with lock-free load
          release_set_higher_dimension(h_ak);
          assert(h_ak->is_objArray_klass(), "incorrect initialization of ObjArrayKlass");
--- 187,197 ----
        // Atomic create higher dimension and link into list
        MutexLocker mu(MultiArray_lock, THREAD);
  
        if (higher_dimension() == NULL) {
          Klass* oak = ObjArrayKlass::allocate_objArray_klass(
!               ArrayStorageProperties::empty, dim + 1, this, CHECK_NULL);
          ObjArrayKlass* h_ak = ObjArrayKlass::cast(oak);
          h_ak->set_lower_dimension(this);
          // use 'release' to pair with lock-free load
          release_set_higher_dimension(h_ak);
          assert(h_ak->is_objArray_klass(), "incorrect initialization of ObjArrayKlass");
*** 200,216 ****
    } else {
      CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
    }
    ObjArrayKlass* h_ak = ObjArrayKlass::cast(higher_dimension());
    if (or_null) {
!     return h_ak->array_klass_or_null(n);
    }
!   return h_ak->array_klass(n, THREAD);
  }
  
! Klass* TypeArrayKlass::array_klass_impl(bool or_null, TRAPS) {
!   return array_klass_impl(or_null, dimension() +  1, THREAD);
  }
  
  int TypeArrayKlass::oop_size(oop obj) const {
    assert(obj->is_typeArray(),"must be a type array");
    typeArrayOop t = typeArrayOop(obj);
--- 200,216 ----
    } else {
      CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
    }
    ObjArrayKlass* h_ak = ObjArrayKlass::cast(higher_dimension());
    if (or_null) {
!     return h_ak->array_klass_or_null(storage_props, n);
    }
!   return h_ak->array_klass(storage_props, n, THREAD);
  }
  
! Klass* TypeArrayKlass::array_klass_impl(ArrayStorageProperties storage_props, bool or_null, TRAPS) {
!   return array_klass_impl(storage_props, or_null, dimension() +  1, THREAD);
  }
  
  int TypeArrayKlass::oop_size(oop obj) const {
    assert(obj->is_typeArray(),"must be a type array");
    typeArrayOop t = typeArrayOop(obj);