java_lang_System.cc revision 54e7df1896a4066cbb9fe6f72249829f0b8c49c6
1/* 2 * Copyright (C) 2008 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 "jni_internal.h" 18#include "object.h" 19 20#include "JniConstants.h" // Last to avoid problems with LOG redefinition. 21 22/* 23 * We make guarantees about the atomicity of accesses to primitive 24 * variables. These guarantees also apply to elements of arrays. 25 * In particular, 8-bit, 16-bit, and 32-bit accesses must be atomic and 26 * must not cause "word tearing". Accesses to 64-bit array elements must 27 * either be atomic or treated as two 32-bit operations. References are 28 * always read and written atomically, regardless of the number of bits 29 * used to represent them. 30 * 31 * We can't rely on standard libc functions like memcpy(3) and memmove(3) 32 * in our implementation of System.arraycopy, because they may copy 33 * byte-by-byte (either for the full run or for "unaligned" parts at the 34 * start or end). We need to use functions that guarantee 16-bit or 32-bit 35 * atomicity as appropriate. 36 * 37 * System.arraycopy() is heavily used, so having an efficient implementation 38 * is important. The bionic libc provides a platform-optimized memory move 39 * function that should be used when possible. If it's not available, 40 * the trivial "reference implementation" versions below can be used until 41 * a proper version can be written. 42 * 43 * For these functions, The caller must guarantee that dst/src are aligned 44 * appropriately for the element type, and that n is a multiple of the 45 * element size. 46 */ 47#ifdef __BIONIC__ 48#define HAVE_MEMMOVE_WORDS 49#endif 50 51#ifdef HAVE_MEMMOVE_WORDS 52extern "C" void _memmove_words(void* dst, const void* src, size_t n); 53#define move16 _memmove_words 54#define move32 _memmove_words 55#else 56static void move16(void* dst, const void* src, size_t n) { 57 DCHECK((((uintptr_t) dst | (uintptr_t) src | n) & 0x01) == 0); 58 59 uint16_t* d = reinterpret_cast<uint16_t*>(dst); 60 const uint16_t* s = reinterpret_cast<const uint16_t*>(src); 61 62 n /= sizeof(uint16_t); 63 64 if (d < s) { 65 // Copy forwards. 66 while (n--) { 67 *d++ = *s++; 68 } 69 } else { 70 // Copy backwards. 71 d += n; 72 s += n; 73 while (n--) { 74 *--d = *--s; 75 } 76 } 77} 78 79static void move32(void* dst, const void* src, size_t n) { 80 DCHECK((((uintptr_t) dst | (uintptr_t) src | n) & 0x03) == 0); 81 82 uint32_t* d = reinterpret_cast<uint32_t*>(dst); 83 const uint32_t* s = reinterpret_cast<const uint32_t*>(src); 84 85 n /= sizeof(uint32_t); 86 87 if (d < s) { 88 // Copy forwards. 89 while (n--) { 90 *d++ = *s++; 91 } 92 } else { 93 // Copy backwards. 94 d += n; 95 s += n; 96 while (n--) { 97 *--d = *--s; 98 } 99 } 100} 101#endif // HAVE_MEMMOVE_WORDS 102 103namespace art { 104 105namespace { 106 107void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array) { 108 std::string actualType(PrettyTypeOf(array)); 109 Thread::Current()->ThrowNewException("Ljava/lang/ArrayStoreException;", "%s is not an array: %s", identifier, actualType.c_str()); 110} 111 112void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint length) { 113 Thread* self = Thread::Current(); 114 115 // Null pointer checks. 116 if (javaSrc == NULL) { 117 self->ThrowNewException("Ljava/lang/NullPointerException;", "src == null"); 118 return; 119 } 120 if (javaDst == NULL) { 121 self->ThrowNewException("Ljava/lang/NullPointerException;", "dst == null"); 122 return; 123 } 124 125 // Make sure source and destination are both arrays. 126 Object* srcObject = Decode<Object*>(env, javaSrc); 127 Object* dstObject = Decode<Object*>(env, javaDst); 128 if (!srcObject->IsArrayInstance()) { 129 ThrowArrayStoreException_NotAnArray("src", srcObject); 130 return; 131 } 132 if (!dstObject->IsArrayInstance()) { 133 ThrowArrayStoreException_NotAnArray("dst", dstObject); 134 return; 135 } 136 Array* srcArray = srcObject->AsArray(); 137 Array* dstArray = dstObject->AsArray(); 138 Class* srcComponentType = srcArray->GetClass()->GetComponentType(); 139 Class* dstComponentType = dstArray->GetClass()->GetComponentType(); 140 141 // Bounds checking. 142 if (srcPos < 0 || dstPos < 0 || length < 0 || srcPos > srcArray->GetLength() - length || dstPos > dstArray->GetLength() - length) { 143 self->ThrowNewException("Ljava/lang/ArrayIndexOutOfBoundsException;", 144 "src.length=%d srcPos=%d dst.length=%d dstPos=%d length=%d", 145 srcArray->GetLength(), srcPos, dstArray->GetLength(), dstPos, length); 146 return; 147 } 148 149 uint8_t* dstBytes = reinterpret_cast<uint8_t*>(dstArray->GetRawData()); 150 const uint8_t* srcBytes = reinterpret_cast<const uint8_t*>(srcArray->GetRawData()); 151 152 // Handle primitive arrays. 153 if (srcComponentType->IsPrimitive() || dstComponentType->IsPrimitive()) { 154 // If one of the arrays holds a primitive type the other array must hold the exact same type. 155 if (srcComponentType->IsPrimitive() != dstComponentType->IsPrimitive() || srcComponentType != dstComponentType) { 156 std::string srcType(PrettyTypeOf(srcArray)); 157 std::string dstType(PrettyTypeOf(dstArray)); 158 self->ThrowNewException("Ljava/lang/ArrayStoreException;", 159 "Incompatible types: src=%s, dst=%s", srcType.c_str(), dstType.c_str()); 160 return; 161 } 162 163 switch (srcArray->GetClass()->GetComponentSize()) { 164 case 1: 165 memmove(dstBytes + dstPos, srcBytes + srcPos, length); 166 break; 167 case 2: 168 move16(dstBytes + dstPos * 2, srcBytes + srcPos * 2, length * 2); 169 break; 170 case 4: 171 move32(dstBytes + dstPos * 4, srcBytes + srcPos * 4, length * 4); 172 break; 173 case 8: 174 // We don't need to guarantee atomicity of the entire 64-bit word. 175 move32(dstBytes + dstPos * 8, srcBytes + srcPos * 8, length * 8); 176 break; 177 default: 178 LOG(FATAL) << "Unknown primitive array type: " << PrettyTypeOf(srcArray); 179 } 180 181 return; 182 } 183 184 // Neither class is primitive. Are the types trivially compatible? 185 const int width = sizeof(Object*); 186 bool sameDimensions = srcArray->GetClass()->GetArrayRank() == dstArray->GetClass()->GetArrayRank(); 187 if (sameDimensions && srcComponentType->InstanceOf(dstComponentType)) { 188 // Yes. Bulk copy. 189 move32(dstBytes + dstPos * width, srcBytes + srcPos * width, length * width); 190 Heap::WriteBarrier(dstArray); 191 return; 192 } 193 194 // The arrays are not trivially compatible. However, we 195 // may still be able to do this if the destination object is 196 // compatible (e.g. copy Object[] to String[], but the Object 197 // being copied is actually a String). We need to copy elements 198 // one by one until something goes wrong. 199 // 200 // Because of overlapping moves, what we really want to do 201 // is compare the types and count up how many we can move, 202 // then call move32() to shift the actual data. If we just 203 // start from the front we could do a smear rather than a move. 204 205 // TODO: this idea is flawed. a malicious caller could exploit the check-use 206 // race by modifying the source array after we check but before we copy, 207 // and cause us to copy incompatible elements. 208 209 Object* const * srcObj = reinterpret_cast<Object* const *>(srcBytes + srcPos * width); 210 Class* dstClass = dstArray->GetClass(); 211 212 Class* initialElementClass = NULL; 213 if (length > 0 && srcObj[0] != NULL) { 214 initialElementClass = srcObj[0]->GetClass(); 215 if (!Class::CanPutArrayElement(initialElementClass, dstClass)) { 216 initialElementClass = NULL; 217 } 218 } 219 220 int copyCount; 221 for (copyCount = 0; copyCount < length; copyCount++) { 222 if (srcObj[copyCount] != NULL && srcObj[copyCount]->GetClass() != initialElementClass && !Class::CanPutArrayElement(srcObj[copyCount]->GetClass(), dstClass)) { 223 // Can't put this element into the array. 224 // We'll copy up to this point, then throw. 225 break; 226 } 227 } 228 229 move32(dstBytes + dstPos * width, srcBytes + srcPos * width, copyCount * width); 230 Heap::WriteBarrier(dstArray); 231 if (copyCount != length) { 232 std::string actualSrcType(PrettyTypeOf(srcObj[copyCount])); 233 std::string dstType(PrettyTypeOf(dstArray)); 234 self->ThrowNewException("Ljava/lang/ArrayStoreException;", 235 "source[%d] of type %s cannot be stored in destination array of type %s", 236 srcPos + copyCount, actualSrcType.c_str(), dstType.c_str()); 237 return; 238 } 239} 240 241jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) { 242 Object* o = Decode<Object*>(env, javaObject); 243 return static_cast<jint>(reinterpret_cast<uintptr_t>(o)); 244} 245 246JNINativeMethod gMethods[] = { 247 NATIVE_METHOD(System, arraycopy, "(Ljava/lang/Object;ILjava/lang/Object;II)V"), 248 NATIVE_METHOD(System, identityHashCode, "(Ljava/lang/Object;)I"), 249}; 250 251} // namespace 252 253void register_java_lang_System(JNIEnv* env) { 254 jniRegisterNativeMethods(env, "java/lang/System", gMethods, NELEM(gMethods)); 255} 256 257} // namespace art 258