java_lang_Class.cc revision 72f9075e92cfc4632d6c50f282a0f6319b718882
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 17#include "java_lang_Class.h" 18 19#include "art_field-inl.h" 20#include "class_linker.h" 21#include "common_throws.h" 22#include "dex_file-inl.h" 23#include "jni_internal.h" 24#include "nth_caller_visitor.h" 25#include "mirror/class-inl.h" 26#include "mirror/class_loader.h" 27#include "mirror/field-inl.h" 28#include "mirror/method.h" 29#include "mirror/object-inl.h" 30#include "mirror/object_array-inl.h" 31#include "mirror/string-inl.h" 32#include "reflection.h" 33#include "scoped_thread_state_change.h" 34#include "scoped_fast_native_object_access.h" 35#include "ScopedLocalRef.h" 36#include "ScopedUtfChars.h" 37#include "utf.h" 38#include "well_known_classes.h" 39 40namespace art { 41 42ALWAYS_INLINE static inline mirror::Class* DecodeClass( 43 const ScopedFastNativeObjectAccess& soa, jobject java_class) 44 SHARED_REQUIRES(Locks::mutator_lock_) { 45 mirror::Class* c = soa.Decode<mirror::Class*>(java_class); 46 DCHECK(c != nullptr); 47 DCHECK(c->IsClass()); 48 // TODO: we could EnsureInitialized here, rather than on every reflective get/set or invoke . 49 // For now, we conservatively preserve the old dalvik behavior. A quick "IsInitialized" check 50 // every time probably doesn't make much difference to reflection performance anyway. 51 return c; 52} 53 54// "name" is in "binary name" format, e.g. "dalvik.system.Debug$1". 55static jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean initialize, 56 jobject javaLoader) { 57 ScopedFastNativeObjectAccess soa(env); 58 ScopedUtfChars name(env, javaName); 59 if (name.c_str() == nullptr) { 60 return nullptr; 61 } 62 63 // We need to validate and convert the name (from x.y.z to x/y/z). This 64 // is especially handy for array types, since we want to avoid 65 // auto-generating bogus array classes. 66 if (!IsValidBinaryClassName(name.c_str())) { 67 soa.Self()->ThrowNewExceptionF("Ljava/lang/ClassNotFoundException;", 68 "Invalid name: %s", name.c_str()); 69 return nullptr; 70 } 71 72 std::string descriptor(DotToDescriptor(name.c_str())); 73 StackHandleScope<2> hs(soa.Self()); 74 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader))); 75 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 76 Handle<mirror::Class> c( 77 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor.c_str(), class_loader))); 78 if (c.Get() == nullptr) { 79 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred()); 80 env->ExceptionClear(); 81 jthrowable cnfe = reinterpret_cast<jthrowable>(env->NewObject(WellKnownClasses::java_lang_ClassNotFoundException, 82 WellKnownClasses::java_lang_ClassNotFoundException_init, 83 javaName, cause.get())); 84 if (cnfe != nullptr) { 85 // Make sure allocation didn't fail with an OOME. 86 env->Throw(cnfe); 87 } 88 return nullptr; 89 } 90 if (initialize) { 91 class_linker->EnsureInitialized(soa.Self(), c, true, true); 92 } 93 return soa.AddLocalReference<jclass>(c.Get()); 94} 95 96static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) { 97 ScopedFastNativeObjectAccess soa(env); 98 StackHandleScope<1> hs(soa.Self()); 99 mirror::Class* const c = DecodeClass(soa, javaThis); 100 return soa.AddLocalReference<jstring>(mirror::Class::ComputeName(hs.NewHandle(c))); 101} 102 103static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) { 104 ScopedFastNativeObjectAccess soa(env); 105 mirror::Class* c = DecodeClass(soa, javaThis); 106 return soa.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone(soa.Self())); 107} 108 109static mirror::ObjectArray<mirror::Field>* GetDeclaredFields( 110 Thread* self, mirror::Class* klass, bool public_only, bool force_resolve) 111 SHARED_REQUIRES(Locks::mutator_lock_) { 112 StackHandleScope<1> hs(self); 113 IterationRange<StrideIterator<ArtField>> ifields = klass->GetIFields(); 114 IterationRange<StrideIterator<ArtField>> sfields = klass->GetSFields(); 115 size_t array_size = klass->NumInstanceFields() + klass->NumStaticFields(); 116 if (public_only) { 117 // Lets go subtract all the non public fields. 118 for (ArtField& field : ifields) { 119 if (!field.IsPublic()) { 120 --array_size; 121 } 122 } 123 for (ArtField& field : sfields) { 124 if (!field.IsPublic()) { 125 --array_size; 126 } 127 } 128 } 129 size_t array_idx = 0; 130 auto object_array = hs.NewHandle(mirror::ObjectArray<mirror::Field>::Alloc( 131 self, mirror::Field::ArrayClass(), array_size)); 132 if (object_array.Get() == nullptr) { 133 return nullptr; 134 } 135 for (ArtField& field : ifields) { 136 if (!public_only || field.IsPublic()) { 137 auto* reflect_field = mirror::Field::CreateFromArtField(self, &field, force_resolve); 138 if (reflect_field == nullptr) { 139 if (kIsDebugBuild) { 140 self->AssertPendingException(); 141 } 142 // Maybe null due to OOME or type resolving exception. 143 return nullptr; 144 } 145 object_array->SetWithoutChecks<false>(array_idx++, reflect_field); 146 } 147 } 148 for (ArtField& field : sfields) { 149 if (!public_only || field.IsPublic()) { 150 auto* reflect_field = mirror::Field::CreateFromArtField(self, &field, force_resolve); 151 if (reflect_field == nullptr) { 152 if (kIsDebugBuild) { 153 self->AssertPendingException(); 154 } 155 return nullptr; 156 } 157 object_array->SetWithoutChecks<false>(array_idx++, reflect_field); 158 } 159 } 160 DCHECK_EQ(array_idx, array_size); 161 return object_array.Get(); 162} 163 164static jobjectArray Class_getDeclaredFieldsUnchecked(JNIEnv* env, jobject javaThis, 165 jboolean publicOnly) { 166 ScopedFastNativeObjectAccess soa(env); 167 return soa.AddLocalReference<jobjectArray>( 168 GetDeclaredFields(soa.Self(), DecodeClass(soa, javaThis), publicOnly != JNI_FALSE, false)); 169} 170 171static jobjectArray Class_getDeclaredFields(JNIEnv* env, jobject javaThis) { 172 ScopedFastNativeObjectAccess soa(env); 173 return soa.AddLocalReference<jobjectArray>( 174 GetDeclaredFields(soa.Self(), DecodeClass(soa, javaThis), false, true)); 175} 176 177static jobjectArray Class_getPublicDeclaredFields(JNIEnv* env, jobject javaThis) { 178 ScopedFastNativeObjectAccess soa(env); 179 return soa.AddLocalReference<jobjectArray>( 180 GetDeclaredFields(soa.Self(), DecodeClass(soa, javaThis), true, true)); 181} 182 183// Performs a binary search through an array of fields, TODO: Is this fast enough if we don't use 184// the dex cache for lookups? I think CompareModifiedUtf8ToUtf16AsCodePointValues should be fairly 185// fast. 186ALWAYS_INLINE static inline ArtField* FindFieldByName( 187 Thread* self ATTRIBUTE_UNUSED, mirror::String* name, LengthPrefixedArray<ArtField>* fields) 188 SHARED_REQUIRES(Locks::mutator_lock_) { 189 if (fields == nullptr) { 190 return nullptr; 191 } 192 size_t low = 0; 193 size_t high = fields->Length(); 194 const uint16_t* const data = name->GetValue(); 195 const size_t length = name->GetLength(); 196 while (low < high) { 197 auto mid = (low + high) / 2; 198 ArtField& field = fields->At(mid); 199 int result = CompareModifiedUtf8ToUtf16AsCodePointValues(field.GetName(), data, length); 200 // Alternate approach, only a few % faster at the cost of more allocations. 201 // int result = field->GetStringName(self, true)->CompareTo(name); 202 if (result < 0) { 203 low = mid + 1; 204 } else if (result > 0) { 205 high = mid; 206 } else { 207 return &field; 208 } 209 } 210 if (kIsDebugBuild) { 211 for (ArtField& field : MakeIterationRangeFromLengthPrefixedArray(fields)) { 212 CHECK_NE(field.GetName(), name->ToModifiedUtf8()); 213 } 214 } 215 return nullptr; 216} 217 218ALWAYS_INLINE static inline mirror::Field* GetDeclaredField( 219 Thread* self, mirror::Class* c, mirror::String* name) 220 SHARED_REQUIRES(Locks::mutator_lock_) { 221 ArtField* art_field = FindFieldByName(self, name, c->GetIFieldsPtr()); 222 if (art_field != nullptr) { 223 return mirror::Field::CreateFromArtField(self, art_field, true); 224 } 225 art_field = FindFieldByName(self, name, c->GetSFieldsPtr()); 226 if (art_field != nullptr) { 227 return mirror::Field::CreateFromArtField(self, art_field, true); 228 } 229 return nullptr; 230} 231 232static mirror::Field* GetPublicFieldRecursive( 233 Thread* self, mirror::Class* clazz, mirror::String* name) 234 SHARED_REQUIRES(Locks::mutator_lock_) { 235 DCHECK(clazz != nullptr); 236 DCHECK(name != nullptr); 237 DCHECK(self != nullptr); 238 239 StackHandleScope<1> hs(self); 240 MutableHandle<mirror::Class> h_clazz(hs.NewHandle(clazz)); 241 242 // We search the current class, its direct interfaces then its superclass. 243 while (h_clazz.Get() != nullptr) { 244 mirror::Field* result = GetDeclaredField(self, h_clazz.Get(), name); 245 if ((result != nullptr) && (result->GetAccessFlags() & kAccPublic)) { 246 return result; 247 } else if (UNLIKELY(self->IsExceptionPending())) { 248 // Something went wrong. Bail out. 249 return nullptr; 250 } 251 252 uint32_t num_direct_interfaces = h_clazz->NumDirectInterfaces(); 253 for (uint32_t i = 0; i < num_direct_interfaces; i++) { 254 mirror::Class *iface = mirror::Class::GetDirectInterface(self, h_clazz, i); 255 if (UNLIKELY(iface == nullptr)) { 256 self->AssertPendingException(); 257 return nullptr; 258 } 259 result = GetPublicFieldRecursive(self, iface, name); 260 if (result != nullptr) { 261 DCHECK(result->GetAccessFlags() & kAccPublic); 262 return result; 263 } else if (UNLIKELY(self->IsExceptionPending())) { 264 // Something went wrong. Bail out. 265 return nullptr; 266 } 267 } 268 269 // We don't try the superclass if we are an interface. 270 if (h_clazz->IsInterface()) { 271 break; 272 } 273 274 // Get the next class. 275 h_clazz.Assign(h_clazz->GetSuperClass()); 276 } 277 return nullptr; 278} 279 280static jobject Class_getPublicFieldRecursive(JNIEnv* env, jobject javaThis, jstring name) { 281 ScopedFastNativeObjectAccess soa(env); 282 auto* name_string = soa.Decode<mirror::String*>(name); 283 if (UNLIKELY(name_string == nullptr)) { 284 ThrowNullPointerException("name == null"); 285 return nullptr; 286 } 287 return soa.AddLocalReference<jobject>( 288 GetPublicFieldRecursive(soa.Self(), DecodeClass(soa, javaThis), name_string)); 289} 290 291static jobject Class_getDeclaredFieldInternal(JNIEnv* env, jobject javaThis, jstring name) { 292 ScopedFastNativeObjectAccess soa(env); 293 auto* name_string = soa.Decode<mirror::String*>(name); 294 return soa.AddLocalReference<jobject>( 295 GetDeclaredField(soa.Self(), DecodeClass(soa, javaThis), name_string)); 296} 297 298static jobject Class_getDeclaredField(JNIEnv* env, jobject javaThis, jstring name) { 299 ScopedFastNativeObjectAccess soa(env); 300 auto* name_string = soa.Decode<mirror::String*>(name); 301 if (name_string == nullptr) { 302 ThrowNullPointerException("name == null"); 303 return nullptr; 304 } 305 auto* klass = DecodeClass(soa, javaThis); 306 mirror::Field* result = GetDeclaredField(soa.Self(), klass, name_string); 307 if (result == nullptr) { 308 std::string name_str = name_string->ToModifiedUtf8(); 309 // We may have a pending exception if we failed to resolve. 310 if (!soa.Self()->IsExceptionPending()) { 311 ThrowNoSuchFieldException(DecodeClass(soa, javaThis), name_str.c_str()); 312 } 313 return nullptr; 314 } 315 return soa.AddLocalReference<jobject>(result); 316} 317 318static jobject Class_getDeclaredConstructorInternal( 319 JNIEnv* env, jobject javaThis, jobjectArray args) { 320 ScopedFastNativeObjectAccess soa(env); 321 auto* klass = DecodeClass(soa, javaThis); 322 auto* params = soa.Decode<mirror::ObjectArray<mirror::Class>*>(args); 323 StackHandleScope<1> hs(soa.Self()); 324 auto* declared_constructor = klass->GetDeclaredConstructor(soa.Self(), hs.NewHandle(params)); 325 if (declared_constructor != nullptr) { 326 return soa.AddLocalReference<jobject>( 327 mirror::Constructor::CreateFromArtMethod(soa.Self(), declared_constructor)); 328 } 329 return nullptr; 330} 331 332static ALWAYS_INLINE inline bool MethodMatchesConstructor(ArtMethod* m, bool public_only) 333 SHARED_REQUIRES(Locks::mutator_lock_) { 334 DCHECK(m != nullptr); 335 return (!public_only || m->IsPublic()) && !m->IsStatic() && m->IsConstructor(); 336} 337 338static jobjectArray Class_getDeclaredConstructorsInternal( 339 JNIEnv* env, jobject javaThis, jboolean publicOnly) { 340 ScopedFastNativeObjectAccess soa(env); 341 StackHandleScope<2> hs(soa.Self()); 342 Handle<mirror::Class> h_klass = hs.NewHandle(DecodeClass(soa, javaThis)); 343 size_t constructor_count = 0; 344 // Two pass approach for speed. 345 for (auto& m : h_klass->GetDirectMethods(sizeof(void*))) { 346 constructor_count += MethodMatchesConstructor(&m, publicOnly != JNI_FALSE) ? 1u : 0u; 347 } 348 auto h_constructors = hs.NewHandle(mirror::ObjectArray<mirror::Constructor>::Alloc( 349 soa.Self(), mirror::Constructor::ArrayClass(), constructor_count)); 350 if (UNLIKELY(h_constructors.Get() == nullptr)) { 351 soa.Self()->AssertPendingException(); 352 return nullptr; 353 } 354 constructor_count = 0; 355 for (auto& m : h_klass->GetDirectMethods(sizeof(void*))) { 356 if (MethodMatchesConstructor(&m, publicOnly != JNI_FALSE)) { 357 auto* constructor = mirror::Constructor::CreateFromArtMethod(soa.Self(), &m); 358 if (UNLIKELY(constructor == nullptr)) { 359 soa.Self()->AssertPendingOOMException(); 360 return nullptr; 361 } 362 h_constructors->SetWithoutChecks<false>(constructor_count++, constructor); 363 } 364 } 365 return soa.AddLocalReference<jobjectArray>(h_constructors.Get()); 366} 367 368static jobject Class_getDeclaredMethodInternal(JNIEnv* env, jobject javaThis, 369 jobject name, jobjectArray args) { 370 // Covariant return types permit the class to define multiple 371 // methods with the same name and parameter types. Prefer to 372 // return a non-synthetic method in such situations. We may 373 // still return a synthetic method to handle situations like 374 // escalated visibility. We never return miranda methods that 375 // were synthesized by the runtime. 376 constexpr uint32_t kSkipModifiers = kAccMiranda | kAccSynthetic; 377 ScopedFastNativeObjectAccess soa(env); 378 StackHandleScope<3> hs(soa.Self()); 379 auto h_method_name = hs.NewHandle(soa.Decode<mirror::String*>(name)); 380 if (UNLIKELY(h_method_name.Get() == nullptr)) { 381 ThrowNullPointerException("name == null"); 382 return nullptr; 383 } 384 auto h_args = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>*>(args)); 385 Handle<mirror::Class> h_klass = hs.NewHandle(DecodeClass(soa, javaThis)); 386 ArtMethod* result = nullptr; 387 for (auto& m : h_klass->GetVirtualMethods(sizeof(void*))) { 388 auto* np_method = m.GetInterfaceMethodIfProxy(sizeof(void*)); 389 // May cause thread suspension. 390 mirror::String* np_name = np_method->GetNameAsString(soa.Self()); 391 if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) { 392 if (UNLIKELY(soa.Self()->IsExceptionPending())) { 393 return nullptr; 394 } 395 continue; 396 } 397 auto modifiers = m.GetAccessFlags(); 398 if ((modifiers & kSkipModifiers) == 0) { 399 return soa.AddLocalReference<jobject>(mirror::Method::CreateFromArtMethod(soa.Self(), &m)); 400 } 401 if ((modifiers & kAccMiranda) == 0) { 402 result = &m; // Remember as potential result if it's not a miranda method. 403 } 404 } 405 if (result == nullptr) { 406 for (auto& m : h_klass->GetDirectMethods(sizeof(void*))) { 407 auto modifiers = m.GetAccessFlags(); 408 if ((modifiers & kAccConstructor) != 0) { 409 continue; 410 } 411 auto* np_method = m.GetInterfaceMethodIfProxy(sizeof(void*)); 412 // May cause thread suspension. 413 mirror::String* np_name = np_method->GetNameAsString(soa.Self()); 414 if (np_name == nullptr) { 415 soa.Self()->AssertPendingException(); 416 return nullptr; 417 } 418 if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) { 419 if (UNLIKELY(soa.Self()->IsExceptionPending())) { 420 return nullptr; 421 } 422 continue; 423 } 424 if ((modifiers & kSkipModifiers) == 0) { 425 return soa.AddLocalReference<jobject>(mirror::Method::CreateFromArtMethod(soa.Self(), &m)); 426 } 427 // Direct methods cannot be miranda methods, so this potential result must be synthetic. 428 result = &m; 429 } 430 } 431 return result != nullptr ? 432 soa.AddLocalReference<jobject>(mirror::Method::CreateFromArtMethod(soa.Self(), result)) : 433 nullptr; 434} 435 436static jobjectArray Class_getDeclaredMethodsUnchecked(JNIEnv* env, jobject javaThis, 437 jboolean publicOnly) { 438 ScopedFastNativeObjectAccess soa(env); 439 StackHandleScope<2> hs(soa.Self()); 440 Handle<mirror::Class> klass = hs.NewHandle(DecodeClass(soa, javaThis)); 441 size_t num_methods = 0; 442 for (auto& m : klass->GetVirtualMethods(sizeof(void*))) { 443 auto modifiers = m.GetAccessFlags(); 444 if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) && 445 (modifiers & kAccMiranda) == 0) { 446 ++num_methods; 447 } 448 } 449 for (auto& m : klass->GetDirectMethods(sizeof(void*))) { 450 auto modifiers = m.GetAccessFlags(); 451 // Add non-constructor direct/static methods. 452 if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) && 453 (modifiers & kAccConstructor) == 0) { 454 ++num_methods; 455 } 456 } 457 auto ret = hs.NewHandle(mirror::ObjectArray<mirror::Method>::Alloc( 458 soa.Self(), mirror::Method::ArrayClass(), num_methods)); 459 num_methods = 0; 460 for (auto& m : klass->GetVirtualMethods(sizeof(void*))) { 461 auto modifiers = m.GetAccessFlags(); 462 if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) && 463 (modifiers & kAccMiranda) == 0) { 464 auto* method = mirror::Method::CreateFromArtMethod(soa.Self(), &m); 465 if (method == nullptr) { 466 soa.Self()->AssertPendingException(); 467 return nullptr; 468 } 469 ret->SetWithoutChecks<false>(num_methods++, method); 470 } 471 } 472 for (auto& m : klass->GetDirectMethods(sizeof(void*))) { 473 auto modifiers = m.GetAccessFlags(); 474 // Add non-constructor direct/static methods. 475 if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) && 476 (modifiers & kAccConstructor) == 0) { 477 auto* method = mirror::Method::CreateFromArtMethod(soa.Self(), &m); 478 if (method == nullptr) { 479 soa.Self()->AssertPendingException(); 480 return nullptr; 481 } 482 ret->SetWithoutChecks<false>(num_methods++, method); 483 } 484 } 485 return soa.AddLocalReference<jobjectArray>(ret.Get()); 486} 487 488static jobject Class_getDeclaredAnnotation(JNIEnv* env, jobject javaThis, jclass annotationType) { 489 ScopedFastNativeObjectAccess soa(env); 490 StackHandleScope<2> hs(soa.Self()); 491 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 492 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 493 return nullptr; 494 } 495 Handle<mirror::Class> annotation_class(hs.NewHandle(soa.Decode<mirror::Class*>(annotationType))); 496 return soa.AddLocalReference<jobject>( 497 klass->GetDexFile().GetAnnotationForClass(klass, annotation_class)); 498} 499 500static jobjectArray Class_getDeclaredAnnotations(JNIEnv* env, jobject javaThis) { 501 ScopedFastNativeObjectAccess soa(env); 502 StackHandleScope<1> hs(soa.Self()); 503 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 504 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 505 // Return an empty array instead of a null pointer. 506 mirror::Class* annotation_array_class = 507 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_annotation_Annotation__array); 508 mirror::ObjectArray<mirror::Object>* empty_array = 509 mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), annotation_array_class, 0); 510 return soa.AddLocalReference<jobjectArray>(empty_array); 511 } 512 return soa.AddLocalReference<jobjectArray>(klass->GetDexFile().GetAnnotationsForClass(klass)); 513} 514 515static jobjectArray Class_getDeclaredClasses(JNIEnv* env, jobject javaThis) { 516 ScopedFastNativeObjectAccess soa(env); 517 StackHandleScope<1> hs(soa.Self()); 518 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 519 mirror::ObjectArray<mirror::Class>* classes = nullptr; 520 if (!klass->IsProxyClass() && klass->GetDexCache() != nullptr) { 521 classes = klass->GetDexFile().GetDeclaredClasses(klass); 522 } 523 if (classes == nullptr) { 524 // Return an empty array instead of a null pointer. 525 mirror::Class* class_class = mirror::Class::GetJavaLangClass(); 526 mirror::Class* class_array_class = 527 Runtime::Current()->GetClassLinker()->FindArrayClass(soa.Self(), &class_class); 528 if (class_array_class == nullptr) { 529 return nullptr; 530 } 531 mirror::ObjectArray<mirror::Class>* empty_array = 532 mirror::ObjectArray<mirror::Class>::Alloc(soa.Self(), class_array_class, 0); 533 return soa.AddLocalReference<jobjectArray>(empty_array); 534 } 535 return soa.AddLocalReference<jobjectArray>(classes); 536} 537 538static jclass Class_getEnclosingClass(JNIEnv* env, jobject javaThis) { 539 ScopedFastNativeObjectAccess soa(env); 540 StackHandleScope<1> hs(soa.Self()); 541 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 542 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 543 return nullptr; 544 } 545 return soa.AddLocalReference<jclass>(klass->GetDexFile().GetEnclosingClass(klass)); 546} 547 548static jobject Class_getEnclosingConstructorNative(JNIEnv* env, jobject javaThis) { 549 ScopedFastNativeObjectAccess soa(env); 550 StackHandleScope<1> hs(soa.Self()); 551 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 552 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 553 return nullptr; 554 } 555 mirror::Object* method = klass->GetDexFile().GetEnclosingMethod(klass); 556 if (method != nullptr) { 557 if (method->GetClass() == 558 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_reflect_Constructor)) { 559 return soa.AddLocalReference<jobject>(method); 560 } 561 } 562 return nullptr; 563} 564 565static jobject Class_getEnclosingMethodNative(JNIEnv* env, jobject javaThis) { 566 ScopedFastNativeObjectAccess soa(env); 567 StackHandleScope<1> hs(soa.Self()); 568 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 569 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 570 return nullptr; 571 } 572 mirror::Object* method = klass->GetDexFile().GetEnclosingMethod(klass); 573 if (method != nullptr) { 574 if (method->GetClass() == 575 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_reflect_Method)) { 576 return soa.AddLocalReference<jobject>(method); 577 } 578 } 579 return nullptr; 580} 581 582static jint Class_getInnerClassFlags(JNIEnv* env, jobject javaThis, jint defaultValue) { 583 ScopedFastNativeObjectAccess soa(env); 584 StackHandleScope<1> hs(soa.Self()); 585 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 586 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 587 return defaultValue; 588 } 589 uint32_t flags; 590 if (!klass->GetDexFile().GetInnerClassFlags(klass, &flags)) { 591 return defaultValue; 592 } 593 return flags; 594} 595 596static jstring Class_getInnerClassName(JNIEnv* env, jobject javaThis) { 597 ScopedFastNativeObjectAccess soa(env); 598 StackHandleScope<1> hs(soa.Self()); 599 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 600 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 601 return nullptr; 602 } 603 mirror::String* class_name = nullptr; 604 if (!klass->GetDexFile().GetInnerClass(klass, &class_name)) { 605 return nullptr; 606 } 607 return soa.AddLocalReference<jstring>(class_name); 608} 609 610static jboolean Class_isAnonymousClass(JNIEnv* env, jobject javaThis) { 611 ScopedFastNativeObjectAccess soa(env); 612 StackHandleScope<1> hs(soa.Self()); 613 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 614 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 615 return false; 616 } 617 mirror::String* class_name = nullptr; 618 if (!klass->GetDexFile().GetInnerClass(klass, &class_name)) { 619 return false; 620 } 621 return class_name == nullptr; 622} 623 624static jboolean Class_isDeclaredAnnotationPresent(JNIEnv* env, jobject javaThis, 625 jclass annotationType) { 626 ScopedFastNativeObjectAccess soa(env); 627 StackHandleScope<2> hs(soa.Self()); 628 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 629 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 630 return false; 631 } 632 Handle<mirror::Class> annotation_class(hs.NewHandle(soa.Decode<mirror::Class*>(annotationType))); 633 return klass->GetDexFile().IsClassAnnotationPresent(klass, annotation_class); 634} 635 636static jclass Class_getDeclaringClass(JNIEnv* env, jobject javaThis) { 637 ScopedFastNativeObjectAccess soa(env); 638 StackHandleScope<1> hs(soa.Self()); 639 Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis))); 640 if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) { 641 return nullptr; 642 } 643 // Return null for anonymous classes. 644 if (Class_isAnonymousClass(env, javaThis)) { 645 return nullptr; 646 } 647 return soa.AddLocalReference<jclass>(klass->GetDexFile().GetDeclaringClass(klass)); 648} 649 650static jobject Class_newInstance(JNIEnv* env, jobject javaThis) { 651 ScopedFastNativeObjectAccess soa(env); 652 StackHandleScope<4> hs(soa.Self()); 653 Handle<mirror::Class> klass = hs.NewHandle(DecodeClass(soa, javaThis)); 654 if (UNLIKELY(klass->GetPrimitiveType() != 0 || klass->IsInterface() || klass->IsArrayClass() || 655 klass->IsAbstract())) { 656 soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;", 657 "%s cannot be instantiated", PrettyClass(klass.Get()).c_str()); 658 return nullptr; 659 } 660 auto caller = hs.NewHandle<mirror::Class>(nullptr); 661 // Verify that we can access the class. 662 if (!klass->IsPublic()) { 663 caller.Assign(GetCallingClass(soa.Self(), 1)); 664 if (caller.Get() != nullptr && !caller->CanAccess(klass.Get())) { 665 soa.Self()->ThrowNewExceptionF( 666 "Ljava/lang/IllegalAccessException;", "%s is not accessible from %s", 667 PrettyClass(klass.Get()).c_str(), PrettyClass(caller.Get()).c_str()); 668 return nullptr; 669 } 670 } 671 auto* constructor = klass->GetDeclaredConstructor( 672 soa.Self(), NullHandle<mirror::ObjectArray<mirror::Class>>()); 673 if (UNLIKELY(constructor == nullptr)) { 674 soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;", 675 "%s has no zero argument constructor", 676 PrettyClass(klass.Get()).c_str()); 677 return nullptr; 678 } 679 // Invoke the string allocator to return an empty string for the string class. 680 if (klass->IsStringClass()) { 681 gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); 682 mirror::SetStringCountVisitor visitor(0); 683 mirror::Object* obj = mirror::String::Alloc<true>(soa.Self(), 0, allocator_type, visitor); 684 if (UNLIKELY(soa.Self()->IsExceptionPending())) { 685 return nullptr; 686 } else { 687 return soa.AddLocalReference<jobject>(obj); 688 } 689 } 690 auto receiver = hs.NewHandle(klass->AllocObject(soa.Self())); 691 if (UNLIKELY(receiver.Get() == nullptr)) { 692 soa.Self()->AssertPendingOOMException(); 693 return nullptr; 694 } 695 // Verify that we can access the constructor. 696 auto* declaring_class = constructor->GetDeclaringClass(); 697 if (!constructor->IsPublic()) { 698 if (caller.Get() == nullptr) { 699 caller.Assign(GetCallingClass(soa.Self(), 1)); 700 } 701 if (UNLIKELY(caller.Get() != nullptr && !VerifyAccess( 702 soa.Self(), receiver.Get(), declaring_class, constructor->GetAccessFlags(), 703 caller.Get()))) { 704 soa.Self()->ThrowNewExceptionF( 705 "Ljava/lang/IllegalAccessException;", "%s is not accessible from %s", 706 PrettyMethod(constructor).c_str(), PrettyClass(caller.Get()).c_str()); 707 return nullptr; 708 } 709 } 710 // Ensure that we are initialized. 711 if (UNLIKELY(!declaring_class->IsInitialized())) { 712 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized( 713 soa.Self(), hs.NewHandle(declaring_class), true, true)) { 714 soa.Self()->AssertPendingException(); 715 return nullptr; 716 } 717 } 718 // Invoke the constructor. 719 JValue result; 720 uint32_t args[1] = { static_cast<uint32_t>(reinterpret_cast<uintptr_t>(receiver.Get())) }; 721 constructor->Invoke(soa.Self(), args, sizeof(args), &result, "V"); 722 if (UNLIKELY(soa.Self()->IsExceptionPending())) { 723 return nullptr; 724 } 725 // Constructors are ()V methods, so we shouldn't touch the result of InvokeMethod. 726 return soa.AddLocalReference<jobject>(receiver.Get()); 727} 728 729static JNINativeMethod gMethods[] = { 730 NATIVE_METHOD(Class, classForName, 731 "!(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"), 732 NATIVE_METHOD(Class, getDeclaredAnnotation, 733 "!(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;"), 734 NATIVE_METHOD(Class, getDeclaredAnnotations, "!()[Ljava/lang/annotation/Annotation;"), 735 NATIVE_METHOD(Class, getDeclaredClasses, "!()[Ljava/lang/Class;"), 736 NATIVE_METHOD(Class, getDeclaredConstructorInternal, 737 "!([Ljava/lang/Class;)Ljava/lang/reflect/Constructor;"), 738 NATIVE_METHOD(Class, getDeclaredConstructorsInternal, "!(Z)[Ljava/lang/reflect/Constructor;"), 739 NATIVE_METHOD(Class, getDeclaredField, "!(Ljava/lang/String;)Ljava/lang/reflect/Field;"), 740 NATIVE_METHOD(Class, getPublicFieldRecursive, "!(Ljava/lang/String;)Ljava/lang/reflect/Field;"), 741 NATIVE_METHOD(Class, getDeclaredFieldInternal, "!(Ljava/lang/String;)Ljava/lang/reflect/Field;"), 742 NATIVE_METHOD(Class, getDeclaredFields, "!()[Ljava/lang/reflect/Field;"), 743 NATIVE_METHOD(Class, getDeclaredFieldsUnchecked, "!(Z)[Ljava/lang/reflect/Field;"), 744 NATIVE_METHOD(Class, getDeclaredMethodInternal, 745 "!(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;"), 746 NATIVE_METHOD(Class, getDeclaredMethodsUnchecked, 747 "!(Z)[Ljava/lang/reflect/Method;"), 748 NATIVE_METHOD(Class, getDeclaringClass, "!()Ljava/lang/Class;"), 749 NATIVE_METHOD(Class, getEnclosingClass, "!()Ljava/lang/Class;"), 750 NATIVE_METHOD(Class, getEnclosingConstructorNative, "!()Ljava/lang/reflect/Constructor;"), 751 NATIVE_METHOD(Class, getEnclosingMethodNative, "!()Ljava/lang/reflect/Method;"), 752 NATIVE_METHOD(Class, getInnerClassFlags, "!(I)I"), 753 NATIVE_METHOD(Class, getInnerClassName, "!()Ljava/lang/String;"), 754 NATIVE_METHOD(Class, getNameNative, "!()Ljava/lang/String;"), 755 NATIVE_METHOD(Class, getProxyInterfaces, "!()[Ljava/lang/Class;"), 756 NATIVE_METHOD(Class, getPublicDeclaredFields, "!()[Ljava/lang/reflect/Field;"), 757 NATIVE_METHOD(Class, isAnonymousClass, "!()Z"), 758 NATIVE_METHOD(Class, isDeclaredAnnotationPresent, "!(Ljava/lang/Class;)Z"), 759 NATIVE_METHOD(Class, newInstance, "!()Ljava/lang/Object;"), 760}; 761 762void register_java_lang_Class(JNIEnv* env) { 763 REGISTER_NATIVE_METHODS("java/lang/Class"); 764} 765 766} // namespace art 767