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 "class.h" 18 19 #include "android-base/stringprintf.h" 20 21 #include "art_field-inl.h" 22 #include "art_method-inl.h" 23 #include "base/logging.h" // For VLOG. 24 #include "base/utils.h" 25 #include "class-inl.h" 26 #include "class_ext.h" 27 #include "class_linker-inl.h" 28 #include "class_loader.h" 29 #include "dex/descriptors_names.h" 30 #include "dex/dex_file-inl.h" 31 #include "dex/dex_file_annotations.h" 32 #include "dex_cache.h" 33 #include "gc/accounting/card_table-inl.h" 34 #include "handle_scope-inl.h" 35 #include "subtype_check.h" 36 #include "method.h" 37 #include "object-inl.h" 38 #include "object-refvisitor-inl.h" 39 #include "object_array-inl.h" 40 #include "object_lock.h" 41 #include "runtime.h" 42 #include "thread.h" 43 #include "throwable.h" 44 #include "well_known_classes.h" 45 46 namespace art { 47 48 // TODO: move to own CC file? 49 constexpr size_t BitString::kBitSizeAtPosition[BitString::kCapacity]; 50 constexpr size_t BitString::kCapacity; 51 52 namespace mirror { 53 54 using android::base::StringPrintf; 55 56 GcRoot<Class> Class::java_lang_Class_; 57 58 void Class::SetClassClass(ObjPtr<Class> java_lang_Class) { 59 CHECK(java_lang_Class_.IsNull()) 60 << java_lang_Class_.Read() 61 << " " << java_lang_Class; 62 CHECK(java_lang_Class != nullptr); 63 java_lang_Class->SetClassFlags(kClassFlagClass); 64 java_lang_Class_ = GcRoot<Class>(java_lang_Class); 65 } 66 67 void Class::ResetClass() { 68 CHECK(!java_lang_Class_.IsNull()); 69 java_lang_Class_ = GcRoot<Class>(nullptr); 70 } 71 72 void Class::VisitRoots(RootVisitor* visitor) { 73 java_lang_Class_.VisitRootIfNonNull(visitor, RootInfo(kRootStickyClass)); 74 } 75 76 ObjPtr<mirror::Class> Class::GetPrimitiveClass(ObjPtr<mirror::String> name) { 77 const char* expected_name = nullptr; 78 ClassLinker::ClassRoot class_root = ClassLinker::kJavaLangObject; // Invalid. 79 if (name != nullptr && name->GetLength() >= 2) { 80 // Perfect hash for the expected values: from the second letters of the primitive types, 81 // only 'y' has the bit 0x10 set, so use it to change 'b' to 'B'. 82 char hash = name->CharAt(0) ^ ((name->CharAt(1) & 0x10) << 1); 83 switch (hash) { 84 case 'b': expected_name = "boolean"; class_root = ClassLinker::kPrimitiveBoolean; break; 85 case 'B': expected_name = "byte"; class_root = ClassLinker::kPrimitiveByte; break; 86 case 'c': expected_name = "char"; class_root = ClassLinker::kPrimitiveChar; break; 87 case 'd': expected_name = "double"; class_root = ClassLinker::kPrimitiveDouble; break; 88 case 'f': expected_name = "float"; class_root = ClassLinker::kPrimitiveFloat; break; 89 case 'i': expected_name = "int"; class_root = ClassLinker::kPrimitiveInt; break; 90 case 'l': expected_name = "long"; class_root = ClassLinker::kPrimitiveLong; break; 91 case 's': expected_name = "short"; class_root = ClassLinker::kPrimitiveShort; break; 92 case 'v': expected_name = "void"; class_root = ClassLinker::kPrimitiveVoid; break; 93 default: break; 94 } 95 } 96 if (expected_name != nullptr && name->Equals(expected_name)) { 97 ObjPtr<mirror::Class> klass = Runtime::Current()->GetClassLinker()->GetClassRoot(class_root); 98 DCHECK(klass != nullptr); 99 return klass; 100 } else { 101 Thread* self = Thread::Current(); 102 if (name == nullptr) { 103 // Note: ThrowNullPointerException() requires a message which we deliberately want to omit. 104 self->ThrowNewException("Ljava/lang/NullPointerException;", /* msg */ nullptr); 105 } else { 106 self->ThrowNewException("Ljava/lang/ClassNotFoundException;", name->ToModifiedUtf8().c_str()); 107 } 108 return nullptr; 109 } 110 } 111 112 ClassExt* Class::EnsureExtDataPresent(Thread* self) { 113 ObjPtr<ClassExt> existing(GetExtData()); 114 if (!existing.IsNull()) { 115 return existing.Ptr(); 116 } 117 StackHandleScope<3> hs(self); 118 // Handlerize 'this' since we are allocating here. 119 Handle<Class> h_this(hs.NewHandle(this)); 120 // Clear exception so we can allocate. 121 Handle<Throwable> throwable(hs.NewHandle(self->GetException())); 122 self->ClearException(); 123 // Allocate the ClassExt 124 Handle<ClassExt> new_ext(hs.NewHandle(ClassExt::Alloc(self))); 125 if (new_ext == nullptr) { 126 // OOM allocating the classExt. 127 // TODO Should we restore the suppressed exception? 128 self->AssertPendingOOMException(); 129 return nullptr; 130 } else { 131 MemberOffset ext_offset(OFFSET_OF_OBJECT_MEMBER(Class, ext_data_)); 132 bool set; 133 // Set the ext_data_ field using CAS semantics. 134 if (Runtime::Current()->IsActiveTransaction()) { 135 set = h_this->CasFieldStrongSequentiallyConsistentObject<true>(ext_offset, 136 ObjPtr<ClassExt>(nullptr), 137 new_ext.Get()); 138 } else { 139 set = h_this->CasFieldStrongSequentiallyConsistentObject<false>(ext_offset, 140 ObjPtr<ClassExt>(nullptr), 141 new_ext.Get()); 142 } 143 ObjPtr<ClassExt> ret(set ? new_ext.Get() : h_this->GetExtData()); 144 DCHECK(!set || h_this->GetExtData() == new_ext.Get()); 145 CHECK(!ret.IsNull()); 146 // Restore the exception if there was one. 147 if (throwable != nullptr) { 148 self->SetException(throwable.Get()); 149 } 150 return ret.Ptr(); 151 } 152 } 153 154 void Class::SetStatus(Handle<Class> h_this, ClassStatus new_status, Thread* self) { 155 ClassStatus old_status = h_this->GetStatus(); 156 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 157 bool class_linker_initialized = class_linker != nullptr && class_linker->IsInitialized(); 158 if (LIKELY(class_linker_initialized)) { 159 if (UNLIKELY(new_status <= old_status && 160 new_status != ClassStatus::kErrorUnresolved && 161 new_status != ClassStatus::kErrorResolved && 162 new_status != ClassStatus::kRetired)) { 163 LOG(FATAL) << "Unexpected change back of class status for " << h_this->PrettyClass() 164 << " " << old_status << " -> " << new_status; 165 } 166 if (new_status >= ClassStatus::kResolved || old_status >= ClassStatus::kResolved) { 167 // When classes are being resolved the resolution code should hold the lock. 168 CHECK_EQ(h_this->GetLockOwnerThreadId(), self->GetThreadId()) 169 << "Attempt to change status of class while not holding its lock: " 170 << h_this->PrettyClass() << " " << old_status << " -> " << new_status; 171 } 172 } 173 if (UNLIKELY(IsErroneous(new_status))) { 174 CHECK(!h_this->IsErroneous()) 175 << "Attempt to set as erroneous an already erroneous class " 176 << h_this->PrettyClass() 177 << " old_status: " << old_status << " new_status: " << new_status; 178 CHECK_EQ(new_status == ClassStatus::kErrorResolved, old_status >= ClassStatus::kResolved); 179 if (VLOG_IS_ON(class_linker)) { 180 LOG(ERROR) << "Setting " << h_this->PrettyDescriptor() << " to erroneous."; 181 if (self->IsExceptionPending()) { 182 LOG(ERROR) << "Exception: " << self->GetException()->Dump(); 183 } 184 } 185 186 ObjPtr<ClassExt> ext(h_this->EnsureExtDataPresent(self)); 187 if (!ext.IsNull()) { 188 self->AssertPendingException(); 189 ext->SetVerifyError(self->GetException()); 190 } else { 191 self->AssertPendingOOMException(); 192 } 193 self->AssertPendingException(); 194 } 195 196 if (kBitstringSubtypeCheckEnabled) { 197 // FIXME: This looks broken with respect to aborted transactions. 198 ObjPtr<mirror::Class> h_this_ptr = h_this.Get(); 199 SubtypeCheck<ObjPtr<mirror::Class>>::WriteStatus(h_this_ptr, new_status); 200 } else { 201 // The ClassStatus is always in the 4 most-significant bits of status_. 202 static_assert(sizeof(status_) == sizeof(uint32_t), "Size of status_ not equal to uint32"); 203 uint32_t new_status_value = static_cast<uint32_t>(new_status) << (32 - kClassStatusBitSize); 204 if (Runtime::Current()->IsActiveTransaction()) { 205 h_this->SetField32Volatile<true>(StatusOffset(), new_status_value); 206 } else { 207 h_this->SetField32Volatile<false>(StatusOffset(), new_status_value); 208 } 209 } 210 211 // Setting the object size alloc fast path needs to be after the status write so that if the 212 // alloc path sees a valid object size, we would know that it's initialized as long as it has a 213 // load-acquire/fake dependency. 214 if (new_status == ClassStatus::kInitialized && !h_this->IsVariableSize()) { 215 DCHECK_EQ(h_this->GetObjectSizeAllocFastPath(), std::numeric_limits<uint32_t>::max()); 216 // Finalizable objects must always go slow path. 217 if (!h_this->IsFinalizable()) { 218 h_this->SetObjectSizeAllocFastPath(RoundUp(h_this->GetObjectSize(), kObjectAlignment)); 219 } 220 } 221 222 if (!class_linker_initialized) { 223 // When the class linker is being initialized its single threaded and by definition there can be 224 // no waiters. During initialization classes may appear temporary but won't be retired as their 225 // size was statically computed. 226 } else { 227 // Classes that are being resolved or initialized need to notify waiters that the class status 228 // changed. See ClassLinker::EnsureResolved and ClassLinker::WaitForInitializeClass. 229 if (h_this->IsTemp()) { 230 // Class is a temporary one, ensure that waiters for resolution get notified of retirement 231 // so that they can grab the new version of the class from the class linker's table. 232 CHECK_LT(new_status, ClassStatus::kResolved) << h_this->PrettyDescriptor(); 233 if (new_status == ClassStatus::kRetired || new_status == ClassStatus::kErrorUnresolved) { 234 h_this->NotifyAll(self); 235 } 236 } else { 237 CHECK_NE(new_status, ClassStatus::kRetired); 238 if (old_status >= ClassStatus::kResolved || new_status >= ClassStatus::kResolved) { 239 h_this->NotifyAll(self); 240 } 241 } 242 } 243 } 244 245 void Class::SetDexCache(ObjPtr<DexCache> new_dex_cache) { 246 SetFieldObjectTransaction(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), new_dex_cache); 247 } 248 249 void Class::SetClassSize(uint32_t new_class_size) { 250 if (kIsDebugBuild && new_class_size < GetClassSize()) { 251 DumpClass(LOG_STREAM(FATAL_WITHOUT_ABORT), kDumpClassFullDetail); 252 LOG(FATAL_WITHOUT_ABORT) << new_class_size << " vs " << GetClassSize(); 253 LOG(FATAL) << "class=" << PrettyTypeOf(); 254 } 255 SetField32Transaction(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size); 256 } 257 258 // Return the class' name. The exact format is bizarre, but it's the specified behavior for 259 // Class.getName: keywords for primitive types, regular "[I" form for primitive arrays (so "int" 260 // but "[I"), and arrays of reference types written between "L" and ";" but with dots rather than 261 // slashes (so "java.lang.String" but "[Ljava.lang.String;"). Madness. 262 String* Class::ComputeName(Handle<Class> h_this) { 263 String* name = h_this->GetName(); 264 if (name != nullptr) { 265 return name; 266 } 267 std::string temp; 268 const char* descriptor = h_this->GetDescriptor(&temp); 269 Thread* self = Thread::Current(); 270 if ((descriptor[0] != 'L') && (descriptor[0] != '[')) { 271 // The descriptor indicates that this is the class for 272 // a primitive type; special-case the return value. 273 const char* c_name = nullptr; 274 switch (descriptor[0]) { 275 case 'Z': c_name = "boolean"; break; 276 case 'B': c_name = "byte"; break; 277 case 'C': c_name = "char"; break; 278 case 'S': c_name = "short"; break; 279 case 'I': c_name = "int"; break; 280 case 'J': c_name = "long"; break; 281 case 'F': c_name = "float"; break; 282 case 'D': c_name = "double"; break; 283 case 'V': c_name = "void"; break; 284 default: 285 LOG(FATAL) << "Unknown primitive type: " << PrintableChar(descriptor[0]); 286 } 287 name = String::AllocFromModifiedUtf8(self, c_name); 288 } else { 289 // Convert the UTF-8 name to a java.lang.String. The name must use '.' to separate package 290 // components. 291 name = String::AllocFromModifiedUtf8(self, DescriptorToDot(descriptor).c_str()); 292 } 293 h_this->SetName(name); 294 return name; 295 } 296 297 void Class::DumpClass(std::ostream& os, int flags) { 298 if ((flags & kDumpClassFullDetail) == 0) { 299 os << PrettyClass(); 300 if ((flags & kDumpClassClassLoader) != 0) { 301 os << ' ' << GetClassLoader(); 302 } 303 if ((flags & kDumpClassInitialized) != 0) { 304 os << ' ' << GetStatus(); 305 } 306 os << "\n"; 307 return; 308 } 309 310 Thread* const self = Thread::Current(); 311 StackHandleScope<2> hs(self); 312 Handle<Class> h_this(hs.NewHandle(this)); 313 Handle<Class> h_super(hs.NewHandle(GetSuperClass())); 314 auto image_pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 315 316 std::string temp; 317 os << "----- " << (IsInterface() ? "interface" : "class") << " " 318 << "'" << GetDescriptor(&temp) << "' cl=" << GetClassLoader() << " -----\n", 319 os << " objectSize=" << SizeOf() << " " 320 << "(" << (h_super != nullptr ? h_super->SizeOf() : -1) << " from super)\n", 321 os << StringPrintf(" access=0x%04x.%04x\n", 322 GetAccessFlags() >> 16, GetAccessFlags() & kAccJavaFlagsMask); 323 if (h_super != nullptr) { 324 os << " super='" << h_super->PrettyClass() << "' (cl=" << h_super->GetClassLoader() 325 << ")\n"; 326 } 327 if (IsArrayClass()) { 328 os << " componentType=" << PrettyClass(GetComponentType()) << "\n"; 329 } 330 const size_t num_direct_interfaces = NumDirectInterfaces(); 331 if (num_direct_interfaces > 0) { 332 os << " interfaces (" << num_direct_interfaces << "):\n"; 333 for (size_t i = 0; i < num_direct_interfaces; ++i) { 334 ObjPtr<Class> interface = GetDirectInterface(self, h_this.Get(), i); 335 if (interface == nullptr) { 336 os << StringPrintf(" %2zd: nullptr!\n", i); 337 } else { 338 ObjPtr<ClassLoader> cl = interface->GetClassLoader(); 339 os << StringPrintf(" %2zd: %s (cl=%p)\n", i, PrettyClass(interface).c_str(), cl.Ptr()); 340 } 341 } 342 } 343 if (!IsLoaded()) { 344 os << " class not yet loaded"; 345 } else { 346 // After this point, this may have moved due to GetDirectInterface. 347 os << " vtable (" << h_this->NumVirtualMethods() << " entries, " 348 << (h_super != nullptr ? h_super->NumVirtualMethods() : 0) << " in super):\n"; 349 for (size_t i = 0; i < NumVirtualMethods(); ++i) { 350 os << StringPrintf(" %2zd: %s\n", i, ArtMethod::PrettyMethod( 351 h_this->GetVirtualMethodDuringLinking(i, image_pointer_size)).c_str()); 352 } 353 os << " direct methods (" << h_this->NumDirectMethods() << " entries):\n"; 354 for (size_t i = 0; i < h_this->NumDirectMethods(); ++i) { 355 os << StringPrintf(" %2zd: %s\n", i, ArtMethod::PrettyMethod( 356 h_this->GetDirectMethod(i, image_pointer_size)).c_str()); 357 } 358 if (h_this->NumStaticFields() > 0) { 359 os << " static fields (" << h_this->NumStaticFields() << " entries):\n"; 360 if (h_this->IsResolved()) { 361 for (size_t i = 0; i < h_this->NumStaticFields(); ++i) { 362 os << StringPrintf(" %2zd: %s\n", i, 363 ArtField::PrettyField(h_this->GetStaticField(i)).c_str()); 364 } 365 } else { 366 os << " <not yet available>"; 367 } 368 } 369 if (h_this->NumInstanceFields() > 0) { 370 os << " instance fields (" << h_this->NumInstanceFields() << " entries):\n"; 371 if (h_this->IsResolved()) { 372 for (size_t i = 0; i < h_this->NumInstanceFields(); ++i) { 373 os << StringPrintf(" %2zd: %s\n", i, 374 ArtField::PrettyField(h_this->GetInstanceField(i)).c_str()); 375 } 376 } else { 377 os << " <not yet available>"; 378 } 379 } 380 } 381 } 382 383 void Class::SetReferenceInstanceOffsets(uint32_t new_reference_offsets) { 384 if (kIsDebugBuild && new_reference_offsets != kClassWalkSuper) { 385 // Sanity check that the number of bits set in the reference offset bitmap 386 // agrees with the number of references 387 uint32_t count = 0; 388 for (ObjPtr<Class> c = this; c != nullptr; c = c->GetSuperClass()) { 389 count += c->NumReferenceInstanceFieldsDuringLinking(); 390 } 391 // +1 for the Class in Object. 392 CHECK_EQ(static_cast<uint32_t>(POPCOUNT(new_reference_offsets)) + 1, count); 393 } 394 // Not called within a transaction. 395 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_), 396 new_reference_offsets); 397 } 398 399 bool Class::IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2) { 400 size_t i = 0; 401 size_t min_length = std::min(descriptor1.size(), descriptor2.size()); 402 while (i < min_length && descriptor1[i] == descriptor2[i]) { 403 ++i; 404 } 405 if (descriptor1.find('/', i) != StringPiece::npos || 406 descriptor2.find('/', i) != StringPiece::npos) { 407 return false; 408 } else { 409 return true; 410 } 411 } 412 413 bool Class::IsInSamePackage(ObjPtr<Class> that) { 414 ObjPtr<Class> klass1 = this; 415 ObjPtr<Class> klass2 = that; 416 if (klass1 == klass2) { 417 return true; 418 } 419 // Class loaders must match. 420 if (klass1->GetClassLoader() != klass2->GetClassLoader()) { 421 return false; 422 } 423 // Arrays are in the same package when their element classes are. 424 while (klass1->IsArrayClass()) { 425 klass1 = klass1->GetComponentType(); 426 } 427 while (klass2->IsArrayClass()) { 428 klass2 = klass2->GetComponentType(); 429 } 430 // trivial check again for array types 431 if (klass1 == klass2) { 432 return true; 433 } 434 // Compare the package part of the descriptor string. 435 std::string temp1, temp2; 436 return IsInSamePackage(klass1->GetDescriptor(&temp1), klass2->GetDescriptor(&temp2)); 437 } 438 439 bool Class::IsThrowableClass() { 440 return WellKnownClasses::ToClass(WellKnownClasses::java_lang_Throwable)->IsAssignableFrom(this); 441 } 442 443 void Class::SetClassLoader(ObjPtr<ClassLoader> new_class_loader) { 444 if (Runtime::Current()->IsActiveTransaction()) { 445 SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader); 446 } else { 447 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader); 448 } 449 } 450 451 template <typename SignatureType> 452 static inline ArtMethod* FindInterfaceMethodWithSignature(ObjPtr<Class> klass, 453 const StringPiece& name, 454 const SignatureType& signature, 455 PointerSize pointer_size) 456 REQUIRES_SHARED(Locks::mutator_lock_) { 457 // If the current class is not an interface, skip the search of its declared methods; 458 // such lookup is used only to distinguish between IncompatibleClassChangeError and 459 // NoSuchMethodError and the caller has already tried to search methods in the class. 460 if (LIKELY(klass->IsInterface())) { 461 // Search declared methods, both direct and virtual. 462 // (This lookup is used also for invoke-static on interface classes.) 463 for (ArtMethod& method : klass->GetDeclaredMethodsSlice(pointer_size)) { 464 if (method.GetName() == name && method.GetSignature() == signature) { 465 return &method; 466 } 467 } 468 } 469 470 // TODO: If there is a unique maximally-specific non-abstract superinterface method, 471 // we should return it, otherwise an arbitrary one can be returned. 472 ObjPtr<IfTable> iftable = klass->GetIfTable(); 473 for (int32_t i = 0, iftable_count = iftable->Count(); i < iftable_count; ++i) { 474 ObjPtr<Class> iface = iftable->GetInterface(i); 475 for (ArtMethod& method : iface->GetVirtualMethodsSlice(pointer_size)) { 476 if (method.GetName() == name && method.GetSignature() == signature) { 477 return &method; 478 } 479 } 480 } 481 482 // Then search for public non-static methods in the java.lang.Object. 483 if (LIKELY(klass->IsInterface())) { 484 ObjPtr<Class> object_class = klass->GetSuperClass(); 485 DCHECK(object_class->IsObjectClass()); 486 for (ArtMethod& method : object_class->GetDeclaredMethodsSlice(pointer_size)) { 487 if (method.IsPublic() && !method.IsStatic() && 488 method.GetName() == name && method.GetSignature() == signature) { 489 return &method; 490 } 491 } 492 } 493 return nullptr; 494 } 495 496 ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, 497 const StringPiece& signature, 498 PointerSize pointer_size) { 499 return FindInterfaceMethodWithSignature(this, name, signature, pointer_size); 500 } 501 502 ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, 503 const Signature& signature, 504 PointerSize pointer_size) { 505 return FindInterfaceMethodWithSignature(this, name, signature, pointer_size); 506 } 507 508 ArtMethod* Class::FindInterfaceMethod(ObjPtr<DexCache> dex_cache, 509 uint32_t dex_method_idx, 510 PointerSize pointer_size) { 511 // We always search by name and signature, ignoring the type index in the MethodId. 512 const DexFile& dex_file = *dex_cache->GetDexFile(); 513 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx); 514 StringPiece name = dex_file.StringDataByIdx(method_id.name_idx_); 515 const Signature signature = dex_file.GetMethodSignature(method_id); 516 return FindInterfaceMethod(name, signature, pointer_size); 517 } 518 519 static inline bool IsValidInheritanceCheck(ObjPtr<mirror::Class> klass, 520 ObjPtr<mirror::Class> declaring_class) 521 REQUIRES_SHARED(Locks::mutator_lock_) { 522 if (klass->IsArrayClass()) { 523 return declaring_class->IsObjectClass(); 524 } else if (klass->IsInterface()) { 525 return declaring_class->IsObjectClass() || declaring_class == klass; 526 } else { 527 return klass->IsSubClass(declaring_class); 528 } 529 } 530 531 static inline bool IsInheritedMethod(ObjPtr<mirror::Class> klass, 532 ObjPtr<mirror::Class> declaring_class, 533 ArtMethod& method) 534 REQUIRES_SHARED(Locks::mutator_lock_) { 535 DCHECK_EQ(declaring_class, method.GetDeclaringClass()); 536 DCHECK_NE(klass, declaring_class); 537 DCHECK(IsValidInheritanceCheck(klass, declaring_class)); 538 uint32_t access_flags = method.GetAccessFlags(); 539 if ((access_flags & (kAccPublic | kAccProtected)) != 0) { 540 return true; 541 } 542 if ((access_flags & kAccPrivate) != 0) { 543 return false; 544 } 545 for (; klass != declaring_class; klass = klass->GetSuperClass()) { 546 if (!klass->IsInSamePackage(declaring_class)) { 547 return false; 548 } 549 } 550 return true; 551 } 552 553 template <typename SignatureType> 554 static inline ArtMethod* FindClassMethodWithSignature(ObjPtr<Class> this_klass, 555 const StringPiece& name, 556 const SignatureType& signature, 557 PointerSize pointer_size) 558 REQUIRES_SHARED(Locks::mutator_lock_) { 559 // Search declared methods first. 560 for (ArtMethod& method : this_klass->GetDeclaredMethodsSlice(pointer_size)) { 561 ArtMethod* np_method = method.GetInterfaceMethodIfProxy(pointer_size); 562 if (np_method->GetName() == name && np_method->GetSignature() == signature) { 563 return &method; 564 } 565 } 566 567 // Then search the superclass chain. If we find an inherited method, return it. 568 // If we find a method that's not inherited because of access restrictions, 569 // try to find a method inherited from an interface in copied methods. 570 ObjPtr<Class> klass = this_klass->GetSuperClass(); 571 ArtMethod* uninherited_method = nullptr; 572 for (; klass != nullptr; klass = klass->GetSuperClass()) { 573 DCHECK(!klass->IsProxyClass()); 574 for (ArtMethod& method : klass->GetDeclaredMethodsSlice(pointer_size)) { 575 if (method.GetName() == name && method.GetSignature() == signature) { 576 if (IsInheritedMethod(this_klass, klass, method)) { 577 return &method; 578 } 579 uninherited_method = &method; 580 break; 581 } 582 } 583 if (uninherited_method != nullptr) { 584 break; 585 } 586 } 587 588 // Then search copied methods. 589 // If we found a method that's not inherited, stop the search in its declaring class. 590 ObjPtr<Class> end_klass = klass; 591 DCHECK_EQ(uninherited_method != nullptr, end_klass != nullptr); 592 klass = this_klass; 593 if (UNLIKELY(klass->IsProxyClass())) { 594 DCHECK(klass->GetCopiedMethodsSlice(pointer_size).empty()); 595 klass = klass->GetSuperClass(); 596 } 597 for (; klass != end_klass; klass = klass->GetSuperClass()) { 598 DCHECK(!klass->IsProxyClass()); 599 for (ArtMethod& method : klass->GetCopiedMethodsSlice(pointer_size)) { 600 if (method.GetName() == name && method.GetSignature() == signature) { 601 return &method; // No further check needed, copied methods are inherited by definition. 602 } 603 } 604 } 605 return uninherited_method; // Return the `uninherited_method` if any. 606 } 607 608 609 ArtMethod* Class::FindClassMethod(const StringPiece& name, 610 const StringPiece& signature, 611 PointerSize pointer_size) { 612 return FindClassMethodWithSignature(this, name, signature, pointer_size); 613 } 614 615 ArtMethod* Class::FindClassMethod(const StringPiece& name, 616 const Signature& signature, 617 PointerSize pointer_size) { 618 return FindClassMethodWithSignature(this, name, signature, pointer_size); 619 } 620 621 ArtMethod* Class::FindClassMethod(ObjPtr<DexCache> dex_cache, 622 uint32_t dex_method_idx, 623 PointerSize pointer_size) { 624 // FIXME: Hijacking a proxy class by a custom class loader can break this assumption. 625 DCHECK(!IsProxyClass()); 626 627 // First try to find a declared method by dex_method_idx if we have a dex_cache match. 628 ObjPtr<DexCache> this_dex_cache = GetDexCache(); 629 if (this_dex_cache == dex_cache) { 630 // Lookup is always performed in the class referenced by the MethodId. 631 DCHECK_EQ(dex_type_idx_, GetDexFile().GetMethodId(dex_method_idx).class_idx_.index_); 632 for (ArtMethod& method : GetDeclaredMethodsSlice(pointer_size)) { 633 if (method.GetDexMethodIndex() == dex_method_idx) { 634 return &method; 635 } 636 } 637 } 638 // If not found, we need to search by name and signature. 639 const DexFile& dex_file = *dex_cache->GetDexFile(); 640 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx); 641 const Signature signature = dex_file.GetMethodSignature(method_id); 642 StringPiece name; // Delay strlen() until actually needed. 643 // If we do not have a dex_cache match, try to find the declared method in this class now. 644 if (this_dex_cache != dex_cache && !GetDeclaredMethodsSlice(pointer_size).empty()) { 645 DCHECK(name.empty()); 646 name = dex_file.StringDataByIdx(method_id.name_idx_); 647 for (ArtMethod& method : GetDeclaredMethodsSlice(pointer_size)) { 648 if (method.GetName() == name && method.GetSignature() == signature) { 649 return &method; 650 } 651 } 652 } 653 654 // Then search the superclass chain. If we find an inherited method, return it. 655 // If we find a method that's not inherited because of access restrictions, 656 // try to find a method inherited from an interface in copied methods. 657 ArtMethod* uninherited_method = nullptr; 658 ObjPtr<Class> klass = GetSuperClass(); 659 for (; klass != nullptr; klass = klass->GetSuperClass()) { 660 ArtMethod* candidate_method = nullptr; 661 ArraySlice<ArtMethod> declared_methods = klass->GetDeclaredMethodsSlice(pointer_size); 662 if (klass->GetDexCache() == dex_cache) { 663 // Matching dex_cache. We cannot compare the `dex_method_idx` anymore because 664 // the type index differs, so compare the name index and proto index. 665 for (ArtMethod& method : declared_methods) { 666 const DexFile::MethodId& cmp_method_id = dex_file.GetMethodId(method.GetDexMethodIndex()); 667 if (cmp_method_id.name_idx_ == method_id.name_idx_ && 668 cmp_method_id.proto_idx_ == method_id.proto_idx_) { 669 candidate_method = &method; 670 break; 671 } 672 } 673 } else { 674 if (!declared_methods.empty() && name.empty()) { 675 name = dex_file.StringDataByIdx(method_id.name_idx_); 676 } 677 for (ArtMethod& method : declared_methods) { 678 if (method.GetName() == name && method.GetSignature() == signature) { 679 candidate_method = &method; 680 break; 681 } 682 } 683 } 684 if (candidate_method != nullptr) { 685 if (IsInheritedMethod(this, klass, *candidate_method)) { 686 return candidate_method; 687 } else { 688 uninherited_method = candidate_method; 689 break; 690 } 691 } 692 } 693 694 // Then search copied methods. 695 // If we found a method that's not inherited, stop the search in its declaring class. 696 ObjPtr<Class> end_klass = klass; 697 DCHECK_EQ(uninherited_method != nullptr, end_klass != nullptr); 698 // After we have searched the declared methods of the super-class chain, 699 // search copied methods which can contain methods from interfaces. 700 for (klass = this; klass != end_klass; klass = klass->GetSuperClass()) { 701 ArraySlice<ArtMethod> copied_methods = klass->GetCopiedMethodsSlice(pointer_size); 702 if (!copied_methods.empty() && name.empty()) { 703 name = dex_file.StringDataByIdx(method_id.name_idx_); 704 } 705 for (ArtMethod& method : copied_methods) { 706 if (method.GetName() == name && method.GetSignature() == signature) { 707 return &method; // No further check needed, copied methods are inherited by definition. 708 } 709 } 710 } 711 return uninherited_method; // Return the `uninherited_method` if any. 712 } 713 714 ArtMethod* Class::FindConstructor(const StringPiece& signature, PointerSize pointer_size) { 715 // Internal helper, never called on proxy classes. We can skip GetInterfaceMethodIfProxy(). 716 DCHECK(!IsProxyClass()); 717 StringPiece name("<init>"); 718 for (ArtMethod& method : GetDirectMethodsSliceUnchecked(pointer_size)) { 719 if (method.GetName() == name && method.GetSignature() == signature) { 720 return &method; 721 } 722 } 723 return nullptr; 724 } 725 726 ArtMethod* Class::FindDeclaredDirectMethodByName(const StringPiece& name, 727 PointerSize pointer_size) { 728 for (auto& method : GetDirectMethods(pointer_size)) { 729 ArtMethod* const np_method = method.GetInterfaceMethodIfProxy(pointer_size); 730 if (name == np_method->GetName()) { 731 return &method; 732 } 733 } 734 return nullptr; 735 } 736 737 ArtMethod* Class::FindDeclaredVirtualMethodByName(const StringPiece& name, 738 PointerSize pointer_size) { 739 for (auto& method : GetVirtualMethods(pointer_size)) { 740 ArtMethod* const np_method = method.GetInterfaceMethodIfProxy(pointer_size); 741 if (name == np_method->GetName()) { 742 return &method; 743 } 744 } 745 return nullptr; 746 } 747 748 ArtMethod* Class::FindVirtualMethodForInterfaceSuper(ArtMethod* method, PointerSize pointer_size) { 749 DCHECK(method->GetDeclaringClass()->IsInterface()); 750 DCHECK(IsInterface()) << "Should only be called on a interface class"; 751 // Check if we have one defined on this interface first. This includes searching copied ones to 752 // get any conflict methods. Conflict methods are copied into each subtype from the supertype. We 753 // don't do any indirect method checks here. 754 for (ArtMethod& iface_method : GetVirtualMethods(pointer_size)) { 755 if (method->HasSameNameAndSignature(&iface_method)) { 756 return &iface_method; 757 } 758 } 759 760 std::vector<ArtMethod*> abstract_methods; 761 // Search through the IFTable for a working version. We don't need to check for conflicts 762 // because if there was one it would appear in this classes virtual_methods_ above. 763 764 Thread* self = Thread::Current(); 765 StackHandleScope<2> hs(self); 766 MutableHandle<IfTable> iftable(hs.NewHandle(GetIfTable())); 767 MutableHandle<Class> iface(hs.NewHandle<Class>(nullptr)); 768 size_t iftable_count = GetIfTableCount(); 769 // Find the method. We don't need to check for conflicts because they would have been in the 770 // copied virtuals of this interface. Order matters, traverse in reverse topological order; most 771 // subtypiest interfaces get visited first. 772 for (size_t k = iftable_count; k != 0;) { 773 k--; 774 DCHECK_LT(k, iftable->Count()); 775 iface.Assign(iftable->GetInterface(k)); 776 // Iterate through every declared method on this interface. Each direct method's name/signature 777 // is unique so the order of the inner loop doesn't matter. 778 for (auto& method_iter : iface->GetDeclaredVirtualMethods(pointer_size)) { 779 ArtMethod* current_method = &method_iter; 780 if (current_method->HasSameNameAndSignature(method)) { 781 if (current_method->IsDefault()) { 782 // Handle JLS soft errors, a default method from another superinterface tree can 783 // "override" an abstract method(s) from another superinterface tree(s). To do this, 784 // ignore any [default] method which are dominated by the abstract methods we've seen so 785 // far. Check if overridden by any in abstract_methods. We do not need to check for 786 // default_conflicts because we would hit those before we get to this loop. 787 bool overridden = false; 788 for (ArtMethod* possible_override : abstract_methods) { 789 DCHECK(possible_override->HasSameNameAndSignature(current_method)); 790 if (iface->IsAssignableFrom(possible_override->GetDeclaringClass())) { 791 overridden = true; 792 break; 793 } 794 } 795 if (!overridden) { 796 return current_method; 797 } 798 } else { 799 // Is not default. 800 // This might override another default method. Just stash it for now. 801 abstract_methods.push_back(current_method); 802 } 803 } 804 } 805 } 806 // If we reach here we either never found any declaration of the method (in which case 807 // 'abstract_methods' is empty or we found no non-overriden default methods in which case 808 // 'abstract_methods' contains a number of abstract implementations of the methods. We choose one 809 // of these arbitrarily. 810 return abstract_methods.empty() ? nullptr : abstract_methods[0]; 811 } 812 813 ArtMethod* Class::FindClassInitializer(PointerSize pointer_size) { 814 for (ArtMethod& method : GetDirectMethods(pointer_size)) { 815 if (method.IsClassInitializer()) { 816 DCHECK_STREQ(method.GetName(), "<clinit>"); 817 DCHECK_STREQ(method.GetSignature().ToString().c_str(), "()V"); 818 return &method; 819 } 820 } 821 return nullptr; 822 } 823 824 // Custom binary search to avoid double comparisons from std::binary_search. 825 static ArtField* FindFieldByNameAndType(LengthPrefixedArray<ArtField>* fields, 826 const StringPiece& name, 827 const StringPiece& type) 828 REQUIRES_SHARED(Locks::mutator_lock_) { 829 if (fields == nullptr) { 830 return nullptr; 831 } 832 size_t low = 0; 833 size_t high = fields->size(); 834 ArtField* ret = nullptr; 835 while (low < high) { 836 size_t mid = (low + high) / 2; 837 ArtField& field = fields->At(mid); 838 // Fields are sorted by class, then name, then type descriptor. This is verified in dex file 839 // verifier. There can be multiple fields with the same in the same class name due to proguard. 840 int result = StringPiece(field.GetName()).Compare(name); 841 if (result == 0) { 842 result = StringPiece(field.GetTypeDescriptor()).Compare(type); 843 } 844 if (result < 0) { 845 low = mid + 1; 846 } else if (result > 0) { 847 high = mid; 848 } else { 849 ret = &field; 850 break; 851 } 852 } 853 if (kIsDebugBuild) { 854 ArtField* found = nullptr; 855 for (ArtField& field : MakeIterationRangeFromLengthPrefixedArray(fields)) { 856 if (name == field.GetName() && type == field.GetTypeDescriptor()) { 857 found = &field; 858 break; 859 } 860 } 861 CHECK_EQ(found, ret) << "Found " << found->PrettyField() << " vs " << ret->PrettyField(); 862 } 863 return ret; 864 } 865 866 ArtField* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) { 867 // Binary search by name. Interfaces are not relevant because they can't contain instance fields. 868 return FindFieldByNameAndType(GetIFieldsPtr(), name, type); 869 } 870 871 ArtField* Class::FindDeclaredInstanceField(ObjPtr<DexCache> dex_cache, uint32_t dex_field_idx) { 872 if (GetDexCache() == dex_cache) { 873 for (ArtField& field : GetIFields()) { 874 if (field.GetDexFieldIndex() == dex_field_idx) { 875 return &field; 876 } 877 } 878 } 879 return nullptr; 880 } 881 882 ArtField* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) { 883 // Is the field in this class, or any of its superclasses? 884 // Interfaces are not relevant because they can't contain instance fields. 885 for (ObjPtr<Class> c = this; c != nullptr; c = c->GetSuperClass()) { 886 ArtField* f = c->FindDeclaredInstanceField(name, type); 887 if (f != nullptr) { 888 return f; 889 } 890 } 891 return nullptr; 892 } 893 894 ArtField* Class::FindInstanceField(ObjPtr<DexCache> dex_cache, uint32_t dex_field_idx) { 895 // Is the field in this class, or any of its superclasses? 896 // Interfaces are not relevant because they can't contain instance fields. 897 for (ObjPtr<Class> c = this; c != nullptr; c = c->GetSuperClass()) { 898 ArtField* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx); 899 if (f != nullptr) { 900 return f; 901 } 902 } 903 return nullptr; 904 } 905 906 ArtField* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) { 907 DCHECK(type != nullptr); 908 return FindFieldByNameAndType(GetSFieldsPtr(), name, type); 909 } 910 911 ArtField* Class::FindDeclaredStaticField(ObjPtr<DexCache> dex_cache, uint32_t dex_field_idx) { 912 if (dex_cache == GetDexCache()) { 913 for (ArtField& field : GetSFields()) { 914 if (field.GetDexFieldIndex() == dex_field_idx) { 915 return &field; 916 } 917 } 918 } 919 return nullptr; 920 } 921 922 ArtField* Class::FindStaticField(Thread* self, 923 ObjPtr<Class> klass, 924 const StringPiece& name, 925 const StringPiece& type) { 926 // Is the field in this class (or its interfaces), or any of its 927 // superclasses (or their interfaces)? 928 for (ObjPtr<Class> k = klass; k != nullptr; k = k->GetSuperClass()) { 929 // Is the field in this class? 930 ArtField* f = k->FindDeclaredStaticField(name, type); 931 if (f != nullptr) { 932 return f; 933 } 934 // Is this field in any of this class' interfaces? 935 for (uint32_t i = 0, num_interfaces = k->NumDirectInterfaces(); i != num_interfaces; ++i) { 936 ObjPtr<Class> interface = GetDirectInterface(self, k, i); 937 DCHECK(interface != nullptr); 938 f = FindStaticField(self, interface, name, type); 939 if (f != nullptr) { 940 return f; 941 } 942 } 943 } 944 return nullptr; 945 } 946 947 ArtField* Class::FindStaticField(Thread* self, 948 ObjPtr<Class> klass, 949 ObjPtr<DexCache> dex_cache, 950 uint32_t dex_field_idx) { 951 for (ObjPtr<Class> k = klass; k != nullptr; k = k->GetSuperClass()) { 952 // Is the field in this class? 953 ArtField* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx); 954 if (f != nullptr) { 955 return f; 956 } 957 // Though GetDirectInterface() should not cause thread suspension when called 958 // from here, it takes a Handle as an argument, so we need to wrap `k`. 959 ScopedAssertNoThreadSuspension ants(__FUNCTION__); 960 // Is this field in any of this class' interfaces? 961 for (uint32_t i = 0, num_interfaces = k->NumDirectInterfaces(); i != num_interfaces; ++i) { 962 ObjPtr<Class> interface = GetDirectInterface(self, k, i); 963 DCHECK(interface != nullptr); 964 f = FindStaticField(self, interface, dex_cache, dex_field_idx); 965 if (f != nullptr) { 966 return f; 967 } 968 } 969 } 970 return nullptr; 971 } 972 973 ArtField* Class::FindField(Thread* self, 974 ObjPtr<Class> klass, 975 const StringPiece& name, 976 const StringPiece& type) { 977 // Find a field using the JLS field resolution order 978 for (ObjPtr<Class> k = klass; k != nullptr; k = k->GetSuperClass()) { 979 // Is the field in this class? 980 ArtField* f = k->FindDeclaredInstanceField(name, type); 981 if (f != nullptr) { 982 return f; 983 } 984 f = k->FindDeclaredStaticField(name, type); 985 if (f != nullptr) { 986 return f; 987 } 988 // Is this field in any of this class' interfaces? 989 for (uint32_t i = 0, num_interfaces = k->NumDirectInterfaces(); i != num_interfaces; ++i) { 990 ObjPtr<Class> interface = GetDirectInterface(self, k, i); 991 DCHECK(interface != nullptr); 992 f = FindStaticField(self, interface, name, type); 993 if (f != nullptr) { 994 return f; 995 } 996 } 997 } 998 return nullptr; 999 } 1000 1001 void Class::SetSkipAccessChecksFlagOnAllMethods(PointerSize pointer_size) { 1002 DCHECK(IsVerified()); 1003 for (auto& m : GetMethods(pointer_size)) { 1004 if (!m.IsNative() && m.IsInvokable()) { 1005 m.SetSkipAccessChecks(); 1006 } 1007 } 1008 } 1009 1010 const char* Class::GetDescriptor(std::string* storage) { 1011 if (IsPrimitive()) { 1012 return Primitive::Descriptor(GetPrimitiveType()); 1013 } else if (IsArrayClass()) { 1014 return GetArrayDescriptor(storage); 1015 } else if (IsProxyClass()) { 1016 *storage = Runtime::Current()->GetClassLinker()->GetDescriptorForProxy(this); 1017 return storage->c_str(); 1018 } else { 1019 const DexFile& dex_file = GetDexFile(); 1020 const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_); 1021 return dex_file.GetTypeDescriptor(type_id); 1022 } 1023 } 1024 1025 const char* Class::GetArrayDescriptor(std::string* storage) { 1026 std::string temp; 1027 const char* elem_desc = GetComponentType()->GetDescriptor(&temp); 1028 *storage = "["; 1029 *storage += elem_desc; 1030 return storage->c_str(); 1031 } 1032 1033 const DexFile::ClassDef* Class::GetClassDef() { 1034 uint16_t class_def_idx = GetDexClassDefIndex(); 1035 if (class_def_idx == DexFile::kDexNoIndex16) { 1036 return nullptr; 1037 } 1038 return &GetDexFile().GetClassDef(class_def_idx); 1039 } 1040 1041 dex::TypeIndex Class::GetDirectInterfaceTypeIdx(uint32_t idx) { 1042 DCHECK(!IsPrimitive()); 1043 DCHECK(!IsArrayClass()); 1044 return GetInterfaceTypeList()->GetTypeItem(idx).type_idx_; 1045 } 1046 1047 ObjPtr<Class> Class::GetDirectInterface(Thread* self, ObjPtr<Class> klass, uint32_t idx) { 1048 DCHECK(klass != nullptr); 1049 DCHECK(!klass->IsPrimitive()); 1050 if (klass->IsArrayClass()) { 1051 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1052 // Use ClassLinker::LookupClass(); avoid poisoning ObjPtr<>s by ClassLinker::FindSystemClass(). 1053 ObjPtr<Class> interface; 1054 if (idx == 0) { 1055 interface = class_linker->LookupClass(self, "Ljava/lang/Cloneable;", nullptr); 1056 } else { 1057 DCHECK_EQ(1U, idx); 1058 interface = class_linker->LookupClass(self, "Ljava/io/Serializable;", nullptr); 1059 } 1060 DCHECK(interface != nullptr); 1061 return interface; 1062 } else if (klass->IsProxyClass()) { 1063 ObjPtr<ObjectArray<Class>> interfaces = klass->GetProxyInterfaces(); 1064 DCHECK(interfaces != nullptr); 1065 return interfaces->Get(idx); 1066 } else { 1067 dex::TypeIndex type_idx = klass->GetDirectInterfaceTypeIdx(idx); 1068 ObjPtr<Class> interface = Runtime::Current()->GetClassLinker()->LookupResolvedType( 1069 type_idx, klass->GetDexCache(), klass->GetClassLoader()); 1070 return interface; 1071 } 1072 } 1073 1074 ObjPtr<Class> Class::ResolveDirectInterface(Thread* self, Handle<Class> klass, uint32_t idx) { 1075 ObjPtr<Class> interface = GetDirectInterface(self, klass.Get(), idx); 1076 if (interface == nullptr) { 1077 DCHECK(!klass->IsArrayClass()); 1078 DCHECK(!klass->IsProxyClass()); 1079 dex::TypeIndex type_idx = klass->GetDirectInterfaceTypeIdx(idx); 1080 interface = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, klass.Get()); 1081 CHECK(interface != nullptr || self->IsExceptionPending()); 1082 } 1083 return interface; 1084 } 1085 1086 ObjPtr<Class> Class::GetCommonSuperClass(Handle<Class> klass) { 1087 DCHECK(klass != nullptr); 1088 DCHECK(!klass->IsInterface()); 1089 DCHECK(!IsInterface()); 1090 ObjPtr<Class> common_super_class = this; 1091 while (!common_super_class->IsAssignableFrom(klass.Get())) { 1092 ObjPtr<Class> old_common = common_super_class; 1093 common_super_class = old_common->GetSuperClass(); 1094 DCHECK(common_super_class != nullptr) << old_common->PrettyClass(); 1095 } 1096 return common_super_class; 1097 } 1098 1099 const char* Class::GetSourceFile() { 1100 const DexFile& dex_file = GetDexFile(); 1101 const DexFile::ClassDef* dex_class_def = GetClassDef(); 1102 if (dex_class_def == nullptr) { 1103 // Generated classes have no class def. 1104 return nullptr; 1105 } 1106 return dex_file.GetSourceFile(*dex_class_def); 1107 } 1108 1109 std::string Class::GetLocation() { 1110 ObjPtr<DexCache> dex_cache = GetDexCache(); 1111 if (dex_cache != nullptr && !IsProxyClass()) { 1112 return dex_cache->GetLocation()->ToModifiedUtf8(); 1113 } 1114 // Arrays and proxies are generated and have no corresponding dex file location. 1115 return "generated class"; 1116 } 1117 1118 const DexFile::TypeList* Class::GetInterfaceTypeList() { 1119 const DexFile::ClassDef* class_def = GetClassDef(); 1120 if (class_def == nullptr) { 1121 return nullptr; 1122 } 1123 return GetDexFile().GetInterfacesList(*class_def); 1124 } 1125 1126 void Class::PopulateEmbeddedVTable(PointerSize pointer_size) { 1127 PointerArray* table = GetVTableDuringLinking(); 1128 CHECK(table != nullptr) << PrettyClass(); 1129 const size_t table_length = table->GetLength(); 1130 SetEmbeddedVTableLength(table_length); 1131 for (size_t i = 0; i < table_length; i++) { 1132 SetEmbeddedVTableEntry(i, table->GetElementPtrSize<ArtMethod*>(i, pointer_size), pointer_size); 1133 } 1134 // Keep java.lang.Object class's vtable around for since it's easier 1135 // to be reused by array classes during their linking. 1136 if (!IsObjectClass()) { 1137 SetVTable(nullptr); 1138 } 1139 } 1140 1141 class ReadBarrierOnNativeRootsVisitor { 1142 public: 1143 void operator()(ObjPtr<Object> obj ATTRIBUTE_UNUSED, 1144 MemberOffset offset ATTRIBUTE_UNUSED, 1145 bool is_static ATTRIBUTE_UNUSED) const {} 1146 1147 void VisitRootIfNonNull(CompressedReference<Object>* root) const 1148 REQUIRES_SHARED(Locks::mutator_lock_) { 1149 if (!root->IsNull()) { 1150 VisitRoot(root); 1151 } 1152 } 1153 1154 void VisitRoot(CompressedReference<Object>* root) const 1155 REQUIRES_SHARED(Locks::mutator_lock_) { 1156 ObjPtr<Object> old_ref = root->AsMirrorPtr(); 1157 ObjPtr<Object> new_ref = ReadBarrier::BarrierForRoot(root); 1158 if (old_ref != new_ref) { 1159 // Update the field atomically. This may fail if mutator updates before us, but it's ok. 1160 auto* atomic_root = 1161 reinterpret_cast<Atomic<CompressedReference<Object>>*>(root); 1162 atomic_root->CompareAndSetStrongSequentiallyConsistent( 1163 CompressedReference<Object>::FromMirrorPtr(old_ref.Ptr()), 1164 CompressedReference<Object>::FromMirrorPtr(new_ref.Ptr())); 1165 } 1166 } 1167 }; 1168 1169 // The pre-fence visitor for Class::CopyOf(). 1170 class CopyClassVisitor { 1171 public: 1172 CopyClassVisitor(Thread* self, 1173 Handle<Class>* orig, 1174 size_t new_length, 1175 size_t copy_bytes, 1176 ImTable* imt, 1177 PointerSize pointer_size) 1178 : self_(self), orig_(orig), new_length_(new_length), 1179 copy_bytes_(copy_bytes), imt_(imt), pointer_size_(pointer_size) { 1180 } 1181 1182 void operator()(ObjPtr<Object> obj, size_t usable_size ATTRIBUTE_UNUSED) const 1183 REQUIRES_SHARED(Locks::mutator_lock_) { 1184 StackHandleScope<1> hs(self_); 1185 Handle<mirror::Class> h_new_class_obj(hs.NewHandle(obj->AsClass())); 1186 Object::CopyObject(h_new_class_obj.Get(), orig_->Get(), copy_bytes_); 1187 Class::SetStatus(h_new_class_obj, ClassStatus::kResolving, self_); 1188 h_new_class_obj->PopulateEmbeddedVTable(pointer_size_); 1189 h_new_class_obj->SetImt(imt_, pointer_size_); 1190 h_new_class_obj->SetClassSize(new_length_); 1191 // Visit all of the references to make sure there is no from space references in the native 1192 // roots. 1193 ObjPtr<Object>(h_new_class_obj.Get())->VisitReferences( 1194 ReadBarrierOnNativeRootsVisitor(), VoidFunctor()); 1195 } 1196 1197 private: 1198 Thread* const self_; 1199 Handle<Class>* const orig_; 1200 const size_t new_length_; 1201 const size_t copy_bytes_; 1202 ImTable* imt_; 1203 const PointerSize pointer_size_; 1204 DISALLOW_COPY_AND_ASSIGN(CopyClassVisitor); 1205 }; 1206 1207 Class* Class::CopyOf(Thread* self, int32_t new_length, ImTable* imt, PointerSize pointer_size) { 1208 DCHECK_GE(new_length, static_cast<int32_t>(sizeof(Class))); 1209 // We may get copied by a compacting GC. 1210 StackHandleScope<1> hs(self); 1211 Handle<Class> h_this(hs.NewHandle(this)); 1212 gc::Heap* heap = Runtime::Current()->GetHeap(); 1213 // The num_bytes (3rd param) is sizeof(Class) as opposed to SizeOf() 1214 // to skip copying the tail part that we will overwrite here. 1215 CopyClassVisitor visitor(self, &h_this, new_length, sizeof(Class), imt, pointer_size); 1216 ObjPtr<Object> new_class = kMovingClasses ? 1217 heap->AllocObject<true>(self, java_lang_Class_.Read(), new_length, visitor) : 1218 heap->AllocNonMovableObject<true>(self, java_lang_Class_.Read(), new_length, visitor); 1219 if (UNLIKELY(new_class == nullptr)) { 1220 self->AssertPendingOOMException(); 1221 return nullptr; 1222 } 1223 return new_class->AsClass(); 1224 } 1225 1226 bool Class::ProxyDescriptorEquals(const char* match) { 1227 DCHECK(IsProxyClass()); 1228 return Runtime::Current()->GetClassLinker()->GetDescriptorForProxy(this) == match; 1229 } 1230 1231 // TODO: Move this to java_lang_Class.cc? 1232 ArtMethod* Class::GetDeclaredConstructor( 1233 Thread* self, Handle<ObjectArray<Class>> args, PointerSize pointer_size) { 1234 for (auto& m : GetDirectMethods(pointer_size)) { 1235 // Skip <clinit> which is a static constructor, as well as non constructors. 1236 if (m.IsStatic() || !m.IsConstructor()) { 1237 continue; 1238 } 1239 // May cause thread suspension and exceptions. 1240 if (m.GetInterfaceMethodIfProxy(kRuntimePointerSize)->EqualParameters(args)) { 1241 return &m; 1242 } 1243 if (UNLIKELY(self->IsExceptionPending())) { 1244 return nullptr; 1245 } 1246 } 1247 return nullptr; 1248 } 1249 1250 uint32_t Class::Depth() { 1251 uint32_t depth = 0; 1252 for (ObjPtr<Class> klass = this; klass->GetSuperClass() != nullptr; klass = klass->GetSuperClass()) { 1253 depth++; 1254 } 1255 return depth; 1256 } 1257 1258 dex::TypeIndex Class::FindTypeIndexInOtherDexFile(const DexFile& dex_file) { 1259 std::string temp; 1260 const DexFile::TypeId* type_id = dex_file.FindTypeId(GetDescriptor(&temp)); 1261 return (type_id == nullptr) ? dex::TypeIndex() : dex_file.GetIndexForTypeId(*type_id); 1262 } 1263 1264 template <PointerSize kPointerSize, bool kTransactionActive> 1265 ObjPtr<Method> Class::GetDeclaredMethodInternal( 1266 Thread* self, 1267 ObjPtr<Class> klass, 1268 ObjPtr<String> name, 1269 ObjPtr<ObjectArray<Class>> args) { 1270 // Covariant return types permit the class to define multiple 1271 // methods with the same name and parameter types. Prefer to 1272 // return a non-synthetic method in such situations. We may 1273 // still return a synthetic method to handle situations like 1274 // escalated visibility. We never return miranda methods that 1275 // were synthesized by the runtime. 1276 StackHandleScope<3> hs(self); 1277 auto h_method_name = hs.NewHandle(name); 1278 if (UNLIKELY(h_method_name == nullptr)) { 1279 ThrowNullPointerException("name == null"); 1280 return nullptr; 1281 } 1282 auto h_args = hs.NewHandle(args); 1283 Handle<Class> h_klass = hs.NewHandle(klass); 1284 ArtMethod* result = nullptr; 1285 for (auto& m : h_klass->GetDeclaredVirtualMethods(kPointerSize)) { 1286 auto* np_method = m.GetInterfaceMethodIfProxy(kPointerSize); 1287 // May cause thread suspension. 1288 ObjPtr<String> np_name = np_method->GetNameAsString(self); 1289 if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) { 1290 if (UNLIKELY(self->IsExceptionPending())) { 1291 return nullptr; 1292 } 1293 continue; 1294 } 1295 if (!m.IsMiranda()) { 1296 if (!m.IsSynthetic()) { 1297 return Method::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, &m); 1298 } 1299 result = &m; // Remember as potential result if it's not a miranda method. 1300 } 1301 } 1302 if (result == nullptr) { 1303 for (auto& m : h_klass->GetDirectMethods(kPointerSize)) { 1304 auto modifiers = m.GetAccessFlags(); 1305 if ((modifiers & kAccConstructor) != 0) { 1306 continue; 1307 } 1308 auto* np_method = m.GetInterfaceMethodIfProxy(kPointerSize); 1309 // May cause thread suspension. 1310 ObjPtr<String> np_name = np_method->GetNameAsString(self); 1311 if (np_name == nullptr) { 1312 self->AssertPendingException(); 1313 return nullptr; 1314 } 1315 if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) { 1316 if (UNLIKELY(self->IsExceptionPending())) { 1317 return nullptr; 1318 } 1319 continue; 1320 } 1321 DCHECK(!m.IsMiranda()); // Direct methods cannot be miranda methods. 1322 if ((modifiers & kAccSynthetic) == 0) { 1323 return Method::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, &m); 1324 } 1325 result = &m; // Remember as potential result. 1326 } 1327 } 1328 return result != nullptr 1329 ? Method::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, result) 1330 : nullptr; 1331 } 1332 1333 template 1334 ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k32, false>( 1335 Thread* self, 1336 ObjPtr<Class> klass, 1337 ObjPtr<String> name, 1338 ObjPtr<ObjectArray<Class>> args); 1339 template 1340 ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k32, true>( 1341 Thread* self, 1342 ObjPtr<Class> klass, 1343 ObjPtr<String> name, 1344 ObjPtr<ObjectArray<Class>> args); 1345 template 1346 ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k64, false>( 1347 Thread* self, 1348 ObjPtr<Class> klass, 1349 ObjPtr<String> name, 1350 ObjPtr<ObjectArray<Class>> args); 1351 template 1352 ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k64, true>( 1353 Thread* self, 1354 ObjPtr<Class> klass, 1355 ObjPtr<String> name, 1356 ObjPtr<ObjectArray<Class>> args); 1357 1358 template <PointerSize kPointerSize, bool kTransactionActive> 1359 ObjPtr<Constructor> Class::GetDeclaredConstructorInternal( 1360 Thread* self, 1361 ObjPtr<Class> klass, 1362 ObjPtr<ObjectArray<Class>> args) { 1363 StackHandleScope<1> hs(self); 1364 ArtMethod* result = klass->GetDeclaredConstructor(self, hs.NewHandle(args), kPointerSize); 1365 return result != nullptr 1366 ? Constructor::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, result) 1367 : nullptr; 1368 } 1369 1370 // Constructor::CreateFromArtMethod<kTransactionActive>(self, result) 1371 1372 template 1373 ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k32, false>( 1374 Thread* self, 1375 ObjPtr<Class> klass, 1376 ObjPtr<ObjectArray<Class>> args); 1377 template 1378 ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k32, true>( 1379 Thread* self, 1380 ObjPtr<Class> klass, 1381 ObjPtr<ObjectArray<Class>> args); 1382 template 1383 ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k64, false>( 1384 Thread* self, 1385 ObjPtr<Class> klass, 1386 ObjPtr<ObjectArray<Class>> args); 1387 template 1388 ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k64, true>( 1389 Thread* self, 1390 ObjPtr<Class> klass, 1391 ObjPtr<ObjectArray<Class>> args); 1392 1393 int32_t Class::GetInnerClassFlags(Handle<Class> h_this, int32_t default_value) { 1394 if (h_this->IsProxyClass() || h_this->GetDexCache() == nullptr) { 1395 return default_value; 1396 } 1397 uint32_t flags; 1398 if (!annotations::GetInnerClassFlags(h_this, &flags)) { 1399 return default_value; 1400 } 1401 return flags; 1402 } 1403 1404 void Class::SetObjectSizeAllocFastPath(uint32_t new_object_size) { 1405 if (Runtime::Current()->IsActiveTransaction()) { 1406 SetField32Volatile<true>(ObjectSizeAllocFastPathOffset(), new_object_size); 1407 } else { 1408 SetField32Volatile<false>(ObjectSizeAllocFastPathOffset(), new_object_size); 1409 } 1410 } 1411 1412 std::string Class::PrettyDescriptor(ObjPtr<mirror::Class> klass) { 1413 if (klass == nullptr) { 1414 return "null"; 1415 } 1416 return klass->PrettyDescriptor(); 1417 } 1418 1419 std::string Class::PrettyDescriptor() { 1420 std::string temp; 1421 return art::PrettyDescriptor(GetDescriptor(&temp)); 1422 } 1423 1424 std::string Class::PrettyClass(ObjPtr<mirror::Class> c) { 1425 if (c == nullptr) { 1426 return "null"; 1427 } 1428 return c->PrettyClass(); 1429 } 1430 1431 std::string Class::PrettyClass() { 1432 std::string result; 1433 result += "java.lang.Class<"; 1434 result += PrettyDescriptor(); 1435 result += ">"; 1436 return result; 1437 } 1438 1439 std::string Class::PrettyClassAndClassLoader(ObjPtr<mirror::Class> c) { 1440 if (c == nullptr) { 1441 return "null"; 1442 } 1443 return c->PrettyClassAndClassLoader(); 1444 } 1445 1446 std::string Class::PrettyClassAndClassLoader() { 1447 std::string result; 1448 result += "java.lang.Class<"; 1449 result += PrettyDescriptor(); 1450 result += ","; 1451 result += mirror::Object::PrettyTypeOf(GetClassLoader()); 1452 // TODO: add an identifying hash value for the loader 1453 result += ">"; 1454 return result; 1455 } 1456 1457 template<VerifyObjectFlags kVerifyFlags> void Class::GetAccessFlagsDCheck() { 1458 // Check class is loaded/retired or this is java.lang.String that has a 1459 // circularity issue during loading the names of its members 1460 DCHECK(IsIdxLoaded<kVerifyFlags>() || IsRetired<kVerifyFlags>() || 1461 IsErroneous<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>() || 1462 this == String::GetJavaLangString()) 1463 << "IsIdxLoaded=" << IsIdxLoaded<kVerifyFlags>() 1464 << " IsRetired=" << IsRetired<kVerifyFlags>() 1465 << " IsErroneous=" << 1466 IsErroneous<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>() 1467 << " IsString=" << (this == String::GetJavaLangString()) 1468 << " status= " << GetStatus<kVerifyFlags>() 1469 << " descriptor=" << PrettyDescriptor(); 1470 } 1471 // Instantiate the common cases. 1472 template void Class::GetAccessFlagsDCheck<kVerifyNone>(); 1473 template void Class::GetAccessFlagsDCheck<kVerifyThis>(); 1474 template void Class::GetAccessFlagsDCheck<kVerifyReads>(); 1475 template void Class::GetAccessFlagsDCheck<kVerifyWrites>(); 1476 template void Class::GetAccessFlagsDCheck<kVerifyAll>(); 1477 1478 } // namespace mirror 1479 } // namespace art 1480