blob: 1d8df68994db9c6fe200fa511bfb89900c124680 [file] [log] [blame]
Shih-wei Liao2d831012011-09-28 22:06:53 -07001/*
Elliott Hughes0f3c5532012-03-30 14:51:51 -07002 * Copyright (C) 2012 The Android Open Source Project
Shih-wei Liao2d831012011-09-28 22:06:53 -07003 *
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
Ian Rogers7655f292013-07-29 11:07:13 -070017#include "entrypoints/entrypoint_utils.h"
Shih-wei Liao2d831012011-09-28 22:06:53 -070018
Mathieu Chartierc7853442015-03-27 14:35:38 -070019#include "art_field-inl.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070020#include "base/mutex.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080021#include "class_linker-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070022#include "dex_file-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070023#include "gc/accounting/card_table-inl.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070024#include "mirror/art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080025#include "mirror/class-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026#include "mirror/object-inl.h"
27#include "mirror/object_array-inl.h"
Ian Rogersaf6e67a2013-01-16 08:38:37 -080028#include "reflection.h"
29#include "scoped_thread_state_change.h"
TDYa1275bb86012012-04-11 05:57:28 -070030#include "ScopedLocalRef.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070031#include "well_known_classes.h"
TDYa1275bb86012012-04-11 05:57:28 -070032
jeffhao41005dd2012-05-09 17:58:52 -070033namespace art {
34
Brian Carlstrom34375312014-09-10 23:10:47 -070035static inline mirror::Class* CheckFilledNewArrayAlloc(uint32_t type_idx,
Brian Carlstrom34375312014-09-10 23:10:47 -070036 int32_t component_count,
Andreas Gampe1cc7dba2014-12-17 18:43:01 -080037 mirror::ArtMethod* referrer,
Brian Carlstrom34375312014-09-10 23:10:47 -070038 Thread* self,
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080039 bool access_check)
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070040 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers57b86d42012-03-27 16:05:41 -070041 if (UNLIKELY(component_count < 0)) {
Ian Rogers62d6c772013-02-27 08:32:07 -080042 ThrowNegativeArraySizeException(component_count);
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080043 return nullptr; // Failure
Elliott Hughes6c8867d2011-10-03 16:34:05 -070044 }
Andreas Gampe58a5af82014-07-31 16:23:49 -070045 mirror::Class* klass = referrer->GetDexCacheResolvedType<false>(type_idx);
Ian Rogers57b86d42012-03-27 16:05:41 -070046 if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
Ian Rogers62d6c772013-02-27 08:32:07 -080047 klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, referrer);
Ian Rogers57b86d42012-03-27 16:05:41 -070048 if (klass == NULL) { // Error
Ian Rogers50b35e22012-10-04 10:09:15 -070049 DCHECK(self->IsExceptionPending());
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080050 return nullptr; // Failure
Ian Rogers19846512012-02-24 11:42:47 -080051 }
Ian Rogersea2a11d2011-10-11 16:48:51 -070052 }
Ian Rogers57b86d42012-03-27 16:05:41 -070053 if (UNLIKELY(klass->IsPrimitive() && !klass->IsPrimitiveInt())) {
54 if (klass->IsPrimitiveLong() || klass->IsPrimitiveDouble()) {
Ian Rogers62d6c772013-02-27 08:32:07 -080055 ThrowRuntimeException("Bad filled array request for type %s",
56 PrettyDescriptor(klass).c_str());
Ian Rogers573db4a2011-12-13 15:30:50 -080057 } else {
Brian Carlstrom34375312014-09-10 23:10:47 -070058 self->ThrowNewExceptionF(
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +000059 "Ljava/lang/InternalError;",
Brian Carlstrom34375312014-09-10 23:10:47 -070060 "Found type %s; filled-new-array not implemented for anything but 'int'",
61 PrettyDescriptor(klass).c_str());
Ian Rogers573db4a2011-12-13 15:30:50 -080062 }
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080063 return nullptr; // Failure
Ian Rogers57b86d42012-03-27 16:05:41 -070064 }
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070065 if (access_check) {
66 mirror::Class* referrer_klass = referrer->GetDeclaringClass();
67 if (UNLIKELY(!referrer_klass->CanAccess(klass))) {
68 ThrowIllegalAccessErrorClass(referrer_klass, klass);
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080069 return nullptr; // Failure
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070070 }
71 }
72 DCHECK(klass->IsArrayClass()) << PrettyClass(klass);
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080073 return klass;
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070074}
75
76// Helper function to allocate array for FILLED_NEW_ARRAY.
Andreas Gampe1cc7dba2014-12-17 18:43:01 -080077mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, int32_t component_count,
78 mirror::ArtMethod* referrer, Thread* self,
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080079 bool access_check,
Mathieu Chartiere6da9af2013-12-16 11:54:42 -080080 gc::AllocatorType /* allocator_type */) {
Andreas Gampe1cc7dba2014-12-17 18:43:01 -080081 mirror::Class* klass = CheckFilledNewArrayAlloc(type_idx, component_count, referrer, self,
Mathieu Chartiercbb2d202013-11-14 17:45:16 -080082 access_check);
83 if (UNLIKELY(klass == nullptr)) {
84 return nullptr;
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070085 }
Mathieu Chartiere6da9af2013-12-16 11:54:42 -080086 // Always go slow path for now, filled new array is not common.
87 gc::Heap* heap = Runtime::Current()->GetHeap();
88 // Use the current allocator type in case CheckFilledNewArrayAlloc caused us to suspend and then
89 // the heap switched the allocator type while we were suspended.
Hiroshi Yamauchif0edfc32014-09-25 11:46:46 -070090 return mirror::Array::Alloc<false>(self, klass, component_count,
91 klass->GetComponentSizeShift(),
Ian Rogers6fac4472014-02-25 17:01:10 -080092 heap->GetCurrentAllocator());
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070093}
94
95// Helper function to allocate array for FILLED_NEW_ARRAY.
Brian Carlstrom34375312014-09-10 23:10:47 -070096mirror::Array* CheckAndAllocArrayFromCodeInstrumented(uint32_t type_idx,
Brian Carlstrom34375312014-09-10 23:10:47 -070097 int32_t component_count,
Andreas Gampe1cc7dba2014-12-17 18:43:01 -080098 mirror::ArtMethod* referrer,
Brian Carlstrom34375312014-09-10 23:10:47 -070099 Thread* self,
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800100 bool access_check,
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800101 gc::AllocatorType /* allocator_type */) {
Andreas Gampe1cc7dba2014-12-17 18:43:01 -0800102 mirror::Class* klass = CheckFilledNewArrayAlloc(type_idx, component_count, referrer, self,
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800103 access_check);
104 if (UNLIKELY(klass == nullptr)) {
105 return nullptr;
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -0700106 }
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800107 gc::Heap* heap = Runtime::Current()->GetHeap();
108 // Use the current allocator type in case CheckFilledNewArrayAlloc caused us to suspend and then
109 // the heap switched the allocator type while we were suspended.
Hiroshi Yamauchif0edfc32014-09-25 11:46:46 -0700110 return mirror::Array::Alloc<true>(self, klass, component_count,
111 klass->GetComponentSizeShift(),
Ian Rogers6fac4472014-02-25 17:01:10 -0800112 heap->GetCurrentAllocator());
Ian Rogers57b86d42012-03-27 16:05:41 -0700113}
114
jeffhaod7521322012-11-21 15:38:24 -0800115void ThrowStackOverflowError(Thread* self) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700116 if (self->IsHandlingStackOverflow()) {
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700117 LOG(ERROR) << "Recursive stack overflow.";
118 // We don't fail here because SetStackEndForStackOverflow will print better diagnostics.
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700119 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800120
jeffhaod7521322012-11-21 15:38:24 -0800121 self->SetStackEndForStackOverflow(); // Allow space on the stack for constructor to execute.
122 JNIEnvExt* env = self->GetJniEnv();
123 std::string msg("stack size ");
124 msg += PrettySize(self->GetStackSize());
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700125
126 // Avoid running Java code for exception initialization.
127 // TODO: Checks to make this a bit less brittle.
128
129 std::string error_msg;
130
131 // Allocate an uninitialized object.
132 ScopedLocalRef<jobject> exc(env,
133 env->AllocObject(WellKnownClasses::java_lang_StackOverflowError));
134 if (exc.get() != nullptr) {
135 // "Initialize".
136 // StackOverflowError -> VirtualMachineError -> Error -> Throwable -> Object.
137 // Only Throwable has "custom" fields:
138 // String detailMessage.
139 // Throwable cause (= this).
140 // List<Throwable> suppressedExceptions (= Collections.emptyList()).
141 // Object stackState;
142 // StackTraceElement[] stackTrace;
143 // Only Throwable has a non-empty constructor:
144 // this.stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
145 // fillInStackTrace();
146
147 // detailMessage.
148 // TODO: Use String::FromModifiedUTF...?
149 ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg.c_str()));
150 if (s.get() != nullptr) {
Brian Carlstrom34375312014-09-10 23:10:47 -0700151 env->SetObjectField(exc.get(), WellKnownClasses::java_lang_Throwable_detailMessage, s.get());
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700152
153 // cause.
Brian Carlstrom34375312014-09-10 23:10:47 -0700154 env->SetObjectField(exc.get(), WellKnownClasses::java_lang_Throwable_cause, exc.get());
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700155
156 // suppressedExceptions.
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700157 ScopedLocalRef<jobject> emptylist(env, env->GetStaticObjectField(
Brian Carlstrom34375312014-09-10 23:10:47 -0700158 WellKnownClasses::java_util_Collections,
159 WellKnownClasses::java_util_Collections_EMPTY_LIST));
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700160 CHECK(emptylist.get() != nullptr);
Brian Carlstrom34375312014-09-10 23:10:47 -0700161 env->SetObjectField(exc.get(),
162 WellKnownClasses::java_lang_Throwable_suppressedExceptions,
163 emptylist.get());
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700164
165 // stackState is set as result of fillInStackTrace. fillInStackTrace calls
166 // nativeFillInStackTrace.
167 ScopedLocalRef<jobject> stack_state_val(env, nullptr);
168 {
169 ScopedObjectAccessUnchecked soa(env);
170 stack_state_val.reset(soa.Self()->CreateInternalStackTrace<false>(soa));
171 }
172 if (stack_state_val.get() != nullptr) {
Brian Carlstrom34375312014-09-10 23:10:47 -0700173 env->SetObjectField(exc.get(),
174 WellKnownClasses::java_lang_Throwable_stackState,
175 stack_state_val.get());
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700176
177 // stackTrace.
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700178 ScopedLocalRef<jobject> stack_trace_elem(env, env->GetStaticObjectField(
Brian Carlstrom34375312014-09-10 23:10:47 -0700179 WellKnownClasses::libcore_util_EmptyArray,
180 WellKnownClasses::libcore_util_EmptyArray_STACK_TRACE_ELEMENT));
181 env->SetObjectField(exc.get(),
182 WellKnownClasses::java_lang_Throwable_stackTrace,
183 stack_trace_elem.get());
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700184 } else {
185 error_msg = "Could not create stack trace.";
186 }
Mathieu Chartier50c138f2015-01-07 16:00:03 -0800187 // Throw the exception.
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000188 self->SetException(reinterpret_cast<mirror::Throwable*>(self->DecodeJObject(exc.get())));
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700189 } else {
190 // Could not allocate a string object.
191 error_msg = "Couldn't throw new StackOverflowError because JNI NewStringUTF failed.";
192 }
193 } else {
194 error_msg = "Could not allocate StackOverflowError object.";
195 }
196
197 if (!error_msg.empty()) {
Andreas Gampe1de0f5c2015-02-19 10:54:31 -0800198 LOG(WARNING) << error_msg;
jeffhaod7521322012-11-21 15:38:24 -0800199 CHECK(self->IsExceptionPending());
200 }
Dave Allisonf9439142014-03-27 15:10:22 -0700201
202 bool explicit_overflow_check = Runtime::Current()->ExplicitStackOverflowChecks();
Dave Allisonb090a182014-08-14 17:02:48 +0000203 self->ResetDefaultStackEnd(); // Return to default stack size.
Dave Allison648d7112014-07-25 16:15:27 -0700204
205 // And restore protection if implicit checks are on.
206 if (!explicit_overflow_check) {
207 self->ProtectStack();
208 }
jeffhaod7521322012-11-21 15:38:24 -0800209}
210
Ian Rogerse5877a12014-07-16 12:06:35 -0700211void CheckReferenceResult(mirror::Object* o, Thread* self) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700212 if (o == nullptr) {
Ian Rogerse5877a12014-07-16 12:06:35 -0700213 return;
214 }
Ian Rogerse5877a12014-07-16 12:06:35 -0700215 // Make sure that the result is an instance of the type this method was expected to return.
Ian Rogersded66a02014-10-28 18:12:55 -0700216 mirror::Class* return_type = self->GetCurrentMethod(nullptr)->GetReturnType();
Ian Rogerse5877a12014-07-16 12:06:35 -0700217
218 if (!o->InstanceOf(return_type)) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700219 Runtime::Current()->GetJavaVM()->JniAbortF(nullptr,
220 "attempt to return an instance of %s from %s",
Ian Rogers68d8b422014-07-17 11:09:10 -0700221 PrettyTypeOf(o).c_str(),
Ian Rogersded66a02014-10-28 18:12:55 -0700222 PrettyMethod(self->GetCurrentMethod(nullptr)).c_str());
Ian Rogerse5877a12014-07-16 12:06:35 -0700223 }
224}
225
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700226JValue InvokeProxyInvocationHandler(ScopedObjectAccessAlreadyRunnable& soa, const char* shorty,
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800227 jobject rcvr_jobj, jobject interface_method_jobj,
228 std::vector<jvalue>& args) {
229 DCHECK(soa.Env()->IsInstanceOf(rcvr_jobj, WellKnownClasses::java_lang_reflect_Proxy));
230
231 // Build argument array possibly triggering GC.
232 soa.Self()->AssertThreadSuspensionIsAllowable();
233 jobjectArray args_jobj = NULL;
234 const JValue zero;
Jeff Haof00571c2014-05-29 17:29:47 -0700235 int32_t target_sdk_version = Runtime::Current()->GetTargetSdkVersion();
236 // Do not create empty arrays unless needed to maintain Dalvik bug compatibility.
237 if (args.size() > 0 || (target_sdk_version > 0 && target_sdk_version <= 21)) {
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800238 args_jobj = soa.Env()->NewObjectArray(args.size(), WellKnownClasses::java_lang_Object, NULL);
239 if (args_jobj == NULL) {
240 CHECK(soa.Self()->IsExceptionPending());
241 return zero;
242 }
243 for (size_t i = 0; i < args.size(); ++i) {
244 if (shorty[i + 1] == 'L') {
245 jobject val = args.at(i).l;
246 soa.Env()->SetObjectArrayElement(args_jobj, i, val);
247 } else {
248 JValue jv;
249 jv.SetJ(args.at(i).j);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800250 mirror::Object* val = BoxPrimitive(Primitive::GetType(shorty[i + 1]), jv);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800251 if (val == NULL) {
252 CHECK(soa.Self()->IsExceptionPending());
253 return zero;
254 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100255 soa.Decode<mirror::ObjectArray<mirror::Object>* >(args_jobj)->Set<false>(i, val);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800256 }
257 }
258 }
259
Brian Carlstromea46f952013-07-30 01:26:50 -0700260 // Call Proxy.invoke(Proxy proxy, ArtMethod method, Object[] args).
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800261 jvalue invocation_args[3];
262 invocation_args[0].l = rcvr_jobj;
263 invocation_args[1].l = interface_method_jobj;
264 invocation_args[2].l = args_jobj;
265 jobject result =
Brian Carlstromea46f952013-07-30 01:26:50 -0700266 soa.Env()->CallStaticObjectMethodA(WellKnownClasses::java_lang_reflect_Proxy,
267 WellKnownClasses::java_lang_reflect_Proxy_invoke,
268 invocation_args);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800269
270 // Unbox result and handle error conditions.
Ian Rogers62d6c772013-02-27 08:32:07 -0800271 if (LIKELY(!soa.Self()->IsExceptionPending())) {
272 if (shorty[0] == 'V' || (shorty[0] == 'L' && result == NULL)) {
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800273 // Do nothing.
274 return zero;
275 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700276 StackHandleScope<1> hs(soa.Self());
Ian Rogersded66a02014-10-28 18:12:55 -0700277 Handle<mirror::ArtMethod> h_interface_method(
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700278 hs.NewHandle(soa.Decode<mirror::ArtMethod*>(interface_method_jobj)));
279 // This can cause thread suspension.
Ian Rogersded66a02014-10-28 18:12:55 -0700280 mirror::Class* result_type = h_interface_method->GetReturnType();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800281 mirror::Object* result_ref = soa.Decode<mirror::Object*>(result);
Ian Rogers62d6c772013-02-27 08:32:07 -0800282 JValue result_unboxed;
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000283 if (!UnboxPrimitiveForResult(result_ref, result_type, &result_unboxed)) {
Ian Rogers530f71c2013-02-22 23:29:00 -0800284 DCHECK(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800285 return zero;
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800286 }
287 return result_unboxed;
288 }
289 } else {
290 // In the case of checked exceptions that aren't declared, the exception must be wrapped by
291 // a UndeclaredThrowableException.
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000292 mirror::Throwable* exception = soa.Self()->GetException();
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800293 if (exception->IsCheckedException()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800294 mirror::Object* rcvr = soa.Decode<mirror::Object*>(rcvr_jobj);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700295 mirror::Class* proxy_class = rcvr->GetClass();
Brian Carlstromea46f952013-07-30 01:26:50 -0700296 mirror::ArtMethod* interface_method =
297 soa.Decode<mirror::ArtMethod*>(interface_method_jobj);
298 mirror::ArtMethod* proxy_method =
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800299 rcvr->GetClass()->FindVirtualMethodForInterface(interface_method);
300 int throws_index = -1;
301 size_t num_virt_methods = proxy_class->NumVirtualMethods();
302 for (size_t i = 0; i < num_virt_methods; i++) {
303 if (proxy_class->GetVirtualMethod(i) == proxy_method) {
304 throws_index = i;
305 break;
306 }
307 }
308 CHECK_NE(throws_index, -1);
Brian Carlstrom34375312014-09-10 23:10:47 -0700309 mirror::ObjectArray<mirror::Class>* declared_exceptions =
310 proxy_class->GetThrows()->Get(throws_index);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800311 mirror::Class* exception_class = exception->GetClass();
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800312 bool declares_exception = false;
313 for (int i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800314 mirror::Class* declared_exception = declared_exceptions->Get(i);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800315 declares_exception = declared_exception->IsAssignableFrom(exception_class);
316 }
317 if (!declares_exception) {
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000318 soa.Self()->ThrowNewWrappedException("Ljava/lang/reflect/UndeclaredThrowableException;",
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800319 NULL);
320 }
321 }
322 return zero;
323 }
324}
Ian Rogers832336b2014-10-08 15:35:22 -0700325
326bool FillArrayData(mirror::Object* obj, const Instruction::ArrayDataPayload* payload) {
327 DCHECK_EQ(payload->ident, static_cast<uint16_t>(Instruction::kArrayDataSignature));
328 if (UNLIKELY(obj == nullptr)) {
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000329 ThrowNullPointerException("null array in FILL_ARRAY_DATA");
Ian Rogers832336b2014-10-08 15:35:22 -0700330 return false;
331 }
332 mirror::Array* array = obj->AsArray();
333 DCHECK(!array->IsObjectArray());
334 if (UNLIKELY(static_cast<int32_t>(payload->element_count) > array->GetLength())) {
335 Thread* self = Thread::Current();
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000336 self->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
Ian Rogers832336b2014-10-08 15:35:22 -0700337 "failed FILL_ARRAY_DATA; length=%d, index=%d",
338 array->GetLength(), payload->element_count);
339 return false;
340 }
341 // Copy data from dex file to memory assuming both are little endian.
342 uint32_t size_in_bytes = payload->element_count * payload->element_width;
343 memcpy(array->GetRawData(payload->element_width, 0), payload->data, size_in_bytes);
344 return true;
345}
346
Shih-wei Liao2d831012011-09-28 22:06:53 -0700347} // namespace art