blob: 741b31971895680558761a4ff3f5942b249800c5 [file] [log] [blame]
Elliott Hughesbf86d042011-08-31 17:53:14 -07001/*
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) {
Elliott Hughescc607472011-10-17 15:34:11 -070057 DCHECK_EQ((((uintptr_t) dst | (uintptr_t) src | n) & 0x01), 0U);
Elliott Hughesbf86d042011-08-31 17:53:14 -070058
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) {
Elliott Hughescc607472011-10-17 15:34:11 -070080 DCHECK_EQ((((uintptr_t) dst | (uintptr_t) src | n) & 0x03), 0U);
Elliott Hughesbf86d042011-08-31 17:53:14 -070081
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
Elliott Hughes0512f022012-03-15 22:10:52 -0700105static void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array) {
Elliott Hughes54e7df12011-09-16 11:47:04 -0700106 std::string actualType(PrettyTypeOf(array));
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700107 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
Elliott Hughes81aa5b32012-01-17 13:47:13 -0800108 "%s of type %s is not an array", identifier, actualType.c_str());
Elliott Hughesbf86d042011-08-31 17:53:14 -0700109}
110
Elliott Hughes0512f022012-03-15 22:10:52 -0700111static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint length) {
Elliott Hughes34e06962012-04-09 13:55:55 -0700112 ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700113 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()) {
Elliott Hughes81aa5b32012-01-17 13:47:13 -0800129 ThrowArrayStoreException_NotAnArray("source", srcObject);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700130 return;
131 }
132 if (!dstObject->IsArrayInstance()) {
Elliott Hughes81aa5b32012-01-17 13:47:13 -0800133 ThrowArrayStoreException_NotAnArray("destination", dstObject);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700134 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) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700143 self->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
Elliott Hughesbf86d042011-08-31 17:53:14 -0700144 "src.length=%d srcPos=%d dst.length=%d dstPos=%d length=%d",
145 srcArray->GetLength(), srcPos, dstArray->GetLength(), dstPos, length);
146 return;
147 }
148
Elliott Hughesbf86d042011-08-31 17:53:14 -0700149 // Handle primitive arrays.
150 if (srcComponentType->IsPrimitive() || dstComponentType->IsPrimitive()) {
151 // If one of the arrays holds a primitive type the other array must hold the exact same type.
152 if (srcComponentType->IsPrimitive() != dstComponentType->IsPrimitive() || srcComponentType != dstComponentType) {
Elliott Hughes54e7df12011-09-16 11:47:04 -0700153 std::string srcType(PrettyTypeOf(srcArray));
154 std::string dstType(PrettyTypeOf(dstArray));
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700155 self->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
Elliott Hughesbf86d042011-08-31 17:53:14 -0700156 "Incompatible types: src=%s, dst=%s", srcType.c_str(), dstType.c_str());
157 return;
158 }
159
Ian Rogersa15e67d2012-02-28 13:51:55 -0800160 size_t width = srcArray->GetClass()->GetComponentSize();
161 uint8_t* dstBytes = reinterpret_cast<uint8_t*>(dstArray->GetRawData(width));
162 const uint8_t* srcBytes = reinterpret_cast<const uint8_t*>(srcArray->GetRawData(width));
163
164 switch (width) {
Elliott Hughesbf86d042011-08-31 17:53:14 -0700165 case 1:
166 memmove(dstBytes + dstPos, srcBytes + srcPos, length);
167 break;
168 case 2:
169 move16(dstBytes + dstPos * 2, srcBytes + srcPos * 2, length * 2);
170 break;
171 case 4:
172 move32(dstBytes + dstPos * 4, srcBytes + srcPos * 4, length * 4);
173 break;
174 case 8:
175 // We don't need to guarantee atomicity of the entire 64-bit word.
176 move32(dstBytes + dstPos * 8, srcBytes + srcPos * 8, length * 8);
177 break;
178 default:
Elliott Hughes54e7df12011-09-16 11:47:04 -0700179 LOG(FATAL) << "Unknown primitive array type: " << PrettyTypeOf(srcArray);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700180 }
181
182 return;
183 }
184
185 // Neither class is primitive. Are the types trivially compatible?
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700186 const size_t width = sizeof(Object*);
Ian Rogersa15e67d2012-02-28 13:51:55 -0800187 uint8_t* dstBytes = reinterpret_cast<uint8_t*>(dstArray->GetRawData(width));
188 const uint8_t* srcBytes = reinterpret_cast<const uint8_t*>(srcArray->GetRawData(width));
Elliott Hughesab3530d2012-01-09 16:04:56 -0800189 if (dstArray == srcArray || dstComponentType->IsAssignableFrom(srcComponentType)) {
Elliott Hughesbf86d042011-08-31 17:53:14 -0700190 // Yes. Bulk copy.
Brian Carlstromb6db9d22011-09-18 11:39:12 -0700191 COMPILE_ASSERT(sizeof(width) == sizeof(uint32_t), move32_assumes_Object_references_are_32_bit);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700192 move32(dstBytes + dstPos * width, srcBytes + srcPos * width, length * width);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800193 Runtime::Current()->GetHeap()->WriteBarrierArray(dstArray, dstPos, length);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700194 return;
195 }
196
Elliott Hughesab3530d2012-01-09 16:04:56 -0800197 // The arrays are not trivially compatible. However, we may still be able to copy some or all of
198 // the elements if the source objects are compatible (for example, copying an Object[] to
199 // String[], the Objects being copied might actually be Strings).
200 // We can't do a bulk move because that would introduce a check-use race condition, so we copy
201 // elements one by one.
Elliott Hughesbf86d042011-08-31 17:53:14 -0700202
Elliott Hughesab3530d2012-01-09 16:04:56 -0800203 // We already dealt with overlapping copies, so we don't need to cope with that case below.
204 CHECK_NE(dstArray, srcArray);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700205
Elliott Hughesab3530d2012-01-09 16:04:56 -0800206 Object* const * srcObjects = reinterpret_cast<Object* const *>(srcBytes + srcPos * width);
207 Object** dstObjects = reinterpret_cast<Object**>(dstBytes + dstPos * width);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700208 Class* dstClass = dstArray->GetClass()->GetComponentType();
Elliott Hughesbf86d042011-08-31 17:53:14 -0700209
Elliott Hughesab3530d2012-01-09 16:04:56 -0800210 // We want to avoid redundant IsAssignableFrom checks where possible, so we cache a class that
211 // we know is assignable to the destination array's component type.
212 Class* lastAssignableElementClass = dstClass;
213
Elliott Hughes025c5de2012-01-10 11:05:48 -0800214 Object* o = NULL;
Elliott Hughesab3530d2012-01-09 16:04:56 -0800215 int i = 0;
216 for (; i < length; ++i) {
Elliott Hughes025c5de2012-01-10 11:05:48 -0800217 o = srcObjects[i];
Elliott Hughesab3530d2012-01-09 16:04:56 -0800218 if (o != NULL) {
219 Class* oClass = o->GetClass();
220 if (lastAssignableElementClass == oClass) {
221 dstObjects[i] = o;
222 } else if (dstClass->IsAssignableFrom(oClass)) {
223 lastAssignableElementClass = oClass;
224 dstObjects[i] = o;
225 } else {
226 // Can't put this element into the array.
227 break;
228 }
229 } else {
230 dstObjects[i] = NULL;
Elliott Hughesbf86d042011-08-31 17:53:14 -0700231 }
232 }
233
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800234 Runtime::Current()->GetHeap()->WriteBarrierArray(dstArray, dstPos, length);
Elliott Hughesab3530d2012-01-09 16:04:56 -0800235 if (i != length) {
Elliott Hughes025c5de2012-01-10 11:05:48 -0800236 std::string actualSrcType(PrettyTypeOf(o));
Elliott Hughes54e7df12011-09-16 11:47:04 -0700237 std::string dstType(PrettyTypeOf(dstArray));
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700238 self->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
Elliott Hughesbf86d042011-08-31 17:53:14 -0700239 "source[%d] of type %s cannot be stored in destination array of type %s",
Elliott Hughesab3530d2012-01-09 16:04:56 -0800240 srcPos + i, actualSrcType.c_str(), dstType.c_str());
Elliott Hughesbf86d042011-08-31 17:53:14 -0700241 return;
242 }
243}
244
Elliott Hughes0512f022012-03-15 22:10:52 -0700245static jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) {
Elliott Hughesbf86d042011-08-31 17:53:14 -0700246 Object* o = Decode<Object*>(env, javaObject);
247 return static_cast<jint>(reinterpret_cast<uintptr_t>(o));
248}
249
Elliott Hughes0512f022012-03-15 22:10:52 -0700250static JNINativeMethod gMethods[] = {
Elliott Hughesbf86d042011-08-31 17:53:14 -0700251 NATIVE_METHOD(System, arraycopy, "(Ljava/lang/Object;ILjava/lang/Object;II)V"),
252 NATIVE_METHOD(System, identityHashCode, "(Ljava/lang/Object;)I"),
253};
254
Elliott Hughesbf86d042011-08-31 17:53:14 -0700255void register_java_lang_System(JNIEnv* env) {
256 jniRegisterNativeMethods(env, "java/lang/System", gMethods, NELEM(gMethods));
257}
258
259} // namespace art