Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 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 | |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 17 | #include "java_lang_System.h" |
| 18 | |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 19 | #include "common_throws.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 20 | #include "gc/accounting/card_table-inl.h" |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 21 | #include "jni_internal.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 22 | #include "mirror/array.h" |
| 23 | #include "mirror/class.h" |
| 24 | #include "mirror/class-inl.h" |
| 25 | #include "mirror/object-inl.h" |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 26 | #include "mirror/object_array-inl.h" |
Mathieu Chartier | 0795f23 | 2016-09-27 18:43:30 -0700 | [diff] [blame] | 27 | #include "scoped_fast_native_object_access-inl.h" |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 28 | |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 29 | namespace art { |
| 30 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 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 | |
Mathieu Chartier | 6b3d12b | 2016-10-13 13:59:58 -0700 | [diff] [blame] | 38 | static void ThrowArrayStoreException_NotAnArray(const char* identifier, |
| 39 | ObjPtr<mirror::Object> array) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 40 | REQUIRES_SHARED(Locks::mutator_lock_) { |
David Sehr | 709b070 | 2016-10-13 09:12:37 -0700 | [diff] [blame] | 41 | std::string actualType(mirror::Object::PrettyTypeOf(array)); |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 42 | Thread* self = Thread::Current(); |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 43 | self->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;", |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 44 | "%s of type %s is not an array", identifier, actualType.c_str()); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 45 | } |
| 46 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 47 | static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, |
| 48 | jint dstPos, jint length) { |
| 49 | // The API is defined in terms of length, but length is somewhat overloaded so we use count. |
| 50 | const jint count = length; |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 51 | ScopedFastNativeObjectAccess soa(env); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 52 | |
| 53 | // Null pointer checks. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 54 | if (UNLIKELY(javaSrc == nullptr)) { |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 55 | ThrowNullPointerException("src == null"); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 56 | return; |
| 57 | } |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 58 | if (UNLIKELY(javaDst == nullptr)) { |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 59 | ThrowNullPointerException("dst == null"); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 60 | return; |
| 61 | } |
| 62 | |
| 63 | // Make sure source and destination are both arrays. |
Mathieu Chartier | 0795f23 | 2016-09-27 18:43:30 -0700 | [diff] [blame] | 64 | ObjPtr<mirror::Object> srcObject = soa.Decode<mirror::Object>(javaSrc); |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 65 | if (UNLIKELY(!srcObject->IsArrayInstance())) { |
Mathieu Chartier | 6b3d12b | 2016-10-13 13:59:58 -0700 | [diff] [blame] | 66 | ThrowArrayStoreException_NotAnArray("source", srcObject); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 67 | return; |
| 68 | } |
Mathieu Chartier | 0795f23 | 2016-09-27 18:43:30 -0700 | [diff] [blame] | 69 | ObjPtr<mirror::Object> dstObject = soa.Decode<mirror::Object>(javaDst); |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 70 | if (UNLIKELY(!dstObject->IsArrayInstance())) { |
Mathieu Chartier | 6b3d12b | 2016-10-13 13:59:58 -0700 | [diff] [blame] | 71 | ThrowArrayStoreException_NotAnArray("destination", dstObject); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 72 | return; |
| 73 | } |
Mathieu Chartier | bc5a795 | 2016-10-17 15:46:31 -0700 | [diff] [blame] | 74 | ObjPtr<mirror::Array> srcArray = srcObject->AsArray(); |
| 75 | ObjPtr<mirror::Array> dstArray = dstObject->AsArray(); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 76 | |
| 77 | // Bounds checking. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 78 | if (UNLIKELY(srcPos < 0) || UNLIKELY(dstPos < 0) || UNLIKELY(count < 0) || |
| 79 | UNLIKELY(srcPos > srcArray->GetLength() - count) || |
| 80 | UNLIKELY(dstPos > dstArray->GetLength() - count)) { |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 81 | soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;", |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 82 | "src.length=%d srcPos=%d dst.length=%d dstPos=%d length=%d", |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 83 | srcArray->GetLength(), srcPos, dstArray->GetLength(), dstPos, |
| 84 | count); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 85 | return; |
| 86 | } |
| 87 | |
Mathieu Chartier | bc5a795 | 2016-10-17 15:46:31 -0700 | [diff] [blame] | 88 | ObjPtr<mirror::Class> dstComponentType = dstArray->GetClass()->GetComponentType(); |
| 89 | ObjPtr<mirror::Class> srcComponentType = srcArray->GetClass()->GetComponentType(); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 90 | Primitive::Type dstComponentPrimitiveType = dstComponentType->GetPrimitiveType(); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 91 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 92 | if (LIKELY(srcComponentType == dstComponentType)) { |
| 93 | // Trivial assignability. |
| 94 | switch (dstComponentPrimitiveType) { |
| 95 | case Primitive::kPrimVoid: |
| 96 | LOG(FATAL) << "Unreachable, cannot have arrays of type void"; |
Ian Rogers | 2c4257b | 2014-10-24 14:20:06 -0700 | [diff] [blame] | 97 | UNREACHABLE(); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 98 | case Primitive::kPrimBoolean: |
| 99 | case Primitive::kPrimByte: |
| 100 | DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 1U); |
| 101 | dstArray->AsByteSizedArray()->Memmove(dstPos, srcArray->AsByteSizedArray(), srcPos, count); |
| 102 | return; |
| 103 | case Primitive::kPrimChar: |
| 104 | case Primitive::kPrimShort: |
| 105 | DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 2U); |
| 106 | dstArray->AsShortSizedArray()->Memmove(dstPos, srcArray->AsShortSizedArray(), srcPos, count); |
| 107 | return; |
| 108 | case Primitive::kPrimInt: |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 109 | DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 4U); |
| 110 | dstArray->AsIntArray()->Memmove(dstPos, srcArray->AsIntArray(), srcPos, count); |
| 111 | return; |
Andreas Gampe | c952ac9 | 2015-07-16 17:41:25 -0700 | [diff] [blame] | 112 | case Primitive::kPrimFloat: |
| 113 | DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 4U); |
| 114 | dstArray->AsFloatArray()->Memmove(dstPos, srcArray->AsFloatArray(), srcPos, count); |
| 115 | return; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 116 | case Primitive::kPrimLong: |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 117 | DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 8U); |
| 118 | dstArray->AsLongArray()->Memmove(dstPos, srcArray->AsLongArray(), srcPos, count); |
| 119 | return; |
Andreas Gampe | c952ac9 | 2015-07-16 17:41:25 -0700 | [diff] [blame] | 120 | case Primitive::kPrimDouble: |
| 121 | DCHECK_EQ(Primitive::ComponentSize(dstComponentPrimitiveType), 8U); |
| 122 | dstArray->AsDoubleArray()->Memmove(dstPos, srcArray->AsDoubleArray(), srcPos, count); |
| 123 | return; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 124 | case Primitive::kPrimNot: { |
| 125 | mirror::ObjectArray<mirror::Object>* dstObjArray = dstArray->AsObjectArray<mirror::Object>(); |
| 126 | mirror::ObjectArray<mirror::Object>* srcObjArray = srcArray->AsObjectArray<mirror::Object>(); |
| 127 | dstObjArray->AssignableMemmove(dstPos, srcObjArray, srcPos, count); |
| 128 | return; |
Elliott Hughes | ab3530d | 2012-01-09 16:04:56 -0800 | [diff] [blame] | 129 | } |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 130 | default: |
David Sehr | 709b070 | 2016-10-13 09:12:37 -0700 | [diff] [blame] | 131 | LOG(FATAL) << "Unknown array type: " << srcArray->PrettyTypeOf(); |
Ian Rogers | 2c4257b | 2014-10-24 14:20:06 -0700 | [diff] [blame] | 132 | UNREACHABLE(); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 133 | } |
| 134 | } |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 135 | // If one of the arrays holds a primitive type the other array must hold the exact same type. |
| 136 | if (UNLIKELY((dstComponentPrimitiveType != Primitive::kPrimNot) || |
| 137 | srcComponentType->IsPrimitive())) { |
David Sehr | 709b070 | 2016-10-13 09:12:37 -0700 | [diff] [blame] | 138 | std::string srcType(srcArray->PrettyTypeOf()); |
| 139 | std::string dstType(dstArray->PrettyTypeOf()); |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 140 | soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;", |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 141 | "Incompatible types: src=%s, dst=%s", |
| 142 | srcType.c_str(), dstType.c_str()); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 143 | return; |
| 144 | } |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 145 | // Arrays hold distinct types and so therefore can't alias - use memcpy instead of memmove. |
Mathieu Chartier | bc5a795 | 2016-10-17 15:46:31 -0700 | [diff] [blame] | 146 | ObjPtr<mirror::ObjectArray<mirror::Object>> dstObjArray = |
| 147 | dstArray->AsObjectArray<mirror::Object>(); |
| 148 | ObjPtr<mirror::ObjectArray<mirror::Object>> srcObjArray = |
| 149 | srcArray->AsObjectArray<mirror::Object>(); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 150 | // If we're assigning into say Object[] then we don't need per element checks. |
| 151 | if (dstComponentType->IsAssignableFrom(srcComponentType)) { |
| 152 | dstObjArray->AssignableMemcpy(dstPos, srcObjArray, srcPos, count); |
| 153 | return; |
| 154 | } |
Andreas Gampe | 85a098a | 2016-03-31 13:30:53 -0700 | [diff] [blame] | 155 | // This code is never run under a transaction. |
| 156 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
| 157 | dstObjArray->AssignableCheckingMemcpy<false>(dstPos, srcObjArray, srcPos, count, true); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Emma Meersman | d735fe4 | 2014-06-18 11:50:59 -0700 | [diff] [blame] | 160 | // Template to convert general array to that of its specific primitive type. |
| 161 | template <typename T> |
Mathieu Chartier | bc5a795 | 2016-10-17 15:46:31 -0700 | [diff] [blame] | 162 | inline ObjPtr<T> AsPrimitiveArray(ObjPtr<mirror::Array> array) |
| 163 | REQUIRES_SHARED(Locks::mutator_lock_) { |
| 164 | return ObjPtr<T>::DownCast(array); |
Emma Meersman | d735fe4 | 2014-06-18 11:50:59 -0700 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | template <typename T, Primitive::Type kPrimType> |
| 168 | inline void System_arraycopyTUnchecked(JNIEnv* env, jobject javaSrc, jint srcPos, |
| 169 | jobject javaDst, jint dstPos, jint count) { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 170 | ScopedFastNativeObjectAccess soa(env); |
Mathieu Chartier | 0795f23 | 2016-09-27 18:43:30 -0700 | [diff] [blame] | 171 | ObjPtr<mirror::Object> srcObject = soa.Decode<mirror::Object>(javaSrc); |
| 172 | ObjPtr<mirror::Object> dstObject = soa.Decode<mirror::Object>(javaDst); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 173 | DCHECK(dstObject != nullptr); |
Mathieu Chartier | bc5a795 | 2016-10-17 15:46:31 -0700 | [diff] [blame] | 174 | ObjPtr<mirror::Array> srcArray = srcObject->AsArray(); |
| 175 | ObjPtr<mirror::Array> dstArray = dstObject->AsArray(); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 176 | DCHECK_GE(count, 0); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 177 | DCHECK_EQ(srcArray->GetClass(), dstArray->GetClass()); |
Emma Meersman | d735fe4 | 2014-06-18 11:50:59 -0700 | [diff] [blame] | 178 | DCHECK_EQ(srcArray->GetClass()->GetComponentType()->GetPrimitiveType(), kPrimType); |
| 179 | AsPrimitiveArray<T>(dstArray)->Memmove(dstPos, AsPrimitiveArray<T>(srcArray), srcPos, count); |
| 180 | } |
| 181 | |
| 182 | static void System_arraycopyCharUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 183 | jobject javaDst, jint dstPos, jint count) { |
| 184 | System_arraycopyTUnchecked<mirror::CharArray, Primitive::kPrimChar>(env, javaSrc, srcPos, |
| 185 | javaDst, dstPos, count); |
| 186 | } |
| 187 | |
| 188 | static void System_arraycopyByteUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 189 | jobject javaDst, jint dstPos, jint count) { |
| 190 | System_arraycopyTUnchecked<mirror::ByteArray, Primitive::kPrimByte>(env, javaSrc, srcPos, |
| 191 | javaDst, dstPos, count); |
| 192 | } |
| 193 | |
| 194 | static void System_arraycopyShortUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 195 | jobject javaDst, jint dstPos, jint count) { |
| 196 | System_arraycopyTUnchecked<mirror::ShortArray, Primitive::kPrimShort>(env, javaSrc, srcPos, |
| 197 | javaDst, dstPos, count); |
| 198 | } |
| 199 | |
| 200 | static void System_arraycopyIntUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 201 | jobject javaDst, jint dstPos, jint count) { |
| 202 | System_arraycopyTUnchecked<mirror::IntArray, Primitive::kPrimInt>(env, javaSrc, srcPos, |
| 203 | javaDst, dstPos, count); |
| 204 | } |
| 205 | |
| 206 | static void System_arraycopyLongUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 207 | jobject javaDst, jint dstPos, jint count) { |
| 208 | System_arraycopyTUnchecked<mirror::LongArray, Primitive::kPrimLong>(env, javaSrc, srcPos, |
| 209 | javaDst, dstPos, count); |
| 210 | } |
| 211 | |
| 212 | static void System_arraycopyFloatUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 213 | jobject javaDst, jint dstPos, jint count) { |
| 214 | System_arraycopyTUnchecked<mirror::FloatArray, Primitive::kPrimFloat>(env, javaSrc, srcPos, |
| 215 | javaDst, dstPos, count); |
| 216 | } |
| 217 | |
| 218 | static void System_arraycopyDoubleUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 219 | jobject javaDst, jint dstPos, jint count) { |
| 220 | System_arraycopyTUnchecked<mirror::DoubleArray, Primitive::kPrimDouble>(env, javaSrc, srcPos, |
| 221 | javaDst, dstPos, count); |
| 222 | } |
| 223 | |
| 224 | static void System_arraycopyBooleanUnchecked(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, |
| 225 | jobject javaDst, jint dstPos, jint count) { |
| 226 | System_arraycopyTUnchecked<mirror::BooleanArray, Primitive::kPrimBoolean>(env, javaSrc, srcPos, |
| 227 | javaDst, dstPos, count); |
Hiroshi Yamauchi | f38ea80 | 2013-08-27 13:04:26 -0700 | [diff] [blame] | 228 | } |
| 229 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 230 | static JNINativeMethod gMethods[] = { |
Igor Murashkin | 3b6f440 | 2017-02-16 16:13:17 -0800 | [diff] [blame] | 231 | FAST_NATIVE_METHOD(System, arraycopy, "(Ljava/lang/Object;ILjava/lang/Object;II)V"), |
| 232 | FAST_NATIVE_METHOD(System, arraycopyCharUnchecked, "([CI[CII)V"), |
| 233 | FAST_NATIVE_METHOD(System, arraycopyByteUnchecked, "([BI[BII)V"), |
| 234 | FAST_NATIVE_METHOD(System, arraycopyShortUnchecked, "([SI[SII)V"), |
| 235 | FAST_NATIVE_METHOD(System, arraycopyIntUnchecked, "([II[III)V"), |
| 236 | FAST_NATIVE_METHOD(System, arraycopyLongUnchecked, "([JI[JII)V"), |
| 237 | FAST_NATIVE_METHOD(System, arraycopyFloatUnchecked, "([FI[FII)V"), |
| 238 | FAST_NATIVE_METHOD(System, arraycopyDoubleUnchecked, "([DI[DII)V"), |
| 239 | FAST_NATIVE_METHOD(System, arraycopyBooleanUnchecked, "([ZI[ZII)V"), |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 240 | }; |
| 241 | |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 242 | void register_java_lang_System(JNIEnv* env) { |
Elliott Hughes | eac7667 | 2012-05-24 21:56:51 -0700 | [diff] [blame] | 243 | REGISTER_NATIVE_METHODS("java/lang/System"); |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | } // namespace art |