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 "java_lang_System.h" 18 19 #include "common_throws.h" 20 #include "gc/accounting/card_table-inl.h" 21 #include "jni_internal.h" 22 #include "mirror/array.h" 23 #include "mirror/class.h" 24 #include "mirror/class-inl.h" 25 #include "mirror/object-inl.h" 26 #include "mirror/object_array-inl.h" 27 #include "scoped_fast_native_object_access.h" 28 29 namespace art { 30 31 /* 32 * We make guarantees about the atomicity of accesses to primitive variables. These guarantees 33 * also apply to elements of arrays. In particular, 8-bit, 16-bit, and 32-bit accesses must not 34 * cause "word tearing". Accesses to 64-bit array elements may be two 32-bit operations. 35 * References are never torn regardless of the number of bits used to represent them. 36 */ 37 38 static void ThrowArrayStoreException_NotAnArray(const char* identifier, mirror::Object* array) 39 SHARED_REQUIRES(Locks::mutator_lock_) { 40 std::string actualType(PrettyTypeOf(array)); 41 Thread* self = Thread::Current(); 42 self->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;", 43 "%s of type %s is not an array", identifier, actualType.c_str()); 44 } 45 46 static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, 47 jint dstPos, jint length) { 48 // The API is defined in terms of length, but length is somewhat overloaded so we use count. 49 const jint count = length; 50 ScopedFastNativeObjectAccess soa(env); 51 52 // Null pointer checks. 53 if (UNLIKELY(javaSrc == nullptr)) { 54 ThrowNullPointerException("src == null"); 55 return; 56 } 57 if (UNLIKELY(javaDst == nullptr)) { 58 ThrowNullPointerException("dst == null"); 59 return; 60 } 61 62 // Make sure source and destination are both arrays. 63 mirror::Object* srcObject = soa.Decode<mirror::Object*>(javaSrc); 64 if (UNLIKELY(!srcObject->IsArrayInstance())) { 65 ThrowArrayStoreException_NotAnArray("source", srcObject); 66 return; 67 } 68 mirror::Object* dstObject = soa.Decode<mirror::Object*>(javaDst); 69 if (UNLIKELY(!dstObject->IsArrayInstance())) { 70 ThrowArrayStoreException_NotAnArray("destination", dstObject); 71 return; 72 } 73 mirror::Array* srcArray = srcObject->AsArray(); 74 mirror::Array* dstArray = dstObject->AsArray(); 75 76 // Bounds checking. 77 if (UNLIKELY(srcPos < 0) || UNLIKELY(dstPos < 0) || UNLIKELY(count < 0) || 78 UNLIKELY(srcPos > srcArray->GetLength() - count) || 79 UNLIKELY(dstPos > dstArray->GetLength() - count)) { 80 soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;", 81 "src.length=%d srcPos=%d dst.length=%d dstPos=%d length=%d", 82 srcArray->GetLength(), srcPos, dstArray->GetLength(), dstPos, 83 count); 84 return; 85 } 86 87 mirror::Class* dstComponentType = dstArray->GetClass()->GetComponentType(); 88 mirror::Class* srcComponentType = srcArray->GetClass()->GetComponentType(); 89 Primitive::Type dstComponentPrimitiveType = dstComponentType->GetPrimitiveType(); 90 91 if (LIKELY(srcComponentType == dstComponentType)) { 92 // Trivial assignability. 93 switch (dstComponentPrimitiveType) { 94 case Primitive::kPrimVoid: 95 LOG(FATAL) << "Unreachable, cannot have arrays of type void"; 96 UNREACHABLE(); 97 case Primitive::kPrimBoolean: 98 case Primitive::kPrimByte: 99 DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 1U); 100 dstArray->AsByteSizedArray()->Memmove(dstPos, srcArray->AsByteSizedArray(), srcPos, count); 101 return; 102 case Primitive::kPrimChar: 103 case Primitive::kPrimShort: 104 DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 2U); 105 dstArray->AsShortSizedArray()->Memmove(dstPos, srcArray->AsShortSizedArray(), srcPos, count); 106 return; 107 case Primitive::kPrimInt: 108 DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 4U); 109 dstArray->AsIntArray()->Memmove(dstPos, srcArray->AsIntArray(), srcPos, count); 110 return; 111 case Primitive::kPrimFloat: 112 DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 4U); 113 dstArray->AsFloatArray()->Memmove(dstPos, srcArray->AsFloatArray(), srcPos, count); 114 return; 115 case Primitive::kPrimLong: 116 DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 8U); 117 dstArray->AsLongArray()->Memmove(dstPos, srcArray->AsLongArray(), srcPos, count); 118 return; 119 case Primitive::kPrimDouble: 120 DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 8U); 121 dstArray->AsDoubleArray()->Memmove(dstPos, srcArray->AsDoubleArray(), srcPos, count); 122 return; 123 case Primitive::kPrimNot: { 124 mirror::ObjectArray<mirror::Object>* dstObjArray = dstArray->AsObjectArray<mirror::Object>(); 125 mirror::ObjectArray<mirror::Object>* srcObjArray = srcArray->AsObjectArray<mirror::Object>(); 126 dstObjArray->AssignableMemmove(dstPos, srcObjArray, srcPos, count); 127 return; 128 } 129 default: 130 LOG(FATAL) << "Unknown array type: " << PrettyTypeOf(srcArray); 131 UNREACHABLE(); 132 } 133 } 134 // If one of the arrays holds a primitive type the other array must hold the exact same type. 135 if (UNLIKELY((dstComponentPrimitiveType != Primitive::kPrimNot) || 136 srcComponentType->IsPrimitive())) { 137 std::string srcType(PrettyTypeOf(srcArray)); 138 std::string dstType(PrettyTypeOf(dstArray)); 139 soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;", 140 "Incompatible types: src=%s, dst=%s", 141 srcType.c_str(), dstType.c_str()); 142 return; 143 } 144 // Arrays hold distinct types and so therefore can't alias - use memcpy instead of memmove. 145 mirror::ObjectArray<mirror::Object>* dstObjArray = dstArray->AsObjectArray<mirror::Object>(); 146 mirror::ObjectArray<mirror::Object>* srcObjArray = srcArray->AsObjectArray<mirror::Object>(); 147 // If we're assigning into say Object[] then we don't need per element checks. 148 if (dstComponentType->IsAssignableFrom(srcComponentType)) { 149 dstObjArray->AssignableMemcpy(dstPos, srcObjArray, srcPos, count); 150 return; 151 } 152 // This code is never run under a transaction. 153 DCHECK(!Runtime::Current()->IsActiveTransaction()); 154 dstObjArray->AssignableCheckingMemcpy<false>(dstPos, srcObjArray, srcPos, count, true); 155 } 156 157 // Template to convert general array to that of its specific primitive type. 158 template <typename T> 159 inline T* AsPrimitiveArray(mirror::Array* array) { 160 return down_cast<T*>(array); 161 } 162 163 template <typename T, Primitive::Type kPrimType> 164 inline void System_arraycopyTUnchecked(JNIEnv* env, jobject javaSrc, jint srcPos, 165 jobject javaDst, jint dstPos, jint count) { 166 ScopedFastNativeObjectAccess soa(env); 167 mirror::Object* srcObject = soa.Decode<mirror::Object*>(javaSrc); 168 mirror::Object* dstObject = soa.Decode<mirror::Object*>(javaDst); 169 DCHECK(dstObject != nullptr); 170 mirror::Array* srcArray = srcObject->AsArray(); 171 mirror::Array* dstArray = dstObject->AsArray(); 172 DCHECK_GE(count, 0); 173 DCHECK_EQ(srcArray->GetClass(), dstArray->GetClass()); 174 DCHECK_EQ(srcArray->GetClass()->GetComponentType()->GetPrimitiveType(), kPrimType); 175 AsPrimitiveArray<T>(dstArray)->Memmove(dstPos, AsPrimitiveArray<T>(srcArray), srcPos, count); 176 } 177 178 static void System_arraycopyCharUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 179 jobject javaDst, jint dstPos, jint count) { 180 System_arraycopyTUnchecked<mirror::CharArray, Primitive::kPrimChar>(env, javaSrc, srcPos, 181 javaDst, dstPos, count); 182 } 183 184 static void System_arraycopyByteUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 185 jobject javaDst, jint dstPos, jint count) { 186 System_arraycopyTUnchecked<mirror::ByteArray, Primitive::kPrimByte>(env, javaSrc, srcPos, 187 javaDst, dstPos, count); 188 } 189 190 static void System_arraycopyShortUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 191 jobject javaDst, jint dstPos, jint count) { 192 System_arraycopyTUnchecked<mirror::ShortArray, Primitive::kPrimShort>(env, javaSrc, srcPos, 193 javaDst, dstPos, count); 194 } 195 196 static void System_arraycopyIntUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 197 jobject javaDst, jint dstPos, jint count) { 198 System_arraycopyTUnchecked<mirror::IntArray, Primitive::kPrimInt>(env, javaSrc, srcPos, 199 javaDst, dstPos, count); 200 } 201 202 static void System_arraycopyLongUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 203 jobject javaDst, jint dstPos, jint count) { 204 System_arraycopyTUnchecked<mirror::LongArray, Primitive::kPrimLong>(env, javaSrc, srcPos, 205 javaDst, dstPos, count); 206 } 207 208 static void System_arraycopyFloatUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 209 jobject javaDst, jint dstPos, jint count) { 210 System_arraycopyTUnchecked<mirror::FloatArray, Primitive::kPrimFloat>(env, javaSrc, srcPos, 211 javaDst, dstPos, count); 212 } 213 214 static void System_arraycopyDoubleUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 215 jobject javaDst, jint dstPos, jint count) { 216 System_arraycopyTUnchecked<mirror::DoubleArray, Primitive::kPrimDouble>(env, javaSrc, srcPos, 217 javaDst, dstPos, count); 218 } 219 220 static void System_arraycopyBooleanUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, 221 jobject javaDst, jint dstPos, jint count) { 222 System_arraycopyTUnchecked<mirror::BooleanArray, Primitive::kPrimBoolean>(env, javaSrc, srcPos, 223 javaDst, dstPos, count); 224 } 225 226 static jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) { 227 if (UNLIKELY(javaObject == nullptr)) { 228 return 0; 229 } 230 ScopedFastNativeObjectAccess soa(env); 231 mirror::Object* o = soa.Decode<mirror::Object*>(javaObject); 232 return static_cast<jint>(o->IdentityHashCode()); 233 } 234 235 static JNINativeMethod gMethods[] = { 236 NATIVE_METHOD(System, arraycopy, "!(Ljava/lang/Object;ILjava/lang/Object;II)V"), 237 NATIVE_METHOD(System, arraycopyCharUnchecked, "!([CI[CII)V"), 238 NATIVE_METHOD(System, arraycopyByteUnchecked, "!([BI[BII)V"), 239 NATIVE_METHOD(System, arraycopyShortUnchecked, "!([SI[SII)V"), 240 NATIVE_METHOD(System, arraycopyIntUnchecked, "!([II[III)V"), 241 NATIVE_METHOD(System, arraycopyLongUnchecked, "!([JI[JII)V"), 242 NATIVE_METHOD(System, arraycopyFloatUnchecked, "!([FI[FII)V"), 243 NATIVE_METHOD(System, arraycopyDoubleUnchecked, "!([DI[DII)V"), 244 NATIVE_METHOD(System, arraycopyBooleanUnchecked, "!([ZI[ZII)V"), 245 NATIVE_METHOD(System, identityHashCode, "!(Ljava/lang/Object;)I"), 246 }; 247 248 void register_java_lang_System(JNIEnv* env) { 249 REGISTER_NATIVE_METHODS("java/lang/System"); 250 } 251 252 } // namespace art 253