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