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