1 /*
2 * Copyright (C) 2011 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 "reflection-inl.h"
18
19 #include "art_field-inl.h"
20 #include "art_method-inl.h"
21 #include "base/enums.h"
22 #include "class_linker.h"
23 #include "common_throws.h"
24 #include "dex/dex_file-inl.h"
25 #include "indirect_reference_table-inl.h"
26 #include "jni/java_vm_ext.h"
27 #include "jni/jni_internal.h"
28 #include "jvalue-inl.h"
29 #include "mirror/class-inl.h"
30 #include "mirror/executable.h"
31 #include "mirror/object_array-inl.h"
32 #include "nativehelper/scoped_local_ref.h"
33 #include "nth_caller_visitor.h"
34 #include "scoped_thread_state_change-inl.h"
35 #include "stack_reference.h"
36 #include "thread-inl.h"
37 #include "well_known_classes.h"
38
39 namespace art {
40 namespace {
41
42 using android::base::StringPrintf;
43
44 class ArgArray {
45 public:
ArgArray(const char * shorty,uint32_t shorty_len)46 ArgArray(const char* shorty, uint32_t shorty_len)
47 : shorty_(shorty), shorty_len_(shorty_len), num_bytes_(0) {
48 size_t num_slots = shorty_len + 1; // +1 in case of receiver.
49 if (LIKELY((num_slots * 2) < kSmallArgArraySize)) {
50 // We can trivially use the small arg array.
51 arg_array_ = small_arg_array_;
52 } else {
53 // Analyze shorty to see if we need the large arg array.
54 for (size_t i = 1; i < shorty_len; ++i) {
55 char c = shorty[i];
56 if (c == 'J' || c == 'D') {
57 num_slots++;
58 }
59 }
60 if (num_slots <= kSmallArgArraySize) {
61 arg_array_ = small_arg_array_;
62 } else {
63 large_arg_array_.reset(new uint32_t[num_slots]);
64 arg_array_ = large_arg_array_.get();
65 }
66 }
67 }
68
GetArray()69 uint32_t* GetArray() {
70 return arg_array_;
71 }
72
GetNumBytes()73 uint32_t GetNumBytes() {
74 return num_bytes_;
75 }
76
Append(uint32_t value)77 void Append(uint32_t value) {
78 arg_array_[num_bytes_ / 4] = value;
79 num_bytes_ += 4;
80 }
81
Append(ObjPtr<mirror::Object> obj)82 void Append(ObjPtr<mirror::Object> obj) REQUIRES_SHARED(Locks::mutator_lock_) {
83 Append(StackReference<mirror::Object>::FromMirrorPtr(obj.Ptr()).AsVRegValue());
84 }
85
AppendWide(uint64_t value)86 void AppendWide(uint64_t value) {
87 arg_array_[num_bytes_ / 4] = value;
88 arg_array_[(num_bytes_ / 4) + 1] = value >> 32;
89 num_bytes_ += 8;
90 }
91
AppendFloat(float value)92 void AppendFloat(float value) {
93 jvalue jv;
94 jv.f = value;
95 Append(jv.i);
96 }
97
AppendDouble(double value)98 void AppendDouble(double value) {
99 jvalue jv;
100 jv.d = value;
101 AppendWide(jv.j);
102 }
103
BuildArgArrayFromVarArgs(const ScopedObjectAccessAlreadyRunnable & soa,ObjPtr<mirror::Object> receiver,va_list ap)104 void BuildArgArrayFromVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
105 ObjPtr<mirror::Object> receiver,
106 va_list ap)
107 REQUIRES_SHARED(Locks::mutator_lock_) {
108 // Set receiver if non-null (method is not static)
109 if (receiver != nullptr) {
110 Append(receiver);
111 }
112 for (size_t i = 1; i < shorty_len_; ++i) {
113 switch (shorty_[i]) {
114 case 'Z':
115 case 'B':
116 case 'C':
117 case 'S':
118 case 'I':
119 Append(va_arg(ap, jint));
120 break;
121 case 'F':
122 AppendFloat(va_arg(ap, jdouble));
123 break;
124 case 'L':
125 Append(soa.Decode<mirror::Object>(va_arg(ap, jobject)));
126 break;
127 case 'D':
128 AppendDouble(va_arg(ap, jdouble));
129 break;
130 case 'J':
131 AppendWide(va_arg(ap, jlong));
132 break;
133 #ifndef NDEBUG
134 default:
135 LOG(FATAL) << "Unexpected shorty character: " << shorty_[i];
136 #endif
137 }
138 }
139 }
140
BuildArgArrayFromJValues(const ScopedObjectAccessAlreadyRunnable & soa,ObjPtr<mirror::Object> receiver,const jvalue * args)141 void BuildArgArrayFromJValues(const ScopedObjectAccessAlreadyRunnable& soa,
142 ObjPtr<mirror::Object> receiver, const jvalue* args)
143 REQUIRES_SHARED(Locks::mutator_lock_) {
144 // Set receiver if non-null (method is not static)
145 if (receiver != nullptr) {
146 Append(receiver);
147 }
148 for (size_t i = 1, args_offset = 0; i < shorty_len_; ++i, ++args_offset) {
149 switch (shorty_[i]) {
150 case 'Z':
151 Append(args[args_offset].z);
152 break;
153 case 'B':
154 Append(args[args_offset].b);
155 break;
156 case 'C':
157 Append(args[args_offset].c);
158 break;
159 case 'S':
160 Append(args[args_offset].s);
161 break;
162 case 'I':
163 FALLTHROUGH_INTENDED;
164 case 'F':
165 Append(args[args_offset].i);
166 break;
167 case 'L':
168 Append(soa.Decode<mirror::Object>(args[args_offset].l));
169 break;
170 case 'D':
171 FALLTHROUGH_INTENDED;
172 case 'J':
173 AppendWide(args[args_offset].j);
174 break;
175 #ifndef NDEBUG
176 default:
177 LOG(FATAL) << "Unexpected shorty character: " << shorty_[i];
178 #endif
179 }
180 }
181 }
182
BuildArgArrayFromFrame(ShadowFrame * shadow_frame,uint32_t arg_offset)183 void BuildArgArrayFromFrame(ShadowFrame* shadow_frame, uint32_t arg_offset)
184 REQUIRES_SHARED(Locks::mutator_lock_) {
185 // Set receiver if non-null (method is not static)
186 size_t cur_arg = arg_offset;
187 if (!shadow_frame->GetMethod()->IsStatic()) {
188 Append(shadow_frame->GetVReg(cur_arg));
189 cur_arg++;
190 }
191 for (size_t i = 1; i < shorty_len_; ++i) {
192 switch (shorty_[i]) {
193 case 'Z':
194 case 'B':
195 case 'C':
196 case 'S':
197 case 'I':
198 case 'F':
199 case 'L':
200 Append(shadow_frame->GetVReg(cur_arg));
201 cur_arg++;
202 break;
203 case 'D':
204 case 'J':
205 AppendWide(shadow_frame->GetVRegLong(cur_arg));
206 cur_arg++;
207 cur_arg++;
208 break;
209 #ifndef NDEBUG
210 default:
211 LOG(FATAL) << "Unexpected shorty character: " << shorty_[i];
212 #endif
213 }
214 }
215 }
216
ThrowIllegalPrimitiveArgumentException(const char * expected,const char * found_descriptor)217 static void ThrowIllegalPrimitiveArgumentException(const char* expected,
218 const char* found_descriptor)
219 REQUIRES_SHARED(Locks::mutator_lock_) {
220 ThrowIllegalArgumentException(
221 StringPrintf("Invalid primitive conversion from %s to %s", expected,
222 PrettyDescriptor(found_descriptor).c_str()).c_str());
223 }
224
BuildArgArrayFromObjectArray(ObjPtr<mirror::Object> receiver,ObjPtr<mirror::ObjectArray<mirror::Object>> raw_args,ArtMethod * m,Thread * self)225 bool BuildArgArrayFromObjectArray(ObjPtr<mirror::Object> receiver,
226 ObjPtr<mirror::ObjectArray<mirror::Object>> raw_args,
227 ArtMethod* m,
228 Thread* self)
229 REQUIRES_SHARED(Locks::mutator_lock_) {
230 const dex::TypeList* classes = m->GetParameterTypeList();
231 // Set receiver if non-null (method is not static)
232 if (receiver != nullptr) {
233 Append(receiver);
234 }
235 StackHandleScope<2> hs(self);
236 MutableHandle<mirror::Object> arg(hs.NewHandle<mirror::Object>(nullptr));
237 Handle<mirror::ObjectArray<mirror::Object>> args(
238 hs.NewHandle<mirror::ObjectArray<mirror::Object>>(raw_args));
239 for (size_t i = 1, args_offset = 0; i < shorty_len_; ++i, ++args_offset) {
240 arg.Assign(args->Get(args_offset));
241 if (((shorty_[i] == 'L') && (arg != nullptr)) ||
242 ((arg == nullptr && shorty_[i] != 'L'))) {
243 // TODO: The method's parameter's type must have been previously resolved, yet
244 // we've seen cases where it's not b/34440020.
245 ObjPtr<mirror::Class> dst_class(
246 m->ResolveClassFromTypeIndex(classes->GetTypeItem(args_offset).type_idx_));
247 if (dst_class == nullptr) {
248 CHECK(self->IsExceptionPending());
249 return false;
250 }
251 if (UNLIKELY(arg == nullptr || !arg->InstanceOf(dst_class))) {
252 ThrowIllegalArgumentException(
253 StringPrintf("method %s argument %zd has type %s, got %s",
254 m->PrettyMethod(false).c_str(),
255 args_offset + 1, // Humans don't count from 0.
256 mirror::Class::PrettyDescriptor(dst_class).c_str(),
257 mirror::Object::PrettyTypeOf(arg.Get()).c_str()).c_str());
258 return false;
259 }
260 }
261
262 #define DO_FIRST_ARG(match_descriptor, get_fn, append) { \
263 if (LIKELY(arg != nullptr && \
264 arg->GetClass()->DescriptorEquals(match_descriptor))) { \
265 ArtField* primitive_field = arg->GetClass()->GetInstanceField(0); \
266 append(primitive_field-> get_fn(arg.Get()));
267
268 #define DO_ARG(match_descriptor, get_fn, append) \
269 } else if (LIKELY(arg != nullptr && \
270 arg->GetClass<>()->DescriptorEquals(match_descriptor))) { \
271 ArtField* primitive_field = arg->GetClass()->GetInstanceField(0); \
272 append(primitive_field-> get_fn(arg.Get()));
273
274 #define DO_FAIL(expected) \
275 } else { \
276 if (arg->GetClass<>()->IsPrimitive()) { \
277 std::string temp; \
278 ThrowIllegalPrimitiveArgumentException(expected, \
279 arg->GetClass<>()->GetDescriptor(&temp)); \
280 } else { \
281 ThrowIllegalArgumentException(\
282 StringPrintf("method %s argument %zd has type %s, got %s", \
283 ArtMethod::PrettyMethod(m, false).c_str(), \
284 args_offset + 1, \
285 expected, \
286 mirror::Object::PrettyTypeOf(arg.Get()).c_str()).c_str()); \
287 } \
288 return false; \
289 } }
290
291 switch (shorty_[i]) {
292 case 'L':
293 Append(arg.Get());
294 break;
295 case 'Z':
296 DO_FIRST_ARG("Ljava/lang/Boolean;", GetBoolean, Append)
297 DO_FAIL("boolean")
298 break;
299 case 'B':
300 DO_FIRST_ARG("Ljava/lang/Byte;", GetByte, Append)
301 DO_FAIL("byte")
302 break;
303 case 'C':
304 DO_FIRST_ARG("Ljava/lang/Character;", GetChar, Append)
305 DO_FAIL("char")
306 break;
307 case 'S':
308 DO_FIRST_ARG("Ljava/lang/Short;", GetShort, Append)
309 DO_ARG("Ljava/lang/Byte;", GetByte, Append)
310 DO_FAIL("short")
311 break;
312 case 'I':
313 DO_FIRST_ARG("Ljava/lang/Integer;", GetInt, Append)
314 DO_ARG("Ljava/lang/Character;", GetChar, Append)
315 DO_ARG("Ljava/lang/Short;", GetShort, Append)
316 DO_ARG("Ljava/lang/Byte;", GetByte, Append)
317 DO_FAIL("int")
318 break;
319 case 'J':
320 DO_FIRST_ARG("Ljava/lang/Long;", GetLong, AppendWide)
321 DO_ARG("Ljava/lang/Integer;", GetInt, AppendWide)
322 DO_ARG("Ljava/lang/Character;", GetChar, AppendWide)
323 DO_ARG("Ljava/lang/Short;", GetShort, AppendWide)
324 DO_ARG("Ljava/lang/Byte;", GetByte, AppendWide)
325 DO_FAIL("long")
326 break;
327 case 'F':
328 DO_FIRST_ARG("Ljava/lang/Float;", GetFloat, AppendFloat)
329 DO_ARG("Ljava/lang/Long;", GetLong, AppendFloat)
330 DO_ARG("Ljava/lang/Integer;", GetInt, AppendFloat)
331 DO_ARG("Ljava/lang/Character;", GetChar, AppendFloat)
332 DO_ARG("Ljava/lang/Short;", GetShort, AppendFloat)
333 DO_ARG("Ljava/lang/Byte;", GetByte, AppendFloat)
334 DO_FAIL("float")
335 break;
336 case 'D':
337 DO_FIRST_ARG("Ljava/lang/Double;", GetDouble, AppendDouble)
338 DO_ARG("Ljava/lang/Float;", GetFloat, AppendDouble)
339 DO_ARG("Ljava/lang/Long;", GetLong, AppendDouble)
340 DO_ARG("Ljava/lang/Integer;", GetInt, AppendDouble)
341 DO_ARG("Ljava/lang/Character;", GetChar, AppendDouble)
342 DO_ARG("Ljava/lang/Short;", GetShort, AppendDouble)
343 DO_ARG("Ljava/lang/Byte;", GetByte, AppendDouble)
344 DO_FAIL("double")
345 break;
346 #ifndef NDEBUG
347 default:
348 LOG(FATAL) << "Unexpected shorty character: " << shorty_[i];
349 UNREACHABLE();
350 #endif
351 }
352 #undef DO_FIRST_ARG
353 #undef DO_ARG
354 #undef DO_FAIL
355 }
356 return true;
357 }
358
359 private:
360 enum { kSmallArgArraySize = 16 };
361 const char* const shorty_;
362 const uint32_t shorty_len_;
363 uint32_t num_bytes_;
364 uint32_t* arg_array_;
365 uint32_t small_arg_array_[kSmallArgArraySize];
366 std::unique_ptr<uint32_t[]> large_arg_array_;
367 };
368
CheckMethodArguments(JavaVMExt * vm,ArtMethod * m,uint32_t * args)369 void CheckMethodArguments(JavaVMExt* vm, ArtMethod* m, uint32_t* args)
370 REQUIRES_SHARED(Locks::mutator_lock_) {
371 const dex::TypeList* params = m->GetParameterTypeList();
372 if (params == nullptr) {
373 return; // No arguments so nothing to check.
374 }
375 uint32_t offset = 0;
376 uint32_t num_params = params->Size();
377 size_t error_count = 0;
378 if (!m->IsStatic()) {
379 offset = 1;
380 }
381 // TODO: If args contain object references, it may cause problems.
382 Thread* const self = Thread::Current();
383 for (uint32_t i = 0; i < num_params; i++) {
384 dex::TypeIndex type_idx = params->GetTypeItem(i).type_idx_;
385 ObjPtr<mirror::Class> param_type(m->ResolveClassFromTypeIndex(type_idx));
386 if (param_type == nullptr) {
387 CHECK(self->IsExceptionPending());
388 LOG(ERROR) << "Internal error: unresolvable type for argument type in JNI invoke: "
389 << m->GetTypeDescriptorFromTypeIdx(type_idx) << "\n"
390 << self->GetException()->Dump();
391 self->ClearException();
392 ++error_count;
393 } else if (!param_type->IsPrimitive()) {
394 // TODO: There is a compaction bug here since GetClassFromTypeIdx can cause thread suspension,
395 // this is a hard to fix problem since the args can contain Object*, we need to save and
396 // restore them by using a visitor similar to the ones used in the trampoline entrypoints.
397 ObjPtr<mirror::Object> argument =
398 (reinterpret_cast<StackReference<mirror::Object>*>(&args[i + offset]))->AsMirrorPtr();
399 if (argument != nullptr && !argument->InstanceOf(param_type)) {
400 LOG(ERROR) << "JNI ERROR (app bug): attempt to pass an instance of "
401 << argument->PrettyTypeOf() << " as argument " << (i + 1)
402 << " to " << m->PrettyMethod();
403 ++error_count;
404 }
405 } else if (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble()) {
406 offset++;
407 } else {
408 int32_t arg = static_cast<int32_t>(args[i + offset]);
409 if (param_type->IsPrimitiveBoolean()) {
410 if (arg != JNI_TRUE && arg != JNI_FALSE) {
411 LOG(ERROR) << "JNI ERROR (app bug): expected jboolean (0/1) but got value of "
412 << arg << " as argument " << (i + 1) << " to " << m->PrettyMethod();
413 ++error_count;
414 }
415 } else if (param_type->IsPrimitiveByte()) {
416 if (arg < -128 || arg > 127) {
417 LOG(ERROR) << "JNI ERROR (app bug): expected jbyte but got value of "
418 << arg << " as argument " << (i + 1) << " to " << m->PrettyMethod();
419 ++error_count;
420 }
421 } else if (param_type->IsPrimitiveChar()) {
422 if (args[i + offset] > 0xFFFF) {
423 LOG(ERROR) << "JNI ERROR (app bug): expected jchar but got value of "
424 << arg << " as argument " << (i + 1) << " to " << m->PrettyMethod();
425 ++error_count;
426 }
427 } else if (param_type->IsPrimitiveShort()) {
428 if (arg < -32768 || arg > 0x7FFF) {
429 LOG(ERROR) << "JNI ERROR (app bug): expected jshort but got value of "
430 << arg << " as argument " << (i + 1) << " to " << m->PrettyMethod();
431 ++error_count;
432 }
433 }
434 }
435 }
436 if (UNLIKELY(error_count > 0)) {
437 // TODO: pass the JNI function name (such as "CallVoidMethodV") through so we can call JniAbort
438 // with an argument.
439 vm->JniAbortF(nullptr, "bad arguments passed to %s (see above for details)",
440 m->PrettyMethod().c_str());
441 }
442 }
443
FindVirtualMethod(ObjPtr<mirror::Object> receiver,ArtMethod * method)444 ArtMethod* FindVirtualMethod(ObjPtr<mirror::Object> receiver, ArtMethod* method)
445 REQUIRES_SHARED(Locks::mutator_lock_) {
446 return receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(method, kRuntimePointerSize);
447 }
448
449
InvokeWithArgArray(const ScopedObjectAccessAlreadyRunnable & soa,ArtMethod * method,ArgArray * arg_array,JValue * result,const char * shorty)450 void InvokeWithArgArray(const ScopedObjectAccessAlreadyRunnable& soa,
451 ArtMethod* method, ArgArray* arg_array, JValue* result,
452 const char* shorty)
453 REQUIRES_SHARED(Locks::mutator_lock_) {
454 uint32_t* args = arg_array->GetArray();
455 if (UNLIKELY(soa.Env()->IsCheckJniEnabled())) {
456 CheckMethodArguments(soa.Vm(), method->GetInterfaceMethodIfProxy(kRuntimePointerSize), args);
457 }
458 method->Invoke(soa.Self(), args, arg_array->GetNumBytes(), result, shorty);
459 }
460
461 ALWAYS_INLINE
CheckArgsForInvokeMethod(ArtMethod * np_method,ObjPtr<mirror::ObjectArray<mirror::Object>> objects)462 bool CheckArgsForInvokeMethod(ArtMethod* np_method,
463 ObjPtr<mirror::ObjectArray<mirror::Object>> objects)
464 REQUIRES_SHARED(Locks::mutator_lock_) {
465 const dex::TypeList* classes = np_method->GetParameterTypeList();
466 uint32_t classes_size = (classes == nullptr) ? 0 : classes->Size();
467 uint32_t arg_count = (objects == nullptr) ? 0 : objects->GetLength();
468 if (UNLIKELY(arg_count != classes_size)) {
469 ThrowIllegalArgumentException(StringPrintf("Wrong number of arguments; expected %d, got %d",
470 classes_size, arg_count).c_str());
471 return false;
472 }
473 return true;
474 }
475
476 ALWAYS_INLINE
InvokeMethodImpl(const ScopedObjectAccessAlreadyRunnable & soa,ArtMethod * m,ArtMethod * np_method,ObjPtr<mirror::Object> receiver,ObjPtr<mirror::ObjectArray<mirror::Object>> objects,const char ** shorty,JValue * result)477 bool InvokeMethodImpl(const ScopedObjectAccessAlreadyRunnable& soa,
478 ArtMethod* m,
479 ArtMethod* np_method,
480 ObjPtr<mirror::Object> receiver,
481 ObjPtr<mirror::ObjectArray<mirror::Object>> objects,
482 const char** shorty,
483 JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) {
484 // Invoke the method.
485 uint32_t shorty_len = 0;
486 *shorty = np_method->GetShorty(&shorty_len);
487 ArgArray arg_array(*shorty, shorty_len);
488 if (!arg_array.BuildArgArrayFromObjectArray(receiver, objects, np_method, soa.Self())) {
489 CHECK(soa.Self()->IsExceptionPending());
490 return false;
491 }
492
493 InvokeWithArgArray(soa, m, &arg_array, result, *shorty);
494
495 // Wrap any exception with "Ljava/lang/reflect/InvocationTargetException;" and return early.
496 if (soa.Self()->IsExceptionPending()) {
497 // To abort a transaction we use a fake exception that should never be caught by the bytecode
498 // and therefore it makes no sense to wrap it.
499 if (Runtime::Current()->IsTransactionAborted()) {
500 DCHECK(soa.Self()->GetException()->GetClass()->DescriptorEquals(
501 "Ldalvik/system/TransactionAbortError;"))
502 << soa.Self()->GetException()->GetClass()->PrettyDescriptor();
503 } else {
504 // If we get another exception when we are trying to wrap, then just use that instead.
505 ScopedLocalRef<jthrowable> th(soa.Env(), soa.Env()->ExceptionOccurred());
506 soa.Self()->ClearException();
507 jobject exception_instance =
508 soa.Env()->NewObject(WellKnownClasses::java_lang_reflect_InvocationTargetException,
509 WellKnownClasses::java_lang_reflect_InvocationTargetException_init,
510 th.get());
511 if (exception_instance == nullptr) {
512 soa.Self()->AssertPendingException();
513 return false;
514 }
515 soa.Env()->Throw(reinterpret_cast<jthrowable>(exception_instance));
516 }
517 return false;
518 }
519
520 return true;
521 }
522
523 } // anonymous namespace
524
525 template <>
InvokeWithVarArgs(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,ArtMethod * method,va_list args)526 JValue InvokeWithVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
527 jobject obj,
528 ArtMethod* method,
529 va_list args) REQUIRES_SHARED(Locks::mutator_lock_) {
530 // We want to make sure that the stack is not within a small distance from the
531 // protected region in case we are calling into a leaf function whose stack
532 // check has been elided.
533 if (UNLIKELY(__builtin_frame_address(0) < soa.Self()->GetStackEnd())) {
534 ThrowStackOverflowError(soa.Self());
535 return JValue();
536 }
537 bool is_string_init = method->GetDeclaringClass()->IsStringClass() && method->IsConstructor();
538 if (is_string_init) {
539 // Replace calls to String.<init> with equivalent StringFactory call.
540 method = WellKnownClasses::StringInitToStringFactory(method);
541 }
542 ObjPtr<mirror::Object> receiver = method->IsStatic() ? nullptr : soa.Decode<mirror::Object>(obj);
543 uint32_t shorty_len = 0;
544 const char* shorty =
545 method->GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(&shorty_len);
546 JValue result;
547 ArgArray arg_array(shorty, shorty_len);
548 arg_array.BuildArgArrayFromVarArgs(soa, receiver, args);
549 InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
550 if (is_string_init) {
551 // For string init, remap original receiver to StringFactory result.
552 UpdateReference(soa.Self(), obj, result.GetL());
553 }
554 return result;
555 }
556
557 template <>
InvokeWithVarArgs(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,jmethodID mid,va_list args)558 JValue InvokeWithVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
559 jobject obj,
560 jmethodID mid,
561 va_list args) REQUIRES_SHARED(Locks::mutator_lock_) {
562 DCHECK(mid != nullptr) << "Called with null jmethodID";
563 return InvokeWithVarArgs(soa, obj, jni::DecodeArtMethod(mid), args);
564 }
565
566 template <>
InvokeWithJValues(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,ArtMethod * method,const jvalue * args)567 JValue InvokeWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
568 jobject obj,
569 ArtMethod* method,
570 const jvalue* args) {
571 // We want to make sure that the stack is not within a small distance from the
572 // protected region in case we are calling into a leaf function whose stack
573 // check has been elided.
574 if (UNLIKELY(__builtin_frame_address(0) < soa.Self()->GetStackEnd())) {
575 ThrowStackOverflowError(soa.Self());
576 return JValue();
577 }
578 bool is_string_init = method->GetDeclaringClass()->IsStringClass() && method->IsConstructor();
579 if (is_string_init) {
580 // Replace calls to String.<init> with equivalent StringFactory call.
581 method = WellKnownClasses::StringInitToStringFactory(method);
582 }
583 ObjPtr<mirror::Object> receiver = method->IsStatic() ? nullptr : soa.Decode<mirror::Object>(obj);
584 uint32_t shorty_len = 0;
585 const char* shorty =
586 method->GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(&shorty_len);
587 JValue result;
588 ArgArray arg_array(shorty, shorty_len);
589 arg_array.BuildArgArrayFromJValues(soa, receiver, args);
590 InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
591 if (is_string_init) {
592 // For string init, remap original receiver to StringFactory result.
593 UpdateReference(soa.Self(), obj, result.GetL());
594 }
595 return result;
596 }
597
598 template <>
InvokeWithJValues(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,jmethodID mid,const jvalue * args)599 JValue InvokeWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
600 jobject obj,
601 jmethodID mid,
602 const jvalue* args) {
603 DCHECK(mid != nullptr) << "Called with null jmethodID";
604 return InvokeWithJValues(soa, obj, jni::DecodeArtMethod(mid), args);
605 }
606
607 template <>
InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,ArtMethod * interface_method,const jvalue * args)608 JValue InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
609 jobject obj,
610 ArtMethod* interface_method,
611 const jvalue* args) {
612 // We want to make sure that the stack is not within a small distance from the
613 // protected region in case we are calling into a leaf function whose stack
614 // check has been elided.
615 if (UNLIKELY(__builtin_frame_address(0) < soa.Self()->GetStackEnd())) {
616 ThrowStackOverflowError(soa.Self());
617 return JValue();
618 }
619 ObjPtr<mirror::Object> receiver = soa.Decode<mirror::Object>(obj);
620 ArtMethod* method = FindVirtualMethod(receiver, interface_method);
621 bool is_string_init = method->GetDeclaringClass()->IsStringClass() && method->IsConstructor();
622 if (is_string_init) {
623 // Replace calls to String.<init> with equivalent StringFactory call.
624 method = WellKnownClasses::StringInitToStringFactory(method);
625 receiver = nullptr;
626 }
627 uint32_t shorty_len = 0;
628 const char* shorty =
629 method->GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(&shorty_len);
630 JValue result;
631 ArgArray arg_array(shorty, shorty_len);
632 arg_array.BuildArgArrayFromJValues(soa, receiver, args);
633 InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
634 if (is_string_init) {
635 // For string init, remap original receiver to StringFactory result.
636 UpdateReference(soa.Self(), obj, result.GetL());
637 }
638 return result;
639 }
640
641 template <>
InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,jmethodID mid,const jvalue * args)642 JValue InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
643 jobject obj,
644 jmethodID mid,
645 const jvalue* args) {
646 DCHECK(mid != nullptr) << "Called with null jmethodID";
647 return InvokeVirtualOrInterfaceWithJValues(soa, obj, jni::DecodeArtMethod(mid), args);
648 }
649
650 template <>
InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,ArtMethod * interface_method,va_list args)651 JValue InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
652 jobject obj,
653 ArtMethod* interface_method,
654 va_list args) {
655 // We want to make sure that the stack is not within a small distance from the
656 // protected region in case we are calling into a leaf function whose stack
657 // check has been elided.
658 if (UNLIKELY(__builtin_frame_address(0) < soa.Self()->GetStackEnd())) {
659 ThrowStackOverflowError(soa.Self());
660 return JValue();
661 }
662
663 ObjPtr<mirror::Object> receiver = soa.Decode<mirror::Object>(obj);
664 ArtMethod* method = FindVirtualMethod(receiver, interface_method);
665 bool is_string_init = method->GetDeclaringClass()->IsStringClass() && method->IsConstructor();
666 if (is_string_init) {
667 // Replace calls to String.<init> with equivalent StringFactory call.
668 method = WellKnownClasses::StringInitToStringFactory(method);
669 receiver = nullptr;
670 }
671 uint32_t shorty_len = 0;
672 const char* shorty =
673 method->GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(&shorty_len);
674 JValue result;
675 ArgArray arg_array(shorty, shorty_len);
676 arg_array.BuildArgArrayFromVarArgs(soa, receiver, args);
677 InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
678 if (is_string_init) {
679 // For string init, remap original receiver to StringFactory result.
680 UpdateReference(soa.Self(), obj, result.GetL());
681 }
682 return result;
683 }
684
685 template <>
InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccessAlreadyRunnable & soa,jobject obj,jmethodID mid,va_list args)686 JValue InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccessAlreadyRunnable& soa,
687 jobject obj,
688 jmethodID mid,
689 va_list args) {
690 DCHECK(mid != nullptr) << "Called with null jmethodID";
691 return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, jni::DecodeArtMethod(mid), args);
692 }
693
694 template <PointerSize kPointerSize>
InvokeMethod(const ScopedObjectAccessAlreadyRunnable & soa,jobject javaMethod,jobject javaReceiver,jobject javaArgs,size_t num_frames)695 jobject InvokeMethod(const ScopedObjectAccessAlreadyRunnable& soa, jobject javaMethod,
696 jobject javaReceiver, jobject javaArgs, size_t num_frames) {
697 // We want to make sure that the stack is not within a small distance from the
698 // protected region in case we are calling into a leaf function whose stack
699 // check has been elided.
700 if (UNLIKELY(__builtin_frame_address(0) <
701 soa.Self()->GetStackEndForInterpreter(true))) {
702 ThrowStackOverflowError(soa.Self());
703 return nullptr;
704 }
705
706 ObjPtr<mirror::Executable> executable = soa.Decode<mirror::Executable>(javaMethod);
707 const bool accessible = executable->IsAccessible();
708 ArtMethod* m = executable->GetArtMethod();
709
710 ObjPtr<mirror::Class> declaring_class = m->GetDeclaringClass();
711 if (UNLIKELY(!declaring_class->IsVisiblyInitialized())) {
712 Thread* self = soa.Self();
713 StackHandleScope<1> hs(self);
714 HandleWrapperObjPtr<mirror::Class> h_class(hs.NewHandleWrapper(&declaring_class));
715 if (UNLIKELY(!Runtime::Current()->GetClassLinker()->EnsureInitialized(
716 self, h_class, /*can_init_fields=*/ true, /*can_init_parents=*/ true))) {
717 DCHECK(self->IsExceptionPending());
718 return nullptr;
719 }
720 DCHECK(h_class->IsInitializing());
721 }
722
723 ObjPtr<mirror::Object> receiver;
724 if (!m->IsStatic()) {
725 // Replace calls to String.<init> with equivalent StringFactory call.
726 if (declaring_class->IsStringClass() && m->IsConstructor()) {
727 m = WellKnownClasses::StringInitToStringFactory(m);
728 CHECK(javaReceiver == nullptr);
729 } else {
730 // Check that the receiver is non-null and an instance of the field's declaring class.
731 receiver = soa.Decode<mirror::Object>(javaReceiver);
732 if (!VerifyObjectIsClass(receiver, declaring_class)) {
733 return nullptr;
734 }
735
736 // Find the actual implementation of the virtual method.
737 m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(m, kPointerSize);
738 }
739 }
740
741 // Get our arrays of arguments and their types, and check they're the same size.
742 ObjPtr<mirror::ObjectArray<mirror::Object>> objects =
743 soa.Decode<mirror::ObjectArray<mirror::Object>>(javaArgs);
744 auto* np_method = m->GetInterfaceMethodIfProxy(kPointerSize);
745 if (!CheckArgsForInvokeMethod(np_method, objects)) {
746 return nullptr;
747 }
748
749 // If method is not set to be accessible, verify it can be accessed by the caller.
750 ObjPtr<mirror::Class> calling_class;
751 if (!accessible && !VerifyAccess(soa.Self(),
752 receiver,
753 declaring_class,
754 m->GetAccessFlags(),
755 &calling_class,
756 num_frames)) {
757 ThrowIllegalAccessException(
758 StringPrintf("Class %s cannot access %s method %s of class %s",
759 calling_class == nullptr ? "null" : calling_class->PrettyClass().c_str(),
760 PrettyJavaAccessFlags(m->GetAccessFlags()).c_str(),
761 m->PrettyMethod().c_str(),
762 m->GetDeclaringClass() == nullptr ? "null" :
763 m->GetDeclaringClass()->PrettyClass().c_str()).c_str());
764 return nullptr;
765 }
766
767 // Invoke the method.
768 JValue result;
769 const char* shorty;
770 if (!InvokeMethodImpl(soa, m, np_method, receiver, objects, &shorty, &result)) {
771 return nullptr;
772 }
773 return soa.AddLocalReference<jobject>(BoxPrimitive(Primitive::GetType(shorty[0]), result));
774 }
775
776 template
777 jobject InvokeMethod<PointerSize::k32>(const ScopedObjectAccessAlreadyRunnable& soa,
778 jobject javaMethod,
779 jobject javaReceiver,
780 jobject javaArgs,
781 size_t num_frames);
782 template
783 jobject InvokeMethod<PointerSize::k64>(const ScopedObjectAccessAlreadyRunnable& soa,
784 jobject javaMethod,
785 jobject javaReceiver,
786 jobject javaArgs,
787 size_t num_frames);
788
InvokeConstructor(const ScopedObjectAccessAlreadyRunnable & soa,ArtMethod * constructor,ObjPtr<mirror::Object> receiver,jobject javaArgs)789 void InvokeConstructor(const ScopedObjectAccessAlreadyRunnable& soa,
790 ArtMethod* constructor,
791 ObjPtr<mirror::Object> receiver,
792 jobject javaArgs) {
793 // We want to make sure that the stack is not within a small distance from the
794 // protected region in case we are calling into a leaf function whose stack
795 // check has been elided.
796 if (UNLIKELY(__builtin_frame_address(0) < soa.Self()->GetStackEndForInterpreter(true))) {
797 ThrowStackOverflowError(soa.Self());
798 return;
799 }
800
801 if (kIsDebugBuild) {
802 CHECK(constructor->IsConstructor());
803
804 ObjPtr<mirror::Class> declaring_class = constructor->GetDeclaringClass();
805 CHECK(declaring_class->IsInitializing());
806
807 // Calls to String.<init> should have been repplaced with with equivalent StringFactory calls.
808 CHECK(!declaring_class->IsStringClass());
809
810 // Check that the receiver is non-null and an instance of the field's declaring class.
811 CHECK(receiver != nullptr);
812 CHECK(VerifyObjectIsClass(receiver, declaring_class));
813 CHECK_EQ(constructor,
814 receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(constructor,
815 kRuntimePointerSize));
816 }
817
818 // Get our arrays of arguments and their types, and check they're the same size.
819 ObjPtr<mirror::ObjectArray<mirror::Object>> objects =
820 soa.Decode<mirror::ObjectArray<mirror::Object>>(javaArgs);
821 ArtMethod* np_method = constructor->GetInterfaceMethodIfProxy(kRuntimePointerSize);
822 if (!CheckArgsForInvokeMethod(np_method, objects)) {
823 return;
824 }
825
826 // Invoke the constructor.
827 JValue result;
828 const char* shorty;
829 InvokeMethodImpl(soa, constructor, np_method, receiver, objects, &shorty, &result);
830 }
831
BoxPrimitive(Primitive::Type src_class,const JValue & value)832 ObjPtr<mirror::Object> BoxPrimitive(Primitive::Type src_class, const JValue& value) {
833 if (src_class == Primitive::kPrimNot) {
834 return value.GetL();
835 }
836 if (src_class == Primitive::kPrimVoid) {
837 // There's no such thing as a void field, and void methods invoked via reflection return null.
838 return nullptr;
839 }
840
841 jmethodID m = nullptr;
842 const char* shorty;
843 switch (src_class) {
844 case Primitive::kPrimBoolean:
845 m = WellKnownClasses::java_lang_Boolean_valueOf;
846 shorty = "LZ";
847 break;
848 case Primitive::kPrimByte:
849 m = WellKnownClasses::java_lang_Byte_valueOf;
850 shorty = "LB";
851 break;
852 case Primitive::kPrimChar:
853 m = WellKnownClasses::java_lang_Character_valueOf;
854 shorty = "LC";
855 break;
856 case Primitive::kPrimDouble:
857 m = WellKnownClasses::java_lang_Double_valueOf;
858 shorty = "LD";
859 break;
860 case Primitive::kPrimFloat:
861 m = WellKnownClasses::java_lang_Float_valueOf;
862 shorty = "LF";
863 break;
864 case Primitive::kPrimInt:
865 m = WellKnownClasses::java_lang_Integer_valueOf;
866 shorty = "LI";
867 break;
868 case Primitive::kPrimLong:
869 m = WellKnownClasses::java_lang_Long_valueOf;
870 shorty = "LJ";
871 break;
872 case Primitive::kPrimShort:
873 m = WellKnownClasses::java_lang_Short_valueOf;
874 shorty = "LS";
875 break;
876 default:
877 LOG(FATAL) << static_cast<int>(src_class);
878 shorty = nullptr;
879 }
880
881 ScopedObjectAccessUnchecked soa(Thread::Current());
882 DCHECK_EQ(soa.Self()->GetState(), kRunnable);
883
884 ArgArray arg_array(shorty, 2);
885 JValue result;
886 if (src_class == Primitive::kPrimDouble || src_class == Primitive::kPrimLong) {
887 arg_array.AppendWide(value.GetJ());
888 } else {
889 arg_array.Append(value.GetI());
890 }
891
892 jni::DecodeArtMethod(m)->Invoke(soa.Self(),
893 arg_array.GetArray(),
894 arg_array.GetNumBytes(),
895 &result,
896 shorty);
897 return result.GetL();
898 }
899
UnboxingFailureKind(ArtField * f)900 static std::string UnboxingFailureKind(ArtField* f)
901 REQUIRES_SHARED(Locks::mutator_lock_) {
902 if (f != nullptr) {
903 return "field " + f->PrettyField(false);
904 }
905 return "result";
906 }
907
UnboxPrimitive(ObjPtr<mirror::Object> o,ObjPtr<mirror::Class> dst_class,ArtField * f,JValue * unboxed_value)908 static bool UnboxPrimitive(ObjPtr<mirror::Object> o,
909 ObjPtr<mirror::Class> dst_class,
910 ArtField* f,
911 JValue* unboxed_value)
912 REQUIRES_SHARED(Locks::mutator_lock_) {
913 bool unbox_for_result = (f == nullptr);
914 if (!dst_class->IsPrimitive()) {
915 if (UNLIKELY(o != nullptr && !o->InstanceOf(dst_class))) {
916 if (!unbox_for_result) {
917 ThrowIllegalArgumentException(
918 StringPrintf("%s has type %s, got %s",
919 UnboxingFailureKind(f).c_str(),
920 dst_class->PrettyDescriptor().c_str(),
921 o->PrettyTypeOf().c_str()).c_str());
922 } else {
923 ThrowClassCastException(
924 StringPrintf("Couldn't convert result of type %s to %s",
925 o->PrettyTypeOf().c_str(),
926 dst_class->PrettyDescriptor().c_str()).c_str());
927 }
928 return false;
929 }
930 unboxed_value->SetL(o);
931 return true;
932 }
933 if (UNLIKELY(dst_class->GetPrimitiveType() == Primitive::kPrimVoid)) {
934 ThrowIllegalArgumentException(StringPrintf("Can't unbox %s to void",
935 UnboxingFailureKind(f).c_str()).c_str());
936 return false;
937 }
938 if (UNLIKELY(o == nullptr)) {
939 if (!unbox_for_result) {
940 ThrowIllegalArgumentException(
941 StringPrintf("%s has type %s, got null",
942 UnboxingFailureKind(f).c_str(),
943 dst_class->PrettyDescriptor().c_str()).c_str());
944 } else {
945 ThrowNullPointerException(
946 StringPrintf("Expected to unbox a '%s' primitive type but was returned null",
947 dst_class->PrettyDescriptor().c_str()).c_str());
948 }
949 return false;
950 }
951
952 JValue boxed_value;
953 ObjPtr<mirror::Class> klass = o->GetClass();
954 Primitive::Type primitive_type;
955 ArtField* primitive_field = &klass->GetIFieldsPtr()->At(0);
956 if (klass->DescriptorEquals("Ljava/lang/Boolean;")) {
957 primitive_type = Primitive::kPrimBoolean;
958 boxed_value.SetZ(primitive_field->GetBoolean(o));
959 } else if (klass->DescriptorEquals("Ljava/lang/Byte;")) {
960 primitive_type = Primitive::kPrimByte;
961 boxed_value.SetB(primitive_field->GetByte(o));
962 } else if (klass->DescriptorEquals("Ljava/lang/Character;")) {
963 primitive_type = Primitive::kPrimChar;
964 boxed_value.SetC(primitive_field->GetChar(o));
965 } else if (klass->DescriptorEquals("Ljava/lang/Float;")) {
966 primitive_type = Primitive::kPrimFloat;
967 boxed_value.SetF(primitive_field->GetFloat(o));
968 } else if (klass->DescriptorEquals("Ljava/lang/Double;")) {
969 primitive_type = Primitive::kPrimDouble;
970 boxed_value.SetD(primitive_field->GetDouble(o));
971 } else if (klass->DescriptorEquals("Ljava/lang/Integer;")) {
972 primitive_type = Primitive::kPrimInt;
973 boxed_value.SetI(primitive_field->GetInt(o));
974 } else if (klass->DescriptorEquals("Ljava/lang/Long;")) {
975 primitive_type = Primitive::kPrimLong;
976 boxed_value.SetJ(primitive_field->GetLong(o));
977 } else if (klass->DescriptorEquals("Ljava/lang/Short;")) {
978 primitive_type = Primitive::kPrimShort;
979 boxed_value.SetS(primitive_field->GetShort(o));
980 } else {
981 std::string temp;
982 ThrowIllegalArgumentException(
983 StringPrintf("%s has type %s, got %s", UnboxingFailureKind(f).c_str(),
984 dst_class->PrettyDescriptor().c_str(),
985 PrettyDescriptor(o->GetClass()->GetDescriptor(&temp)).c_str()).c_str());
986 return false;
987 }
988
989 return ConvertPrimitiveValue(unbox_for_result,
990 primitive_type,
991 dst_class->GetPrimitiveType(),
992 boxed_value, unboxed_value);
993 }
994
UnboxPrimitiveForField(ObjPtr<mirror::Object> o,ObjPtr<mirror::Class> dst_class,ArtField * f,JValue * unboxed_value)995 bool UnboxPrimitiveForField(ObjPtr<mirror::Object> o,
996 ObjPtr<mirror::Class> dst_class,
997 ArtField* f,
998 JValue* unboxed_value) {
999 DCHECK(f != nullptr);
1000 return UnboxPrimitive(o, dst_class, f, unboxed_value);
1001 }
1002
UnboxPrimitiveForResult(ObjPtr<mirror::Object> o,ObjPtr<mirror::Class> dst_class,JValue * unboxed_value)1003 bool UnboxPrimitiveForResult(ObjPtr<mirror::Object> o,
1004 ObjPtr<mirror::Class> dst_class,
1005 JValue* unboxed_value) {
1006 return UnboxPrimitive(o, dst_class, nullptr, unboxed_value);
1007 }
1008
GetCallingClass(Thread * self,size_t num_frames)1009 ObjPtr<mirror::Class> GetCallingClass(Thread* self, size_t num_frames) {
1010 NthCallerVisitor visitor(self, num_frames);
1011 visitor.WalkStack();
1012 return visitor.caller != nullptr ? visitor.caller->GetDeclaringClass() : nullptr;
1013 }
1014
VerifyAccess(Thread * self,ObjPtr<mirror::Object> obj,ObjPtr<mirror::Class> declaring_class,uint32_t access_flags,ObjPtr<mirror::Class> * calling_class,size_t num_frames)1015 bool VerifyAccess(Thread* self,
1016 ObjPtr<mirror::Object> obj,
1017 ObjPtr<mirror::Class> declaring_class,
1018 uint32_t access_flags,
1019 ObjPtr<mirror::Class>* calling_class,
1020 size_t num_frames) {
1021 if ((access_flags & kAccPublic) != 0) {
1022 return true;
1023 }
1024 ObjPtr<mirror::Class> klass = GetCallingClass(self, num_frames);
1025 if (UNLIKELY(klass == nullptr)) {
1026 // The caller is an attached native thread.
1027 return false;
1028 }
1029 *calling_class = klass;
1030 return VerifyAccess(obj, declaring_class, access_flags, klass);
1031 }
1032
VerifyAccess(ObjPtr<mirror::Object> obj,ObjPtr<mirror::Class> declaring_class,uint32_t access_flags,ObjPtr<mirror::Class> calling_class)1033 bool VerifyAccess(ObjPtr<mirror::Object> obj,
1034 ObjPtr<mirror::Class> declaring_class,
1035 uint32_t access_flags,
1036 ObjPtr<mirror::Class> calling_class) {
1037 if (calling_class == declaring_class) {
1038 return true;
1039 }
1040 ScopedAssertNoThreadSuspension sants("verify-access");
1041 if ((access_flags & kAccPrivate) != 0) {
1042 return false;
1043 }
1044 if ((access_flags & kAccProtected) != 0) {
1045 if (obj != nullptr && !obj->InstanceOf(calling_class) &&
1046 !declaring_class->IsInSamePackage(calling_class)) {
1047 return false;
1048 } else if (declaring_class->IsAssignableFrom(calling_class)) {
1049 return true;
1050 }
1051 }
1052 return declaring_class->IsInSamePackage(calling_class);
1053 }
1054
InvalidReceiverError(ObjPtr<mirror::Object> o,ObjPtr<mirror::Class> c)1055 void InvalidReceiverError(ObjPtr<mirror::Object> o, ObjPtr<mirror::Class> c) {
1056 std::string expected_class_name(mirror::Class::PrettyDescriptor(c));
1057 std::string actual_class_name(mirror::Object::PrettyTypeOf(o));
1058 ThrowIllegalArgumentException(StringPrintf("Expected receiver of type %s, but got %s",
1059 expected_class_name.c_str(),
1060 actual_class_name.c_str()).c_str());
1061 }
1062
1063 // This only works if there's one reference which points to the object in obj.
1064 // Will need to be fixed if there's cases where it's not.
UpdateReference(Thread * self,jobject obj,ObjPtr<mirror::Object> result)1065 void UpdateReference(Thread* self, jobject obj, ObjPtr<mirror::Object> result) {
1066 IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
1067 IndirectRefKind kind = IndirectReferenceTable::GetIndirectRefKind(ref);
1068 if (kind == kLocal) {
1069 self->GetJniEnv()->UpdateLocal(obj, result);
1070 } else if (kind == kJniTransitionOrInvalid) {
1071 LOG(FATAL) << "Unsupported UpdateReference for kind kJniTransitionOrInvalid";
1072 } else if (kind == kGlobal) {
1073 self->GetJniEnv()->GetVm()->UpdateGlobal(self, ref, result);
1074 } else {
1075 DCHECK_EQ(kind, kWeakGlobal);
1076 self->GetJniEnv()->GetVm()->UpdateWeakGlobal(self, ref, result);
1077 }
1078 }
1079
1080 } // namespace art
1081