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.h"
18
19 #include "class_linker.h"
20 #include "common_throws.h"
21 #include "dex_file-inl.h"
22 #include "invoke_arg_array_builder.h"
23 #include "jni_internal.h"
24 #include "mirror/art_field-inl.h"
25 #include "mirror/art_method-inl.h"
26 #include "mirror/class.h"
27 #include "mirror/class-inl.h"
28 #include "mirror/object_array.h"
29 #include "mirror/object_array-inl.h"
30 #include "object_utils.h"
31 #include "scoped_thread_state_change.h"
32 #include "well_known_classes.h"
33
34 namespace art {
35
InvokeMethod(const ScopedObjectAccess & soa,jobject javaMethod,jobject javaReceiver,jobject javaArgs)36 jobject InvokeMethod(const ScopedObjectAccess& soa, jobject javaMethod, jobject javaReceiver,
37 jobject javaArgs) {
38 jmethodID mid = soa.Env()->FromReflectedMethod(javaMethod);
39 mirror::ArtMethod* m = soa.DecodeMethod(mid);
40
41 mirror::Class* declaring_class = m->GetDeclaringClass();
42 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(declaring_class, true, true)) {
43 return NULL;
44 }
45
46 mirror::Object* receiver = NULL;
47 if (!m->IsStatic()) {
48 // Check that the receiver is non-null and an instance of the field's declaring class.
49 receiver = soa.Decode<mirror::Object*>(javaReceiver);
50 if (!VerifyObjectInClass(receiver, declaring_class)) {
51 return NULL;
52 }
53
54 // Find the actual implementation of the virtual method.
55 m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(m);
56 mid = soa.EncodeMethod(m);
57 }
58
59 // Get our arrays of arguments and their types, and check they're the same size.
60 mirror::ObjectArray<mirror::Object>* objects =
61 soa.Decode<mirror::ObjectArray<mirror::Object>*>(javaArgs);
62 MethodHelper mh(m);
63 const DexFile::TypeList* classes = mh.GetParameterTypeList();
64 uint32_t classes_size = classes == NULL ? 0 : classes->Size();
65 uint32_t arg_count = (objects != NULL) ? objects->GetLength() : 0;
66 if (arg_count != classes_size) {
67 ThrowIllegalArgumentException(NULL,
68 StringPrintf("Wrong number of arguments; expected %d, got %d",
69 classes_size, arg_count).c_str());
70 return NULL;
71 }
72
73 // Translate javaArgs to a jvalue[].
74 UniquePtr<jvalue[]> args(new jvalue[arg_count]);
75 JValue* decoded_args = reinterpret_cast<JValue*>(args.get());
76 for (uint32_t i = 0; i < arg_count; ++i) {
77 mirror::Object* arg = objects->Get(i);
78 mirror::Class* dst_class = mh.GetClassFromTypeIdx(classes->GetTypeItem(i).type_idx_);
79 if (!UnboxPrimitiveForArgument(arg, dst_class, decoded_args[i], m, i)) {
80 return NULL;
81 }
82 if (!dst_class->IsPrimitive()) {
83 args[i].l = soa.AddLocalReference<jobject>(arg);
84 }
85 }
86
87 // Invoke the method.
88 JValue value(InvokeWithJValues(soa, javaReceiver, mid, args.get()));
89
90 // Wrap any exception with "Ljava/lang/reflect/InvocationTargetException;" and return early.
91 if (soa.Self()->IsExceptionPending()) {
92 jthrowable th = soa.Env()->ExceptionOccurred();
93 soa.Env()->ExceptionClear();
94 jclass exception_class = soa.Env()->FindClass("java/lang/reflect/InvocationTargetException");
95 jmethodID mid = soa.Env()->GetMethodID(exception_class, "<init>", "(Ljava/lang/Throwable;)V");
96 jobject exception_instance = soa.Env()->NewObject(exception_class, mid, th);
97 soa.Env()->Throw(reinterpret_cast<jthrowable>(exception_instance));
98 return NULL;
99 }
100
101 // Box if necessary and return.
102 return soa.AddLocalReference<jobject>(BoxPrimitive(mh.GetReturnType()->GetPrimitiveType(), value));
103 }
104
VerifyObjectInClass(mirror::Object * o,mirror::Class * c)105 bool VerifyObjectInClass(mirror::Object* o, mirror::Class* c) {
106 if (o == NULL) {
107 ThrowNullPointerException(NULL, "null receiver");
108 return false;
109 } else if (!o->InstanceOf(c)) {
110 std::string expected_class_name(PrettyDescriptor(c));
111 std::string actual_class_name(PrettyTypeOf(o));
112 ThrowIllegalArgumentException(NULL,
113 StringPrintf("Expected receiver of type %s, but got %s",
114 expected_class_name.c_str(),
115 actual_class_name.c_str()).c_str());
116 return false;
117 }
118 return true;
119 }
120
ConvertPrimitiveValue(const ThrowLocation * throw_location,bool unbox_for_result,Primitive::Type srcType,Primitive::Type dstType,const JValue & src,JValue & dst)121 bool ConvertPrimitiveValue(const ThrowLocation* throw_location, bool unbox_for_result,
122 Primitive::Type srcType, Primitive::Type dstType,
123 const JValue& src, JValue& dst) {
124 CHECK(srcType != Primitive::kPrimNot && dstType != Primitive::kPrimNot);
125 switch (dstType) {
126 case Primitive::kPrimBoolean:
127 if (srcType == Primitive::kPrimBoolean) {
128 dst.SetZ(src.GetZ());
129 return true;
130 }
131 break;
132 case Primitive::kPrimChar:
133 if (srcType == Primitive::kPrimChar) {
134 dst.SetC(src.GetC());
135 return true;
136 }
137 break;
138 case Primitive::kPrimByte:
139 if (srcType == Primitive::kPrimByte) {
140 dst.SetB(src.GetB());
141 return true;
142 }
143 break;
144 case Primitive::kPrimShort:
145 if (srcType == Primitive::kPrimByte || srcType == Primitive::kPrimShort) {
146 dst.SetS(src.GetI());
147 return true;
148 }
149 break;
150 case Primitive::kPrimInt:
151 if (srcType == Primitive::kPrimByte || srcType == Primitive::kPrimChar ||
152 srcType == Primitive::kPrimShort || srcType == Primitive::kPrimInt) {
153 dst.SetI(src.GetI());
154 return true;
155 }
156 break;
157 case Primitive::kPrimLong:
158 if (srcType == Primitive::kPrimByte || srcType == Primitive::kPrimChar ||
159 srcType == Primitive::kPrimShort || srcType == Primitive::kPrimInt) {
160 dst.SetJ(src.GetI());
161 return true;
162 } else if (srcType == Primitive::kPrimLong) {
163 dst.SetJ(src.GetJ());
164 return true;
165 }
166 break;
167 case Primitive::kPrimFloat:
168 if (srcType == Primitive::kPrimByte || srcType == Primitive::kPrimChar ||
169 srcType == Primitive::kPrimShort || srcType == Primitive::kPrimInt) {
170 dst.SetF(src.GetI());
171 return true;
172 } else if (srcType == Primitive::kPrimLong) {
173 dst.SetF(src.GetJ());
174 return true;
175 } else if (srcType == Primitive::kPrimFloat) {
176 dst.SetF(src.GetF());
177 return true;
178 }
179 break;
180 case Primitive::kPrimDouble:
181 if (srcType == Primitive::kPrimByte || srcType == Primitive::kPrimChar ||
182 srcType == Primitive::kPrimShort || srcType == Primitive::kPrimInt) {
183 dst.SetD(src.GetI());
184 return true;
185 } else if (srcType == Primitive::kPrimLong) {
186 dst.SetD(src.GetJ());
187 return true;
188 } else if (srcType == Primitive::kPrimFloat) {
189 dst.SetD(src.GetF());
190 return true;
191 } else if (srcType == Primitive::kPrimDouble) {
192 dst.SetJ(src.GetJ());
193 return true;
194 }
195 break;
196 default:
197 break;
198 }
199 if (!unbox_for_result) {
200 ThrowIllegalArgumentException(throw_location,
201 StringPrintf("Invalid primitive conversion from %s to %s",
202 PrettyDescriptor(srcType).c_str(),
203 PrettyDescriptor(dstType).c_str()).c_str());
204 } else {
205 ThrowClassCastException(throw_location,
206 StringPrintf("Couldn't convert result of type %s to %s",
207 PrettyDescriptor(srcType).c_str(),
208 PrettyDescriptor(dstType).c_str()).c_str());
209 }
210 return false;
211 }
212
BoxPrimitive(Primitive::Type src_class,const JValue & value)213 mirror::Object* BoxPrimitive(Primitive::Type src_class, const JValue& value) {
214 if (src_class == Primitive::kPrimNot) {
215 return value.GetL();
216 }
217
218 jmethodID m = NULL;
219 switch (src_class) {
220 case Primitive::kPrimBoolean:
221 m = WellKnownClasses::java_lang_Boolean_valueOf;
222 break;
223 case Primitive::kPrimByte:
224 m = WellKnownClasses::java_lang_Byte_valueOf;
225 break;
226 case Primitive::kPrimChar:
227 m = WellKnownClasses::java_lang_Character_valueOf;
228 break;
229 case Primitive::kPrimDouble:
230 m = WellKnownClasses::java_lang_Double_valueOf;
231 break;
232 case Primitive::kPrimFloat:
233 m = WellKnownClasses::java_lang_Float_valueOf;
234 break;
235 case Primitive::kPrimInt:
236 m = WellKnownClasses::java_lang_Integer_valueOf;
237 break;
238 case Primitive::kPrimLong:
239 m = WellKnownClasses::java_lang_Long_valueOf;
240 break;
241 case Primitive::kPrimShort:
242 m = WellKnownClasses::java_lang_Short_valueOf;
243 break;
244 case Primitive::kPrimVoid:
245 // There's no such thing as a void field, and void methods invoked via reflection return null.
246 return NULL;
247 default:
248 LOG(FATAL) << static_cast<int>(src_class);
249 }
250
251 ScopedObjectAccessUnchecked soa(Thread::Current());
252 if (kIsDebugBuild) {
253 CHECK_EQ(soa.Self()->GetState(), kRunnable);
254 }
255
256 ArgArray arg_array(NULL, 0);
257 JValue result;
258 if (src_class == Primitive::kPrimDouble || src_class == Primitive::kPrimLong) {
259 arg_array.AppendWide(value.GetJ());
260 } else {
261 arg_array.Append(value.GetI());
262 }
263
264 soa.DecodeMethod(m)->Invoke(soa.Self(), arg_array.GetArray(), arg_array.GetNumBytes(),
265 &result, 'L');
266 return result.GetL();
267 }
268
UnboxingFailureKind(mirror::ArtMethod * m,int index,mirror::ArtField * f)269 static std::string UnboxingFailureKind(mirror::ArtMethod* m, int index, mirror::ArtField* f)
270 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
271 if (m != NULL && index != -1) {
272 ++index; // Humans count from 1.
273 return StringPrintf("method %s argument %d", PrettyMethod(m, false).c_str(), index);
274 }
275 if (f != NULL) {
276 return "field " + PrettyField(f, false);
277 }
278 return "result";
279 }
280
UnboxPrimitive(const ThrowLocation * throw_location,mirror::Object * o,mirror::Class * dst_class,JValue & unboxed_value,mirror::ArtMethod * m,int index,mirror::ArtField * f)281 static bool UnboxPrimitive(const ThrowLocation* throw_location, mirror::Object* o,
282 mirror::Class* dst_class, JValue& unboxed_value,
283 mirror::ArtMethod* m, int index, mirror::ArtField* f)
284 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
285 bool unbox_for_result = (f == NULL) && (index == -1);
286 if (!dst_class->IsPrimitive()) {
287 if (UNLIKELY(o != NULL && !o->InstanceOf(dst_class))) {
288 if (!unbox_for_result) {
289 ThrowIllegalArgumentException(throw_location,
290 StringPrintf("%s has type %s, got %s",
291 UnboxingFailureKind(m, index, f).c_str(),
292 PrettyDescriptor(dst_class).c_str(),
293 PrettyTypeOf(o).c_str()).c_str());
294 } else {
295 ThrowClassCastException(throw_location,
296 StringPrintf("Couldn't convert result of type %s to %s",
297 PrettyTypeOf(o).c_str(),
298 PrettyDescriptor(dst_class).c_str()).c_str());
299 }
300 return false;
301 }
302 unboxed_value.SetL(o);
303 return true;
304 }
305 if (UNLIKELY(dst_class->GetPrimitiveType() == Primitive::kPrimVoid)) {
306 ThrowIllegalArgumentException(throw_location,
307 StringPrintf("Can't unbox %s to void",
308 UnboxingFailureKind(m, index, f).c_str()).c_str());
309 return false;
310 }
311 if (UNLIKELY(o == NULL)) {
312 if (!unbox_for_result) {
313 ThrowIllegalArgumentException(throw_location,
314 StringPrintf("%s has type %s, got null",
315 UnboxingFailureKind(m, index, f).c_str(),
316 PrettyDescriptor(dst_class).c_str()).c_str());
317 } else {
318 ThrowNullPointerException(throw_location,
319 StringPrintf("Expected to unbox a '%s' primitive type but was returned null",
320 PrettyDescriptor(dst_class).c_str()).c_str());
321 }
322 return false;
323 }
324
325 JValue boxed_value;
326 std::string src_descriptor(ClassHelper(o->GetClass()).GetDescriptor());
327 mirror::Class* src_class = NULL;
328 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
329 mirror::ArtField* primitive_field = o->GetClass()->GetIFields()->Get(0);
330 if (src_descriptor == "Ljava/lang/Boolean;") {
331 src_class = class_linker->FindPrimitiveClass('Z');
332 boxed_value.SetZ(primitive_field->GetBoolean(o));
333 } else if (src_descriptor == "Ljava/lang/Byte;") {
334 src_class = class_linker->FindPrimitiveClass('B');
335 boxed_value.SetB(primitive_field->GetByte(o));
336 } else if (src_descriptor == "Ljava/lang/Character;") {
337 src_class = class_linker->FindPrimitiveClass('C');
338 boxed_value.SetC(primitive_field->GetChar(o));
339 } else if (src_descriptor == "Ljava/lang/Float;") {
340 src_class = class_linker->FindPrimitiveClass('F');
341 boxed_value.SetF(primitive_field->GetFloat(o));
342 } else if (src_descriptor == "Ljava/lang/Double;") {
343 src_class = class_linker->FindPrimitiveClass('D');
344 boxed_value.SetD(primitive_field->GetDouble(o));
345 } else if (src_descriptor == "Ljava/lang/Integer;") {
346 src_class = class_linker->FindPrimitiveClass('I');
347 boxed_value.SetI(primitive_field->GetInt(o));
348 } else if (src_descriptor == "Ljava/lang/Long;") {
349 src_class = class_linker->FindPrimitiveClass('J');
350 boxed_value.SetJ(primitive_field->GetLong(o));
351 } else if (src_descriptor == "Ljava/lang/Short;") {
352 src_class = class_linker->FindPrimitiveClass('S');
353 boxed_value.SetS(primitive_field->GetShort(o));
354 } else {
355 ThrowIllegalArgumentException(throw_location,
356 StringPrintf("%s has type %s, got %s",
357 UnboxingFailureKind(m, index, f).c_str(),
358 PrettyDescriptor(dst_class).c_str(),
359 PrettyDescriptor(src_descriptor.c_str()).c_str()).c_str());
360 return false;
361 }
362
363 return ConvertPrimitiveValue(throw_location, unbox_for_result,
364 src_class->GetPrimitiveType(), dst_class->GetPrimitiveType(),
365 boxed_value, unboxed_value);
366 }
367
UnboxPrimitiveForArgument(mirror::Object * o,mirror::Class * dst_class,JValue & unboxed_value,mirror::ArtMethod * m,size_t index)368 bool UnboxPrimitiveForArgument(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
369 mirror::ArtMethod* m, size_t index) {
370 CHECK(m != NULL);
371 return UnboxPrimitive(NULL, o, dst_class, unboxed_value, m, index, NULL);
372 }
373
UnboxPrimitiveForField(mirror::Object * o,mirror::Class * dst_class,JValue & unboxed_value,mirror::ArtField * f)374 bool UnboxPrimitiveForField(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
375 mirror::ArtField* f) {
376 CHECK(f != NULL);
377 return UnboxPrimitive(NULL, o, dst_class, unboxed_value, NULL, -1, f);
378 }
379
UnboxPrimitiveForResult(const ThrowLocation & throw_location,mirror::Object * o,mirror::Class * dst_class,JValue & unboxed_value)380 bool UnboxPrimitiveForResult(const ThrowLocation& throw_location, mirror::Object* o,
381 mirror::Class* dst_class, JValue& unboxed_value) {
382 return UnboxPrimitive(&throw_location, o, dst_class, unboxed_value, NULL, -1, NULL);
383 }
384
385 } // namespace art
386