array.cc revision 4f6ad8ab428038129b2d0d6c40b7fd625cca15e1
1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "array.h" 18 19#include "class.h" 20#include "class-inl.h" 21#include "dex_file-inl.h" 22#include "gc/card_table-inl.h" 23#include "object-inl.h" 24#include "object_array.h" 25#include "object_array-inl.h" 26#include "object_utils.h" 27#include "sirt_ref.h" 28#include "thread.h" 29#include "utils.h" 30 31namespace art { 32namespace mirror { 33 34Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count, 35 size_t component_size) { 36 DCHECK(array_class != NULL); 37 DCHECK_GE(component_count, 0); 38 DCHECK(array_class->IsArrayClass()); 39 40 size_t header_size = sizeof(Object) + (component_size == sizeof(int64_t) ? 8 : 4); 41 size_t data_size = component_count * component_size; 42 size_t size = header_size + data_size; 43 44 // Check for overflow and throw OutOfMemoryError if this was an unreasonable request. 45 size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size); 46 if (data_size >> component_shift != size_t(component_count) || size < data_size) { 47 self->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;", 48 "%s of length %d would overflow", 49 PrettyDescriptor(array_class).c_str(), component_count); 50 return NULL; 51 } 52 53 Heap* heap = Runtime::Current()->GetHeap(); 54 Array* array = down_cast<Array*>(heap->AllocObject(self, array_class, size)); 55 if (array != NULL) { 56 DCHECK(array->IsArrayInstance()); 57 array->SetLength(component_count); 58 } 59 return array; 60} 61 62Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count) { 63 DCHECK(array_class->IsArrayClass()); 64 return Alloc(self, array_class, component_count, array_class->GetComponentSize()); 65} 66 67// Create a multi-dimensional array of Objects or primitive types. 68// 69// We have to generate the names for X[], X[][], X[][][], and so on. The 70// easiest way to deal with that is to create the full name once and then 71// subtract pieces off. Besides, we want to start with the outermost 72// piece and work our way in. 73// Recursively create an array with multiple dimensions. Elements may be 74// Objects or primitive types. 75static Array* RecursiveCreateMultiArray(Thread* self, Class* array_class, int current_dimension, 76 IntArray* dimensions) 77 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 78 int32_t array_length = dimensions->Get(current_dimension); 79 SirtRef<Array> new_array(self, Array::Alloc(self, array_class, array_length)); 80 if (UNLIKELY(new_array.get() == NULL)) { 81 CHECK(self->IsExceptionPending()); 82 return NULL; 83 } 84 if ((current_dimension + 1) < dimensions->GetLength()) { 85 // Create a new sub-array in every element of the array. 86 for (int32_t i = 0; i < array_length; i++) { 87 Array* sub_array = RecursiveCreateMultiArray(self, array_class->GetComponentType(), 88 current_dimension + 1, dimensions); 89 if (UNLIKELY(sub_array == NULL)) { 90 CHECK(self->IsExceptionPending()); 91 return NULL; 92 } 93 new_array->AsObjectArray<Array>()->Set(i, sub_array); 94 } 95 } 96 return new_array.get(); 97} 98 99Array* Array::CreateMultiArray(Thread* self, Class* element_class, IntArray* dimensions) { 100 // Verify dimensions. 101 // 102 // The caller is responsible for verifying that "dimArray" is non-null 103 // and has a length > 0 and <= 255. 104 int num_dimensions = dimensions->GetLength(); 105 DCHECK_GT(num_dimensions, 0); 106 DCHECK_LE(num_dimensions, 255); 107 108 for (int i = 0; i < num_dimensions; i++) { 109 int dimension = dimensions->Get(i); 110 if (UNLIKELY(dimension < 0)) { 111 self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", 112 "Dimension %d: %d", i, dimension); 113 return NULL; 114 } 115 } 116 117 // Generate the full name of the array class. 118 std::string descriptor(num_dimensions, '['); 119 descriptor += ClassHelper(element_class).GetDescriptor(); 120 121 // Find/generate the array class. 122 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 123 Class* array_class = class_linker->FindClass(descriptor.c_str(), element_class->GetClassLoader()); 124 if (UNLIKELY(array_class == NULL)) { 125 CHECK(self->IsExceptionPending()); 126 return NULL; 127 } 128 // create the array 129 Array* new_array = RecursiveCreateMultiArray(self, array_class, 0, dimensions); 130 if (UNLIKELY(new_array == NULL)) { 131 CHECK(self->IsExceptionPending()); 132 return NULL; 133 } 134 return new_array; 135} 136 137bool Array::ThrowArrayIndexOutOfBoundsException(int32_t index) const { 138 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;", 139 "length=%i; index=%i", length_, index); 140 return false; 141} 142 143bool Array::ThrowArrayStoreException(Object* object) const { 144 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;", 145 "%s cannot be stored in an array of type %s", 146 PrettyTypeOf(object).c_str(), PrettyTypeOf(this).c_str()); 147 return false; 148} 149 150template<typename T> 151PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) { 152 DCHECK(array_class_ != NULL); 153 Array* raw_array = Array::Alloc(self, array_class_, length, sizeof(T)); 154 return down_cast<PrimitiveArray<T>*>(raw_array); 155} 156 157template <typename T> Class* PrimitiveArray<T>::array_class_ = NULL; 158 159// Explicitly instantiate all the primitive array types. 160template class PrimitiveArray<uint8_t>; // BooleanArray 161template class PrimitiveArray<int8_t>; // ByteArray 162template class PrimitiveArray<uint16_t>; // CharArray 163template class PrimitiveArray<double>; // DoubleArray 164template class PrimitiveArray<float>; // FloatArray 165template class PrimitiveArray<int32_t>; // IntArray 166template class PrimitiveArray<int64_t>; // LongArray 167template class PrimitiveArray<int16_t>; // ShortArray 168 169} // namespace mirror 170} // namespace art 171