59   }
  60   KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj());
  61 
  62   arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL);
  63   typeArrayKlass* ak = typeArrayKlass::cast(k());
  64   ak->set_name(sym);
  65   ak->set_layout_helper(array_layout_helper(type));
  66   assert(scale == (1 << ak->log2_element_size()), "scale must check out");
  67   assert(ak->oop_is_javaArray(), "sanity");
  68   assert(ak->oop_is_typeArray(), "sanity");
  69   ak->set_max_length(arrayOopDesc::max_array_length(type));
  70   assert(k()->size() > header_size(), "bad size");
  71 
  72   // Call complete_create_array_klass after all instance variables have been initialized.
  73   KlassHandle super (THREAD, k->super());
  74   complete_create_array_klass(k, super, CHECK_NULL);
  75 
  76   return k();
  77 }
  78 
  79 typeArrayOop typeArrayKlass::allocate(int length, TRAPS) {
  80   assert(log2_element_size() >= 0, "bad scale");
  81   if (length >= 0) {
  82     if (length <= max_length()) {
  83       size_t size = typeArrayOopDesc::object_size(layout_helper(), length);
  84       KlassHandle h_k(THREAD, as_klassOop());
  85       typeArrayOop t;
  86       CollectedHeap* ch = Universe::heap();



  87       t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL);

  88       assert(t->is_parsable(), "Don't publish unless parsable");
  89       return t;
  90     } else {
  91       report_java_out_of_memory("Requested array size exceeds VM limit");
  92       THROW_OOP_0(Universe::out_of_memory_error_array_size());
  93     }
  94   } else {
  95     THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
  96   }
  97 }
  98 
  99 typeArrayOop typeArrayKlass::allocate_permanent(int length, TRAPS) {
 100   if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 101   int size = typeArrayOopDesc::object_size(layout_helper(), length);
 102   KlassHandle h_k(THREAD, as_klassOop());
 103   typeArrayOop t = (typeArrayOop)
 104     CollectedHeap::permanent_array_allocate(h_k, size, length, CHECK_NULL);
 105   assert(t->is_parsable(), "Can't publish until parsable");
 106   return t;
 107 }

  59   }
  60   KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj());
  61 
  62   arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL);
  63   typeArrayKlass* ak = typeArrayKlass::cast(k());
  64   ak->set_name(sym);
  65   ak->set_layout_helper(array_layout_helper(type));
  66   assert(scale == (1 << ak->log2_element_size()), "scale must check out");
  67   assert(ak->oop_is_javaArray(), "sanity");
  68   assert(ak->oop_is_typeArray(), "sanity");
  69   ak->set_max_length(arrayOopDesc::max_array_length(type));
  70   assert(k()->size() > header_size(), "bad size");
  71 
  72   // Call complete_create_array_klass after all instance variables have been initialized.
  73   KlassHandle super (THREAD, k->super());
  74   complete_create_array_klass(k, super, CHECK_NULL);
  75 
  76   return k();
  77 }
  78 
  79 typeArrayOop typeArrayKlass::allocate_common(int length, bool nozero, TRAPS) {
  80   assert(log2_element_size() >= 0, "bad scale");
  81   if (length >= 0) {
  82     if (length <= max_length()) {
  83       size_t size = typeArrayOopDesc::object_size(layout_helper(), length);
  84       KlassHandle h_k(THREAD, as_klassOop());
  85       typeArrayOop t;
  86       CollectedHeap* ch = Universe::heap();
  87       if (nozero) {
  88         t = (typeArrayOop)CollectedHeap::array_allocate_nozero(h_k, (int)size, length, CHECK_NULL);
  89       } else {
  90         t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL);
  91       }
  92       assert(t->is_parsable(), "Don't publish unless parsable");
  93       return t;
  94     } else {
  95       report_java_out_of_memory("Requested array size exceeds VM limit");
  96       THROW_OOP_0(Universe::out_of_memory_error_array_size());
  97     }
  98   } else {
  99     THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 100   }
 101 }
 102 
 103 typeArrayOop typeArrayKlass::allocate_permanent(int length, TRAPS) {
 104   if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 105   int size = typeArrayOopDesc::object_size(layout_helper(), length);
 106   KlassHandle h_k(THREAD, as_klassOop());
 107   typeArrayOop t = (typeArrayOop)
 108     CollectedHeap::permanent_array_allocate(h_k, size, length, CHECK_NULL);
 109   assert(t->is_parsable(), "Can't publish until parsable");
 110   return t;
 111 }