class_linker.h revision a49e053faa4a254df1f21e055cb73555de241cfc
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#ifndef ART_RUNTIME_CLASS_LINKER_H_ 18#define ART_RUNTIME_CLASS_LINKER_H_ 19 20#include <set> 21#include <string> 22#include <unordered_map> 23#include <unordered_set> 24#include <utility> 25#include <vector> 26 27#include "base/enums.h" 28#include "base/macros.h" 29#include "base/mutex.h" 30#include "dex_cache_resolved_classes.h" 31#include "dex_file.h" 32#include "dex_file_types.h" 33#include "gc_root.h" 34#include "handle.h" 35#include "jni.h" 36#include "mirror/class.h" 37#include "verifier/verifier_enums.h" 38 39namespace art { 40 41namespace gc { 42namespace space { 43 class ImageSpace; 44} // namespace space 45} // namespace gc 46namespace mirror { 47 class ClassLoader; 48 class DexCache; 49 class DexCachePointerArray; 50 class DexCacheMethodHandlesTest_Open_Test; 51 class DexCacheTest_Open_Test; 52 class IfTable; 53 class MethodHandle; 54 class MethodHandlesLookup; 55 class MethodType; 56 template<class T> class ObjectArray; 57 class StackTraceElement; 58 template <typename T> struct NativeDexCachePair; 59 using MethodDexCachePair = NativeDexCachePair<ArtMethod>; 60 using MethodDexCacheType = std::atomic<MethodDexCachePair>; 61} // namespace mirror 62 63class ClassHierarchyAnalysis; 64class ClassTable; 65template<class T> class Handle; 66class ImtConflictTable; 67template<typename T> class LengthPrefixedArray; 68template<class T> class MutableHandle; 69class InternTable; 70class LinearAlloc; 71class OatFile; 72template<class T> class ObjectLock; 73class Runtime; 74class ScopedObjectAccessAlreadyRunnable; 75template<size_t kNumReferences> class PACKED(4) StackHandleScope; 76 77enum VisitRootFlags : uint8_t; 78 79class ClassVisitor { 80 public: 81 virtual ~ClassVisitor() {} 82 // Return true to continue visiting. 83 virtual bool operator()(ObjPtr<mirror::Class> klass) = 0; 84}; 85 86class ClassLoaderVisitor { 87 public: 88 virtual ~ClassLoaderVisitor() {} 89 virtual void Visit(ObjPtr<mirror::ClassLoader> class_loader) 90 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) = 0; 91}; 92 93class ClassLinker { 94 public: 95 // Well known mirror::Class roots accessed via GetClassRoot. 96 enum ClassRoot { 97 kJavaLangClass, 98 kJavaLangObject, 99 kClassArrayClass, 100 kObjectArrayClass, 101 kJavaLangString, 102 kJavaLangDexCache, 103 kJavaLangRefReference, 104 kJavaLangReflectConstructor, 105 kJavaLangReflectField, 106 kJavaLangReflectMethod, 107 kJavaLangReflectProxy, 108 kJavaLangStringArrayClass, 109 kJavaLangReflectConstructorArrayClass, 110 kJavaLangReflectFieldArrayClass, 111 kJavaLangReflectMethodArrayClass, 112 kJavaLangInvokeCallSite, 113 kJavaLangInvokeMethodHandleImpl, 114 kJavaLangInvokeMethodHandlesLookup, 115 kJavaLangInvokeMethodType, 116 kJavaLangClassLoader, 117 kJavaLangThrowable, 118 kJavaLangClassNotFoundException, 119 kJavaLangStackTraceElement, 120 kDalvikSystemEmulatedStackFrame, 121 kPrimitiveBoolean, 122 kPrimitiveByte, 123 kPrimitiveChar, 124 kPrimitiveDouble, 125 kPrimitiveFloat, 126 kPrimitiveInt, 127 kPrimitiveLong, 128 kPrimitiveShort, 129 kPrimitiveVoid, 130 kBooleanArrayClass, 131 kByteArrayClass, 132 kCharArrayClass, 133 kDoubleArrayClass, 134 kFloatArrayClass, 135 kIntArrayClass, 136 kLongArrayClass, 137 kShortArrayClass, 138 kJavaLangStackTraceElementArrayClass, 139 kDalvikSystemClassExt, 140 kClassRootsMax, 141 }; 142 143 explicit ClassLinker(InternTable* intern_table); 144 virtual ~ClassLinker(); 145 146 // Initialize class linker by bootstraping from dex files. 147 bool InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path, 148 std::string* error_msg) 149 REQUIRES_SHARED(Locks::mutator_lock_) 150 REQUIRES(!Locks::dex_lock_); 151 152 // Initialize class linker from one or more boot images. 153 bool InitFromBootImage(std::string* error_msg) 154 REQUIRES_SHARED(Locks::mutator_lock_) 155 REQUIRES(!Locks::dex_lock_); 156 157 // Add an image space to the class linker, may fix up classloader fields and dex cache fields. 158 // The dex files that were newly opened for the space are placed in the out argument 159 // out_dex_files. Returns true if the operation succeeded. 160 // The space must be already added to the heap before calling AddImageSpace since we need to 161 // properly handle read barriers and object marking. 162 bool AddImageSpace(gc::space::ImageSpace* space, 163 Handle<mirror::ClassLoader> class_loader, 164 jobjectArray dex_elements, 165 const char* dex_location, 166 std::vector<std::unique_ptr<const DexFile>>* out_dex_files, 167 std::string* error_msg) 168 REQUIRES(!Locks::dex_lock_) 169 REQUIRES_SHARED(Locks::mutator_lock_); 170 171 bool OpenImageDexFiles(gc::space::ImageSpace* space, 172 std::vector<std::unique_ptr<const DexFile>>* out_dex_files, 173 std::string* error_msg) 174 REQUIRES(!Locks::dex_lock_) 175 REQUIRES_SHARED(Locks::mutator_lock_); 176 177 // Finds a class by its descriptor, loading it if necessary. 178 // If class_loader is null, searches boot_class_path_. 179 mirror::Class* FindClass(Thread* self, 180 const char* descriptor, 181 Handle<mirror::ClassLoader> class_loader) 182 REQUIRES_SHARED(Locks::mutator_lock_) 183 REQUIRES(!Locks::dex_lock_); 184 185 // Finds a class by its descriptor using the "system" class loader, ie by searching the 186 // boot_class_path_. 187 mirror::Class* FindSystemClass(Thread* self, const char* descriptor) 188 REQUIRES_SHARED(Locks::mutator_lock_) 189 REQUIRES(!Locks::dex_lock_) { 190 return FindClass(self, descriptor, ScopedNullHandle<mirror::ClassLoader>()); 191 } 192 193 // Finds the array class given for the element class. 194 mirror::Class* FindArrayClass(Thread* self, ObjPtr<mirror::Class>* element_class) 195 REQUIRES_SHARED(Locks::mutator_lock_) 196 REQUIRES(!Locks::dex_lock_); 197 198 // Returns true if the class linker is initialized. 199 bool IsInitialized() const { 200 return init_done_; 201 } 202 203 // Define a new a class based on a ClassDef from a DexFile 204 mirror::Class* DefineClass(Thread* self, 205 const char* descriptor, 206 size_t hash, 207 Handle<mirror::ClassLoader> class_loader, 208 const DexFile& dex_file, 209 const DexFile::ClassDef& dex_class_def) 210 REQUIRES_SHARED(Locks::mutator_lock_) 211 REQUIRES(!Locks::dex_lock_); 212 213 // Finds a class by its descriptor, returning null if it isn't wasn't loaded 214 // by the given 'class_loader'. 215 mirror::Class* LookupClass(Thread* self, 216 const char* descriptor, 217 ObjPtr<mirror::ClassLoader> class_loader) 218 REQUIRES(!Locks::classlinker_classes_lock_) 219 REQUIRES_SHARED(Locks::mutator_lock_); 220 221 // Finds all the classes with the given descriptor, regardless of ClassLoader. 222 void LookupClasses(const char* descriptor, std::vector<ObjPtr<mirror::Class>>& classes) 223 REQUIRES(!Locks::classlinker_classes_lock_) 224 REQUIRES_SHARED(Locks::mutator_lock_); 225 226 mirror::Class* FindPrimitiveClass(char type) REQUIRES_SHARED(Locks::mutator_lock_); 227 228 void DumpForSigQuit(std::ostream& os) REQUIRES(!Locks::classlinker_classes_lock_); 229 230 size_t NumLoadedClasses() 231 REQUIRES(!Locks::classlinker_classes_lock_) 232 REQUIRES_SHARED(Locks::mutator_lock_); 233 234 // Resolve a String with the given index from the DexFile, storing the 235 // result in the DexCache. 236 mirror::String* ResolveString(const DexFile& dex_file, 237 dex::StringIndex string_idx, 238 Handle<mirror::DexCache> dex_cache) 239 REQUIRES_SHARED(Locks::mutator_lock_); 240 241 // Find a String with the given index from the DexFile, storing the 242 // result in the DexCache if found. Return null if not found. 243 mirror::String* LookupString(const DexFile& dex_file, 244 dex::StringIndex string_idx, 245 ObjPtr<mirror::DexCache> dex_cache) 246 REQUIRES_SHARED(Locks::mutator_lock_); 247 248 // Resolve a Type with the given index from the DexFile, storing the 249 // result in the DexCache. The referrer is used to identify the 250 // target DexCache and ClassLoader to use for resolution. 251 mirror::Class* ResolveType(const DexFile& dex_file, 252 dex::TypeIndex type_idx, 253 ObjPtr<mirror::Class> referrer) 254 REQUIRES_SHARED(Locks::mutator_lock_) 255 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 256 257 // Resolve a Type with the given index from the DexFile, storing the 258 // result in the DexCache. The referrer is used to identify the 259 // target DexCache and ClassLoader to use for resolution. 260 mirror::Class* ResolveType(dex::TypeIndex type_idx, ArtMethod* referrer) 261 REQUIRES_SHARED(Locks::mutator_lock_) 262 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 263 264 // Look up a resolved type with the given ID from the DexFile. The ClassLoader is used to search 265 // for the type, since it may be referenced from but not contained within the given DexFile. 266 ObjPtr<mirror::Class> LookupResolvedType(const DexFile& dex_file, 267 dex::TypeIndex type_idx, 268 ObjPtr<mirror::DexCache> dex_cache, 269 ObjPtr<mirror::ClassLoader> class_loader) 270 REQUIRES_SHARED(Locks::mutator_lock_); 271 static ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_idx, 272 ObjPtr<mirror::DexCache> dex_cache, 273 ObjPtr<mirror::ClassLoader> class_loader) 274 REQUIRES_SHARED(Locks::mutator_lock_); 275 276 // Resolve a type with the given ID from the DexFile, storing the 277 // result in DexCache. The ClassLoader is used to search for the 278 // type, since it may be referenced from but not contained within 279 // the given DexFile. 280 mirror::Class* ResolveType(const DexFile& dex_file, 281 dex::TypeIndex type_idx, 282 Handle<mirror::DexCache> dex_cache, 283 Handle<mirror::ClassLoader> class_loader) 284 REQUIRES_SHARED(Locks::mutator_lock_) 285 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 286 287 // Determine whether a dex cache result should be trusted, or an IncompatibleClassChangeError 288 // check and IllegalAccessError check should be performed even after a hit. 289 enum class ResolveMode { // private. 290 kNoChecks, 291 kCheckICCEAndIAE 292 }; 293 294 // Look up a previously resolved method with the given index. 295 ArtMethod* LookupResolvedMethod(uint32_t method_idx, 296 ObjPtr<mirror::DexCache> dex_cache, 297 ObjPtr<mirror::ClassLoader> class_loader) 298 REQUIRES_SHARED(Locks::mutator_lock_); 299 300 // Resolve a method with a given ID from the DexFile, storing the 301 // result in DexCache. The ClassLinker and ClassLoader are used as 302 // in ResolveType. What is unique is the method type argument which 303 // is used to determine if this method is a direct, static, or 304 // virtual method. 305 template <ResolveMode kResolveMode> 306 ArtMethod* ResolveMethod(const DexFile& dex_file, 307 uint32_t method_idx, 308 Handle<mirror::DexCache> dex_cache, 309 Handle<mirror::ClassLoader> class_loader, 310 ArtMethod* referrer, 311 InvokeType type) 312 REQUIRES_SHARED(Locks::mutator_lock_) 313 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 314 315 template <InvokeType type, ResolveMode kResolveMode> 316 ArtMethod* GetResolvedMethod(uint32_t method_idx, ArtMethod* referrer) 317 REQUIRES_SHARED(Locks::mutator_lock_); 318 319 template <ResolveMode kResolveMode> 320 ArtMethod* ResolveMethod(Thread* self, uint32_t method_idx, ArtMethod* referrer, InvokeType type) 321 REQUIRES_SHARED(Locks::mutator_lock_) 322 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 323 ArtMethod* ResolveMethodWithoutInvokeType(const DexFile& dex_file, 324 uint32_t method_idx, 325 Handle<mirror::DexCache> dex_cache, 326 Handle<mirror::ClassLoader> class_loader) 327 REQUIRES_SHARED(Locks::mutator_lock_) 328 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 329 330 ArtField* LookupResolvedField(uint32_t field_idx, ArtMethod* referrer, bool is_static) 331 REQUIRES_SHARED(Locks::mutator_lock_); 332 ArtField* ResolveField(uint32_t field_idx, ArtMethod* referrer, bool is_static) 333 REQUIRES_SHARED(Locks::mutator_lock_) 334 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 335 336 // Resolve a field with a given ID from the DexFile, storing the 337 // result in DexCache. The ClassLinker and ClassLoader are used as 338 // in ResolveType. What is unique is the is_static argument which is 339 // used to determine if we are resolving a static or non-static 340 // field. 341 ArtField* ResolveField(const DexFile& dex_file, uint32_t field_idx, 342 Handle<mirror::DexCache> dex_cache, 343 Handle<mirror::ClassLoader> class_loader, bool is_static) 344 REQUIRES_SHARED(Locks::mutator_lock_) 345 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 346 347 // Resolve a field with a given ID from the DexFile, storing the 348 // result in DexCache. The ClassLinker and ClassLoader are used as 349 // in ResolveType. No is_static argument is provided so that Java 350 // field resolution semantics are followed. 351 ArtField* ResolveFieldJLS(const DexFile& dex_file, 352 uint32_t field_idx, 353 Handle<mirror::DexCache> dex_cache, 354 Handle<mirror::ClassLoader> class_loader) 355 REQUIRES_SHARED(Locks::mutator_lock_) 356 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 357 358 // Resolve a method type with a given ID from the DexFile, storing 359 // the result in the DexCache. 360 mirror::MethodType* ResolveMethodType(const DexFile& dex_file, 361 uint32_t proto_idx, 362 Handle<mirror::DexCache> dex_cache, 363 Handle<mirror::ClassLoader> class_loader) 364 REQUIRES_SHARED(Locks::mutator_lock_) 365 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 366 367 // Resolve a method handle with a given ID from the DexFile. The 368 // result is not cached in the DexCache as the instance will only be 369 // used once in most circumstances. 370 mirror::MethodHandle* ResolveMethodHandle(uint32_t method_handle_idx, ArtMethod* referrer) 371 REQUIRES_SHARED(Locks::mutator_lock_); 372 373 // Returns true on success, false if there's an exception pending. 374 // can_run_clinit=false allows the compiler to attempt to init a class, 375 // given the restriction that no <clinit> execution is possible. 376 bool EnsureInitialized(Thread* self, 377 Handle<mirror::Class> c, 378 bool can_init_fields, 379 bool can_init_parents) 380 REQUIRES_SHARED(Locks::mutator_lock_) 381 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 382 383 // Initializes classes that have instances in the image but that have 384 // <clinit> methods so they could not be initialized by the compiler. 385 void RunRootClinits() 386 REQUIRES_SHARED(Locks::mutator_lock_) 387 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 388 389 // Directly register an already existing dex cache. RegisterDexFile should be preferred since that 390 // reduplicates DexCaches when possible. The DexCache given to this function must already be fully 391 // initialized and not already registered. 392 void RegisterExistingDexCache(ObjPtr<mirror::DexCache> cache, 393 ObjPtr<mirror::ClassLoader> class_loader) 394 REQUIRES(!Locks::dex_lock_) 395 REQUIRES_SHARED(Locks::mutator_lock_); 396 ObjPtr<mirror::DexCache> RegisterDexFile(const DexFile& dex_file, 397 ObjPtr<mirror::ClassLoader> class_loader) 398 REQUIRES(!Locks::dex_lock_) 399 REQUIRES_SHARED(Locks::mutator_lock_); 400 401 const std::vector<const DexFile*>& GetBootClassPath() { 402 return boot_class_path_; 403 } 404 405 void VisitClasses(ClassVisitor* visitor) 406 REQUIRES(!Locks::classlinker_classes_lock_) 407 REQUIRES_SHARED(Locks::mutator_lock_); 408 409 // Less efficient variant of VisitClasses that copies the class_table_ into secondary storage 410 // so that it can visit individual classes without holding the doesn't hold the 411 // Locks::classlinker_classes_lock_. As the Locks::classlinker_classes_lock_ isn't held this code 412 // can race with insertion and deletion of classes while the visitor is being called. 413 void VisitClassesWithoutClassesLock(ClassVisitor* visitor) 414 REQUIRES_SHARED(Locks::mutator_lock_) 415 REQUIRES(!Locks::dex_lock_); 416 417 void VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) 418 REQUIRES(!Locks::classlinker_classes_lock_, !Locks::trace_lock_) 419 REQUIRES_SHARED(Locks::mutator_lock_); 420 void VisitRoots(RootVisitor* visitor, VisitRootFlags flags) 421 REQUIRES(!Locks::dex_lock_, !Locks::classlinker_classes_lock_, !Locks::trace_lock_) 422 REQUIRES_SHARED(Locks::mutator_lock_); 423 424 bool IsDexFileRegistered(Thread* self, const DexFile& dex_file) 425 REQUIRES(!Locks::dex_lock_) 426 REQUIRES_SHARED(Locks::mutator_lock_); 427 ObjPtr<mirror::DexCache> FindDexCache(Thread* self, const DexFile& dex_file) 428 REQUIRES(!Locks::dex_lock_) 429 REQUIRES_SHARED(Locks::mutator_lock_); 430 ClassTable* FindClassTable(Thread* self, ObjPtr<mirror::DexCache> dex_cache) 431 REQUIRES(!Locks::dex_lock_) 432 REQUIRES_SHARED(Locks::mutator_lock_); 433 434 LengthPrefixedArray<ArtField>* AllocArtFieldArray(Thread* self, 435 LinearAlloc* allocator, 436 size_t length); 437 438 LengthPrefixedArray<ArtMethod>* AllocArtMethodArray(Thread* self, 439 LinearAlloc* allocator, 440 size_t length); 441 442 mirror::PointerArray* AllocPointerArray(Thread* self, size_t length) 443 REQUIRES_SHARED(Locks::mutator_lock_) 444 REQUIRES(!Roles::uninterruptible_); 445 446 mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount) 447 REQUIRES_SHARED(Locks::mutator_lock_) 448 REQUIRES(!Roles::uninterruptible_); 449 450 mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self, 451 size_t length) 452 REQUIRES_SHARED(Locks::mutator_lock_) 453 REQUIRES(!Roles::uninterruptible_); 454 455 verifier::FailureKind VerifyClass( 456 Thread* self, 457 Handle<mirror::Class> klass, 458 verifier::HardFailLogMode log_level = verifier::HardFailLogMode::kLogNone) 459 REQUIRES_SHARED(Locks::mutator_lock_) 460 REQUIRES(!Locks::dex_lock_); 461 bool VerifyClassUsingOatFile(const DexFile& dex_file, 462 ObjPtr<mirror::Class> klass, 463 mirror::Class::Status& oat_file_class_status) 464 REQUIRES_SHARED(Locks::mutator_lock_) 465 REQUIRES(!Locks::dex_lock_); 466 void ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass) 467 REQUIRES_SHARED(Locks::mutator_lock_) 468 REQUIRES(!Locks::dex_lock_); 469 void ResolveMethodExceptionHandlerTypes(ArtMethod* klass) 470 REQUIRES_SHARED(Locks::mutator_lock_) 471 REQUIRES(!Locks::dex_lock_); 472 473 mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, 474 jstring name, 475 jobjectArray interfaces, 476 jobject loader, 477 jobjectArray methods, 478 jobjectArray throws) 479 REQUIRES_SHARED(Locks::mutator_lock_); 480 std::string GetDescriptorForProxy(ObjPtr<mirror::Class> proxy_class) 481 REQUIRES_SHARED(Locks::mutator_lock_); 482 483 // Get the oat code for a method when its class isn't yet initialized. 484 const void* GetQuickOatCodeFor(ArtMethod* method) 485 REQUIRES_SHARED(Locks::mutator_lock_); 486 487 pid_t GetClassesLockOwner(); // For SignalCatcher. 488 pid_t GetDexLockOwner(); // For SignalCatcher. 489 490 mirror::Class* GetClassRoot(ClassRoot class_root) REQUIRES_SHARED(Locks::mutator_lock_); 491 492 static const char* GetClassRootDescriptor(ClassRoot class_root); 493 494 // Is the given entry point quick code to run the resolution stub? 495 bool IsQuickResolutionStub(const void* entry_point) const; 496 497 // Is the given entry point quick code to bridge into the interpreter? 498 bool IsQuickToInterpreterBridge(const void* entry_point) const; 499 500 // Is the given entry point quick code to run the generic JNI stub? 501 bool IsQuickGenericJniStub(const void* entry_point) const; 502 503 // Is the given entry point the JNI dlsym lookup stub? 504 bool IsJniDlsymLookupStub(const void* entry_point) const; 505 506 const void* GetQuickToInterpreterBridgeTrampoline() const { 507 return quick_to_interpreter_bridge_trampoline_; 508 } 509 510 InternTable* GetInternTable() const { 511 return intern_table_; 512 } 513 514 // Set the entrypoints up for method to the enter the interpreter. 515 void SetEntryPointsToInterpreter(ArtMethod* method) const 516 REQUIRES_SHARED(Locks::mutator_lock_); 517 518 // Set the entrypoints up for an obsolete method. 519 void SetEntryPointsForObsoleteMethod(ArtMethod* method) const 520 REQUIRES_SHARED(Locks::mutator_lock_); 521 522 // Attempts to insert a class into a class table. Returns null if 523 // the class was inserted, otherwise returns an existing class with 524 // the same descriptor and ClassLoader. 525 mirror::Class* InsertClass(const char* descriptor, ObjPtr<mirror::Class> klass, size_t hash) 526 REQUIRES(!Locks::classlinker_classes_lock_) 527 REQUIRES_SHARED(Locks::mutator_lock_); 528 529 // Add an oat file with .bss GC roots to be visited again at the end of GC 530 // for collector types that need it. 531 void WriteBarrierForBootOatFileBssRoots(const OatFile* oat_file) 532 REQUIRES(!Locks::classlinker_classes_lock_) 533 REQUIRES_SHARED(Locks::mutator_lock_); 534 535 mirror::ObjectArray<mirror::Class>* GetClassRoots() REQUIRES_SHARED(Locks::mutator_lock_) { 536 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read(); 537 DCHECK(class_roots != nullptr); 538 return class_roots; 539 } 540 541 // Move the class table to the pre-zygote table to reduce memory usage. This works by ensuring 542 // that no more classes are ever added to the pre zygote table which makes it that the pages 543 // always remain shared dirty instead of private dirty. 544 void MoveClassTableToPreZygote() 545 REQUIRES(!Locks::classlinker_classes_lock_) 546 REQUIRES_SHARED(Locks::mutator_lock_); 547 548 // Creates a GlobalRef PathClassLoader or DelegateLastClassLoader (specified by loader_class) 549 // that can be used to load classes from the given dex files. The parent of the class loader 550 // will be set to `parent_loader`. If `parent_loader` is null the parent will be 551 // the boot class loader. 552 // If class_loader points to a different class than PathClassLoader or DelegateLastClassLoader 553 // this method will abort. 554 // Note: the objects are not completely set up. Do not use this outside of tests and the compiler. 555 jobject CreateWellKnownClassLoader(Thread* self, 556 const std::vector<const DexFile*>& dex_files, 557 jclass loader_class, 558 jobject parent_loader) 559 REQUIRES_SHARED(Locks::mutator_lock_) 560 REQUIRES(!Locks::dex_lock_); 561 562 // Calls CreateWellKnownClassLoader(self, 563 // dex_files, 564 // WellKnownClasses::dalvik_system_PathClassLoader, 565 // nullptr) 566 jobject CreatePathClassLoader(Thread* self, const std::vector<const DexFile*>& dex_files) 567 REQUIRES_SHARED(Locks::mutator_lock_) 568 REQUIRES(!Locks::dex_lock_); 569 570 PointerSize GetImagePointerSize() const { 571 return image_pointer_size_; 572 } 573 574 // Used by image writer for checking. 575 bool ClassInClassTable(ObjPtr<mirror::Class> klass) 576 REQUIRES(Locks::classlinker_classes_lock_) 577 REQUIRES_SHARED(Locks::mutator_lock_); 578 579 // Clear the ArrayClass cache. This is necessary when cleaning up for the image, as the cache 580 // entries are roots, but potentially not image classes. 581 void DropFindArrayClassCache() REQUIRES_SHARED(Locks::mutator_lock_); 582 583 // Clean up class loaders, this needs to happen after JNI weak globals are cleared. 584 void CleanupClassLoaders() 585 REQUIRES(!Locks::classlinker_classes_lock_) 586 REQUIRES_SHARED(Locks::mutator_lock_); 587 588 // Unlike GetOrCreateAllocatorForClassLoader, GetAllocatorForClassLoader asserts that the 589 // allocator for this class loader is already created. 590 LinearAlloc* GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) 591 REQUIRES_SHARED(Locks::mutator_lock_); 592 593 // Return the linear alloc for a class loader if it is already allocated, otherwise allocate and 594 // set it. TODO: Consider using a lock other than classlinker_classes_lock_. 595 LinearAlloc* GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) 596 REQUIRES(!Locks::classlinker_classes_lock_) 597 REQUIRES_SHARED(Locks::mutator_lock_); 598 599 // May be called with null class_loader due to legacy code. b/27954959 600 void InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file, 601 ObjPtr<mirror::ClassLoader> class_loader) 602 REQUIRES(!Locks::classlinker_classes_lock_) 603 REQUIRES_SHARED(Locks::mutator_lock_); 604 605 static bool ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) 606 REQUIRES_SHARED(Locks::mutator_lock_); 607 608 std::set<DexCacheResolvedClasses> GetResolvedClasses(bool ignore_boot_classes) 609 REQUIRES(!Locks::dex_lock_); 610 611 static bool IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa, 612 ObjPtr<mirror::ClassLoader> class_loader) 613 REQUIRES_SHARED(Locks::mutator_lock_); 614 615 ArtMethod* AddMethodToConflictTable(ObjPtr<mirror::Class> klass, 616 ArtMethod* conflict_method, 617 ArtMethod* interface_method, 618 ArtMethod* method, 619 bool force_new_conflict_method) 620 REQUIRES_SHARED(Locks::mutator_lock_); 621 622 // Create a conflict table with a specified capacity. 623 ImtConflictTable* CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc); 624 625 // Static version for when the class linker is not yet created. 626 static ImtConflictTable* CreateImtConflictTable(size_t count, 627 LinearAlloc* linear_alloc, 628 PointerSize pointer_size); 629 630 631 // Create the IMT and conflict tables for a class. 632 void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); 633 634 // Visit all of the class tables. This is used by dex2oat to allow pruning dex caches. 635 template <class Visitor> 636 void VisitClassTables(const Visitor& visitor) 637 REQUIRES(!Locks::classlinker_classes_lock_) 638 REQUIRES_SHARED(Locks::mutator_lock_); 639 640 // Throw the class initialization failure recorded when first trying to initialize the given 641 // class. 642 void ThrowEarlierClassFailure(ObjPtr<mirror::Class> c, bool wrap_in_no_class_def = false) 643 REQUIRES_SHARED(Locks::mutator_lock_) 644 REQUIRES(!Locks::dex_lock_); 645 646 // Get the actual holding class for a copied method. Pretty slow, don't call often. 647 mirror::Class* GetHoldingClassOfCopiedMethod(ArtMethod* method) 648 REQUIRES_SHARED(Locks::mutator_lock_); 649 650 // Returns null if not found. 651 // This returns a pointer to the class-table, without requiring any locking - including the 652 // boot class-table. It is the caller's responsibility to access this under lock, if required. 653 ClassTable* ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) 654 REQUIRES_SHARED(Locks::mutator_lock_) 655 NO_THREAD_SAFETY_ANALYSIS; 656 657 void AppendToBootClassPath(Thread* self, const DexFile& dex_file) 658 REQUIRES_SHARED(Locks::mutator_lock_) 659 REQUIRES(!Locks::dex_lock_); 660 661 // Visit all of the class loaders in the class linker. 662 void VisitClassLoaders(ClassLoaderVisitor* visitor) const 663 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_); 664 665 // Checks that a class and its superclass from another class loader have the same virtual methods. 666 bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass) 667 REQUIRES_SHARED(Locks::mutator_lock_); 668 669 ClassHierarchyAnalysis* GetClassHierarchyAnalysis() { 670 return cha_.get(); 671 } 672 673 struct DexCacheData { 674 // Construct an invalid data object. 675 DexCacheData() 676 : weak_root(nullptr), 677 dex_file(nullptr), 678 class_table(nullptr) { } 679 680 // Check if the data is valid. 681 bool IsValid() const { 682 return dex_file != nullptr; 683 } 684 685 // Weak root to the DexCache. Note: Do not decode this unnecessarily or else class unloading may 686 // not work properly. 687 jweak weak_root; 688 // The following field caches the DexCache's field here to avoid unnecessary jweak decode that 689 // triggers read barriers (and marks them alive unnecessarily and messes with class unloading.) 690 const DexFile* dex_file; 691 // Identify the associated class loader's class table. This is used to make sure that 692 // the Java call to native DexCache.setResolvedType() inserts the resolved type in that 693 // class table. It is also used to make sure we don't register the same dex cache with 694 // multiple class loaders. 695 ClassTable* class_table; 696 }; 697 698 protected: 699 virtual bool InitializeClass(Thread* self, 700 Handle<mirror::Class> klass, 701 bool can_run_clinit, 702 bool can_init_parents) 703 REQUIRES_SHARED(Locks::mutator_lock_) 704 REQUIRES(!Locks::dex_lock_); 705 706 virtual verifier::FailureKind PerformClassVerification(Thread* self, 707 Handle<mirror::Class> klass, 708 verifier::HardFailLogMode log_level, 709 std::string* error_msg) 710 REQUIRES_SHARED(Locks::mutator_lock_); 711 712 private: 713 class LinkInterfaceMethodsHelper; 714 715 struct ClassLoaderData { 716 jweak weak_root; // Weak root to enable class unloading. 717 ClassTable* class_table; 718 LinearAlloc* allocator; 719 }; 720 721 // Ensures that the supertype of 'klass' ('supertype') is verified. Returns false and throws 722 // appropriate exceptions if verification failed hard. Returns true for successful verification or 723 // soft-failures. 724 bool AttemptSupertypeVerification(Thread* self, 725 Handle<mirror::Class> klass, 726 Handle<mirror::Class> supertype) 727 REQUIRES(!Locks::dex_lock_) 728 REQUIRES_SHARED(Locks::mutator_lock_); 729 730 void DeleteClassLoader(Thread* self, const ClassLoaderData& data) 731 REQUIRES_SHARED(Locks::mutator_lock_); 732 733 void VisitClassesInternal(ClassVisitor* visitor) 734 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_); 735 736 // Returns the number of zygote and image classes. 737 size_t NumZygoteClasses() const 738 REQUIRES(Locks::classlinker_classes_lock_) 739 REQUIRES_SHARED(Locks::mutator_lock_); 740 741 // Returns the number of non zygote nor image classes. 742 size_t NumNonZygoteClasses() const 743 REQUIRES(Locks::classlinker_classes_lock_) 744 REQUIRES_SHARED(Locks::mutator_lock_); 745 746 void FinishInit(Thread* self) 747 REQUIRES_SHARED(Locks::mutator_lock_) 748 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 749 750 // For early bootstrapping by Init 751 mirror::Class* AllocClass(Thread* self, 752 ObjPtr<mirror::Class> java_lang_Class, 753 uint32_t class_size) 754 REQUIRES_SHARED(Locks::mutator_lock_) 755 REQUIRES(!Roles::uninterruptible_); 756 757 // Alloc* convenience functions to avoid needing to pass in mirror::Class* 758 // values that are known to the ClassLinker such as 759 // kObjectArrayClass and kJavaLangString etc. 760 mirror::Class* AllocClass(Thread* self, uint32_t class_size) 761 REQUIRES_SHARED(Locks::mutator_lock_) 762 REQUIRES(!Roles::uninterruptible_); 763 764 mirror::DexCache* AllocDexCache(ObjPtr<mirror::String>* out_location, 765 Thread* self, 766 const DexFile& dex_file) 767 REQUIRES_SHARED(Locks::mutator_lock_) 768 REQUIRES(!Roles::uninterruptible_); 769 770 // Used for tests and AppendToBootClassPath. 771 mirror::DexCache* AllocAndInitializeDexCache(Thread* self, 772 const DexFile& dex_file, 773 LinearAlloc* linear_alloc) 774 REQUIRES_SHARED(Locks::mutator_lock_) 775 REQUIRES(!Locks::dex_lock_) 776 REQUIRES(!Roles::uninterruptible_); 777 778 mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type) 779 REQUIRES_SHARED(Locks::mutator_lock_) 780 REQUIRES(!Roles::uninterruptible_); 781 mirror::Class* InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class, 782 Primitive::Type type) 783 REQUIRES_SHARED(Locks::mutator_lock_) 784 REQUIRES(!Roles::uninterruptible_); 785 786 mirror::Class* CreateArrayClass(Thread* self, 787 const char* descriptor, 788 size_t hash, 789 Handle<mirror::ClassLoader> class_loader) 790 REQUIRES_SHARED(Locks::mutator_lock_) 791 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); 792 793 void AppendToBootClassPath(const DexFile& dex_file, ObjPtr<mirror::DexCache> dex_cache) 794 REQUIRES_SHARED(Locks::mutator_lock_) 795 REQUIRES(!Locks::dex_lock_); 796 797 // Precomputes size needed for Class, in the case of a non-temporary class this size must be 798 // sufficient to hold all static fields. 799 uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file, 800 const DexFile::ClassDef& dex_class_def); 801 802 // Setup the classloader, class def index, type idx so that we can insert this class in the class 803 // table. 804 void SetupClass(const DexFile& dex_file, 805 const DexFile::ClassDef& dex_class_def, 806 Handle<mirror::Class> klass, 807 ObjPtr<mirror::ClassLoader> class_loader) 808 REQUIRES_SHARED(Locks::mutator_lock_); 809 810 void LoadClass(Thread* self, 811 const DexFile& dex_file, 812 const DexFile::ClassDef& dex_class_def, 813 Handle<mirror::Class> klass) 814 REQUIRES_SHARED(Locks::mutator_lock_); 815 void LoadClassMembers(Thread* self, 816 const DexFile& dex_file, 817 const uint8_t* class_data, 818 Handle<mirror::Class> klass) 819 REQUIRES_SHARED(Locks::mutator_lock_); 820 821 void LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtField* dst) 822 REQUIRES_SHARED(Locks::mutator_lock_); 823 824 void LoadMethod(const DexFile& dex_file, 825 const ClassDataItemIterator& it, 826 Handle<mirror::Class> klass, ArtMethod* dst) 827 REQUIRES_SHARED(Locks::mutator_lock_); 828 829 void FixupStaticTrampolines(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); 830 831 // Finds a class in a Path- or DexClassLoader, loading it if necessary without using JNI. Hash 832 // function is supposed to be ComputeModifiedUtf8Hash(descriptor). Returns true if the 833 // class-loader chain could be handled, false otherwise, i.e., a non-supported class-loader 834 // was encountered while walking the parent chain (currently only BootClassLoader and 835 // PathClassLoader are supported). 836 bool FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa, 837 Thread* self, 838 const char* descriptor, 839 size_t hash, 840 Handle<mirror::ClassLoader> class_loader, 841 ObjPtr<mirror::Class>* result) 842 REQUIRES_SHARED(Locks::mutator_lock_) 843 REQUIRES(!Locks::dex_lock_); 844 845 // Finds the class in the classpath of the given class loader. It only searches the class loader 846 // dex files and does not recurse into its parent. 847 // The method checks that the provided class loader is either a PathClassLoader or a 848 // DexClassLoader. 849 // If the class is found the method returns the resolved class. Otherwise it returns null. 850 ObjPtr<mirror::Class> FindClassInBaseDexClassLoaderClassPath( 851 ScopedObjectAccessAlreadyRunnable& soa, 852 const char* descriptor, 853 size_t hash, 854 Handle<mirror::ClassLoader> class_loader) 855 REQUIRES_SHARED(Locks::mutator_lock_) 856 REQUIRES(!Locks::dex_lock_); 857 858 // Finds the class in the boot class loader. 859 // If the class is found the method returns the resolved class. Otherwise it returns null. 860 ObjPtr<mirror::Class> FindClassInBootClassLoaderClassPath(Thread* self, 861 const char* descriptor, 862 size_t hash) 863 REQUIRES_SHARED(Locks::mutator_lock_) 864 REQUIRES(!Locks::dex_lock_); 865 866 // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded 867 // by the given 'class_loader'. Uses the provided hash for the descriptor. 868 mirror::Class* LookupClass(Thread* self, 869 const char* descriptor, 870 size_t hash, 871 ObjPtr<mirror::ClassLoader> class_loader) 872 REQUIRES(!Locks::classlinker_classes_lock_) 873 REQUIRES_SHARED(Locks::mutator_lock_); 874 875 // Find a field by its field index. 876 ArtField* LookupResolvedField(uint32_t field_idx, 877 ObjPtr<mirror::DexCache> dex_cache, 878 ObjPtr<mirror::ClassLoader> class_loader, 879 bool is_static) 880 REQUIRES_SHARED(Locks::mutator_lock_); 881 882 void RegisterDexFileLocked(const DexFile& dex_file, 883 ObjPtr<mirror::DexCache> dex_cache, 884 ObjPtr<mirror::ClassLoader> class_loader) 885 REQUIRES(Locks::dex_lock_) 886 REQUIRES_SHARED(Locks::mutator_lock_); 887 DexCacheData FindDexCacheDataLocked(const DexFile& dex_file) 888 REQUIRES(Locks::dex_lock_) 889 REQUIRES_SHARED(Locks::mutator_lock_); 890 static ObjPtr<mirror::DexCache> DecodeDexCache(Thread* self, const DexCacheData& data) 891 REQUIRES_SHARED(Locks::mutator_lock_); 892 // Called to ensure that the dex cache has been registered with the same class loader. 893 // If yes, returns the dex cache, otherwise throws InternalError and returns null. 894 ObjPtr<mirror::DexCache> EnsureSameClassLoader(Thread* self, 895 ObjPtr<mirror::DexCache> dex_cache, 896 const DexCacheData& data, 897 ObjPtr<mirror::ClassLoader> class_loader) 898 REQUIRES(!Locks::dex_lock_) 899 REQUIRES_SHARED(Locks::mutator_lock_); 900 901 bool InitializeDefaultInterfaceRecursive(Thread* self, 902 Handle<mirror::Class> klass, 903 bool can_run_clinit, 904 bool can_init_parents) 905 REQUIRES(!Locks::dex_lock_) 906 REQUIRES_SHARED(Locks::mutator_lock_); 907 bool WaitForInitializeClass(Handle<mirror::Class> klass, 908 Thread* self, 909 ObjectLock<mirror::Class>& lock); 910 911 bool IsSameDescriptorInDifferentClassContexts(Thread* self, 912 const char* descriptor, 913 Handle<mirror::ClassLoader> class_loader1, 914 Handle<mirror::ClassLoader> class_loader2) 915 REQUIRES_SHARED(Locks::mutator_lock_); 916 917 bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, 918 ArtMethod* method, 919 ObjPtr<mirror::Class> klass1, 920 ObjPtr<mirror::Class> klass2) 921 REQUIRES_SHARED(Locks::mutator_lock_); 922 923 bool LinkClass(Thread* self, 924 const char* descriptor, 925 Handle<mirror::Class> klass, 926 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 927 MutableHandle<mirror::Class>* h_new_class_out) 928 REQUIRES_SHARED(Locks::mutator_lock_) 929 REQUIRES(!Locks::classlinker_classes_lock_); 930 931 bool LinkSuperClass(Handle<mirror::Class> klass) 932 REQUIRES_SHARED(Locks::mutator_lock_); 933 934 bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) 935 REQUIRES_SHARED(Locks::mutator_lock_) 936 REQUIRES(!Locks::dex_lock_); 937 938 bool LinkMethods(Thread* self, 939 Handle<mirror::Class> klass, 940 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 941 bool* out_new_conflict, 942 ArtMethod** out_imt) 943 REQUIRES_SHARED(Locks::mutator_lock_); 944 945 mirror::MethodHandle* ResolveMethodHandleForField(Thread* self, 946 const DexFile::MethodHandleItem& method_handle, 947 ArtMethod* referrer) 948 REQUIRES_SHARED(Locks::mutator_lock_); 949 950 mirror::MethodHandle* ResolveMethodHandleForMethod(Thread* self, 951 const DexFile* const dex_file, 952 const DexFile::MethodHandleItem& method_handle, 953 ArtMethod* referrer) 954 REQUIRES_SHARED(Locks::mutator_lock_); 955 956 // A wrapper class representing the result of a method translation used for linking methods and 957 // updating superclass default methods. For each method in a classes vtable there are 4 states it 958 // could be in: 959 // 1) No translation is necessary. In this case there is no MethodTranslation object for it. This 960 // is the standard case and is true when the method is not overridable by a default method, 961 // the class defines a concrete implementation of the method, the default method implementation 962 // remains the same, or an abstract method stayed abstract. 963 // 2) The method must be translated to a different default method. We note this with 964 // CreateTranslatedMethod. 965 // 3) The method must be replaced with a conflict method. This happens when a superclass 966 // implements an interface with a default method and this class implements an unrelated 967 // interface that also defines that default method. We note this with CreateConflictingMethod. 968 // 4) The method must be replaced with an abstract miranda method. This happens when a superclass 969 // implements an interface with a default method and this class implements a subinterface of 970 // the superclass's interface which declares the default method abstract. We note this with 971 // CreateAbstractMethod. 972 // 973 // When a method translation is unnecessary (case #1), we don't put it into the 974 // default_translation maps. So an instance of MethodTranslation must be in one of #2-#4. 975 class MethodTranslation { 976 public: 977 // This slot must become a default conflict method. 978 static MethodTranslation CreateConflictingMethod() { 979 return MethodTranslation(Type::kConflict, /*translation*/nullptr); 980 } 981 982 // This slot must become an abstract method. 983 static MethodTranslation CreateAbstractMethod() { 984 return MethodTranslation(Type::kAbstract, /*translation*/nullptr); 985 } 986 987 // Use the given method as the current value for this vtable slot during translation. 988 static MethodTranslation CreateTranslatedMethod(ArtMethod* new_method) { 989 return MethodTranslation(Type::kTranslation, new_method); 990 } 991 992 // Returns true if this is a method that must become a conflict method. 993 bool IsInConflict() const { 994 return type_ == Type::kConflict; 995 } 996 997 // Returns true if this is a method that must become an abstract method. 998 bool IsAbstract() const { 999 return type_ == Type::kAbstract; 1000 } 1001 1002 // Returns true if this is a method that must become a different method. 1003 bool IsTranslation() const { 1004 return type_ == Type::kTranslation; 1005 } 1006 1007 // Get the translated version of this method. 1008 ArtMethod* GetTranslation() const { 1009 DCHECK(IsTranslation()); 1010 DCHECK(translation_ != nullptr); 1011 return translation_; 1012 } 1013 1014 private: 1015 enum class Type { 1016 kTranslation, 1017 kConflict, 1018 kAbstract, 1019 }; 1020 1021 MethodTranslation(Type type, ArtMethod* translation) 1022 : translation_(translation), type_(type) {} 1023 1024 ArtMethod* const translation_; 1025 const Type type_; 1026 }; 1027 1028 // Links the virtual methods for the given class and records any default methods that will need to 1029 // be updated later. 1030 // 1031 // Arguments: 1032 // * self - The current thread. 1033 // * klass - class, whose vtable will be filled in. 1034 // * default_translations - Vtable index to new method map. 1035 // Any vtable entries that need to be updated with new default methods 1036 // are stored into the default_translations map. The default_translations 1037 // map is keyed on the vtable index that needs to be updated. We use this 1038 // map because if we override a default method with another default 1039 // method we need to update the vtable to point to the new method. 1040 // Unfortunately since we copy the ArtMethod* we cannot just do a simple 1041 // scan, we therefore store the vtable index's that might need to be 1042 // updated with the method they will turn into. 1043 // TODO This whole default_translations thing is very dirty. There should be a better way. 1044 bool LinkVirtualMethods( 1045 Thread* self, 1046 Handle<mirror::Class> klass, 1047 /*out*/std::unordered_map<size_t, MethodTranslation>* default_translations) 1048 REQUIRES_SHARED(Locks::mutator_lock_); 1049 1050 // Sets up the interface lookup table (IFTable) in the correct order to allow searching for 1051 // default methods. 1052 bool SetupInterfaceLookupTable(Thread* self, 1053 Handle<mirror::Class> klass, 1054 Handle<mirror::ObjectArray<mirror::Class>> interfaces) 1055 REQUIRES_SHARED(Locks::mutator_lock_); 1056 1057 1058 enum class DefaultMethodSearchResult { 1059 kDefaultFound, 1060 kAbstractFound, 1061 kDefaultConflict 1062 }; 1063 1064 // Find the default method implementation for 'interface_method' in 'klass', if one exists. 1065 // 1066 // Arguments: 1067 // * self - The current thread. 1068 // * target_method - The method we are trying to find a default implementation for. 1069 // * klass - The class we are searching for a definition of target_method. 1070 // * out_default_method - The pointer we will store the found default method to on success. 1071 // 1072 // Return value: 1073 // * kDefaultFound - There were no conflicting method implementations found in the class while 1074 // searching for target_method. The default method implementation is stored into 1075 // out_default_method. 1076 // * kAbstractFound - There were no conflicting method implementations found in the class while 1077 // searching for target_method but no default implementation was found either. 1078 // out_default_method is set to null and the method should be considered not 1079 // implemented. 1080 // * kDefaultConflict - Conflicting method implementations were found when searching for 1081 // target_method. The value of *out_default_method is null. 1082 DefaultMethodSearchResult FindDefaultMethodImplementation( 1083 Thread* self, 1084 ArtMethod* target_method, 1085 Handle<mirror::Class> klass, 1086 /*out*/ArtMethod** out_default_method) const 1087 REQUIRES_SHARED(Locks::mutator_lock_); 1088 1089 // Sets the imt entries and fixes up the vtable for the given class by linking all the interface 1090 // methods. See LinkVirtualMethods for an explanation of what default_translations is. 1091 bool LinkInterfaceMethods( 1092 Thread* self, 1093 Handle<mirror::Class> klass, 1094 const std::unordered_map<size_t, MethodTranslation>& default_translations, 1095 bool* out_new_conflict, 1096 ArtMethod** out_imt) 1097 REQUIRES_SHARED(Locks::mutator_lock_); 1098 1099 bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) 1100 REQUIRES_SHARED(Locks::mutator_lock_); 1101 bool LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) 1102 REQUIRES_SHARED(Locks::mutator_lock_); 1103 bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size) 1104 REQUIRES_SHARED(Locks::mutator_lock_); 1105 void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) 1106 REQUIRES_SHARED(Locks::mutator_lock_); 1107 1108 void CheckProxyConstructor(ArtMethod* constructor) const 1109 REQUIRES_SHARED(Locks::mutator_lock_); 1110 void CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const 1111 REQUIRES_SHARED(Locks::mutator_lock_); 1112 1113 size_t GetDexCacheCount() REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) { 1114 return dex_caches_.size(); 1115 } 1116 const std::list<DexCacheData>& GetDexCachesData() 1117 REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) { 1118 return dex_caches_; 1119 } 1120 1121 void CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out) 1122 REQUIRES_SHARED(Locks::mutator_lock_); 1123 void CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, ArtMethod* out) 1124 REQUIRES_SHARED(Locks::mutator_lock_); 1125 1126 // Register a class loader and create its class table and allocator. Should not be called if 1127 // these are already created. 1128 void RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader) 1129 REQUIRES_SHARED(Locks::mutator_lock_) 1130 REQUIRES(Locks::classlinker_classes_lock_); 1131 1132 // Insert a new class table if not found. 1133 ClassTable* InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) 1134 REQUIRES_SHARED(Locks::mutator_lock_) 1135 REQUIRES(Locks::classlinker_classes_lock_); 1136 1137 // EnsureResolved is called to make sure that a class in the class_table_ has been resolved 1138 // before returning it to the caller. Its the responsibility of the thread that placed the class 1139 // in the table to make it resolved. The thread doing resolution must notify on the class' lock 1140 // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may 1141 // retire a class, the version of the class in the table is returned and this may differ from 1142 // the class passed in. 1143 mirror::Class* EnsureResolved(Thread* self, const char* descriptor, ObjPtr<mirror::Class> klass) 1144 WARN_UNUSED 1145 REQUIRES_SHARED(Locks::mutator_lock_) 1146 REQUIRES(!Locks::dex_lock_); 1147 1148 void FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class, 1149 ObjPtr<mirror::Class> new_class) 1150 REQUIRES_SHARED(Locks::mutator_lock_); 1151 1152 void SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass) 1153 REQUIRES_SHARED(Locks::mutator_lock_); 1154 1155 // Return the quick generic JNI stub for testing. 1156 const void* GetRuntimeQuickGenericJniStub() const; 1157 1158 bool CanWeInitializeClass(ObjPtr<mirror::Class> klass, 1159 bool can_init_statics, 1160 bool can_init_parents) 1161 REQUIRES_SHARED(Locks::mutator_lock_); 1162 1163 void UpdateClassMethods(ObjPtr<mirror::Class> klass, 1164 LengthPrefixedArray<ArtMethod>* new_methods) 1165 REQUIRES_SHARED(Locks::mutator_lock_) 1166 REQUIRES(!Locks::classlinker_classes_lock_); 1167 1168 // Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise. 1169 void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor) 1170 REQUIRES(!Locks::dex_lock_) 1171 REQUIRES_SHARED(Locks::mutator_lock_); 1172 1173 // Allocate method arrays for interfaces. 1174 bool AllocateIfTableMethodArrays(Thread* self, 1175 Handle<mirror::Class> klass, 1176 Handle<mirror::IfTable> iftable) 1177 REQUIRES_SHARED(Locks::mutator_lock_); 1178 1179 // Sets imt_ref appropriately for LinkInterfaceMethods. 1180 // If there is no method in the imt location of imt_ref it will store the given method there. 1181 // Otherwise it will set the conflict method which will figure out which method to use during 1182 // runtime. 1183 void SetIMTRef(ArtMethod* unimplemented_method, 1184 ArtMethod* imt_conflict_method, 1185 ArtMethod* current_method, 1186 /*out*/bool* new_conflict, 1187 /*out*/ArtMethod** imt_ref) REQUIRES_SHARED(Locks::mutator_lock_); 1188 1189 void FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table, 1190 ArtMethod* unimplemented_method, 1191 ArtMethod* imt_conflict_method, 1192 ObjPtr<mirror::Class> klass, 1193 bool create_conflict_tables, 1194 bool ignore_copied_methods, 1195 /*out*/bool* new_conflict, 1196 /*out*/ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_); 1197 1198 void FillImtFromSuperClass(Handle<mirror::Class> klass, 1199 ArtMethod* unimplemented_method, 1200 ArtMethod* imt_conflict_method, 1201 bool* new_conflict, 1202 ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_); 1203 1204 // Check invoke type against the referenced class. Throws IncompatibleClassChangeError 1205 // (if `kThrowOnError`) and returns true on mismatch (kInterface on a non-interface class, 1206 // kVirtual on interface, kDefault on interface for dex files not supporting default methods), 1207 // otherwise returns false. 1208 template <bool kThrowOnError, typename ClassGetter> 1209 static bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache, 1210 InvokeType type, 1211 ClassGetter class_getter) 1212 REQUIRES_SHARED(Locks::mutator_lock_); 1213 // Helper that feeds the above function with `ClassGetter` doing `LookupResolvedType()`. 1214 template <bool kThrow> 1215 bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache, 1216 InvokeType type, 1217 uint32_t method_idx, 1218 ObjPtr<mirror::ClassLoader> class_loader) 1219 REQUIRES_SHARED(Locks::mutator_lock_); 1220 1221 std::vector<const DexFile*> boot_class_path_; 1222 std::vector<std::unique_ptr<const DexFile>> boot_dex_files_; 1223 1224 // JNI weak globals and side data to allow dex caches to get unloaded. We lazily delete weak 1225 // globals when we register new dex files. 1226 std::list<DexCacheData> dex_caches_ GUARDED_BY(Locks::dex_lock_); 1227 1228 // This contains the class loaders which have class tables. It is populated by 1229 // InsertClassTableForClassLoader. 1230 std::list<ClassLoaderData> class_loaders_ 1231 GUARDED_BY(Locks::classlinker_classes_lock_); 1232 1233 // Boot class path table. Since the class loader for this is null. 1234 std::unique_ptr<ClassTable> boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_); 1235 1236 // New class roots, only used by CMS since the GC needs to mark these in the pause. 1237 std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); 1238 1239 // Boot image oat files with new .bss GC roots to be visited in the pause by CMS. 1240 std::vector<const OatFile*> new_bss_roots_boot_oat_files_ 1241 GUARDED_BY(Locks::classlinker_classes_lock_); 1242 1243 // Number of times we've searched dex caches for a class. After a certain number of misses we move 1244 // the classes into the class_table_ to avoid dex cache based searches. 1245 Atomic<uint32_t> failed_dex_cache_class_lookups_; 1246 1247 // Well known mirror::Class roots. 1248 GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_; 1249 1250 // The interface table used by all arrays. 1251 GcRoot<mirror::IfTable> array_iftable_; 1252 1253 // A cache of the last FindArrayClass results. The cache serves to avoid creating array class 1254 // descriptors for the sake of performing FindClass. 1255 static constexpr size_t kFindArrayCacheSize = 16; 1256 GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize]; 1257 size_t find_array_class_cache_next_victim_; 1258 1259 bool init_done_; 1260 bool log_new_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); 1261 1262 InternTable* intern_table_; 1263 1264 // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single 1265 // patch point within the image. TODO: make these proper relocations. 1266 const void* quick_resolution_trampoline_; 1267 const void* quick_imt_conflict_trampoline_; 1268 const void* quick_generic_jni_trampoline_; 1269 const void* quick_to_interpreter_bridge_trampoline_; 1270 1271 // Image pointer size. 1272 PointerSize image_pointer_size_; 1273 1274 std::unique_ptr<ClassHierarchyAnalysis> cha_; 1275 1276 class FindVirtualMethodHolderVisitor; 1277 1278 friend class AppImageClassLoadersAndDexCachesHelper; 1279 friend struct CompilationHelper; // For Compile in ImageTest. 1280 friend class ImageDumper; // for DexLock 1281 friend class ImageWriter; // for GetClassRoots 1282 friend class JniCompilerTest; // for GetRuntimeQuickGenericJniStub 1283 friend class JniInternalTest; // for GetRuntimeQuickGenericJniStub 1284 friend class OatWriter; // for boot image string/class table slot address lookup. 1285 friend class VMClassLoader; // for LookupClass and FindClassInBaseDexClassLoader. 1286 ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName); // for DexLock, and RegisterDexFileLocked 1287 ART_FRIEND_TEST(mirror::DexCacheMethodHandlesTest, Open); // for AllocDexCache 1288 ART_FRIEND_TEST(mirror::DexCacheTest, Open); // for AllocDexCache 1289 DISALLOW_COPY_AND_ASSIGN(ClassLinker); 1290}; 1291 1292class ClassLoadCallback { 1293 public: 1294 virtual ~ClassLoadCallback() {} 1295 1296 // If set we will replace initial_class_def & initial_dex_file with the final versions. The 1297 // callback author is responsible for ensuring these are allocated in such a way they can be 1298 // cleaned up if another transformation occurs. Note that both must be set or null/unchanged on 1299 // return. 1300 // Note: the class may be temporary, in which case a following ClassPrepare event will be a 1301 // different object. It is the listener's responsibility to handle this. 1302 // Note: This callback is rarely useful so a default implementation has been given that does 1303 // nothing. 1304 virtual void ClassPreDefine(const char* descriptor ATTRIBUTE_UNUSED, 1305 Handle<mirror::Class> klass ATTRIBUTE_UNUSED, 1306 Handle<mirror::ClassLoader> class_loader ATTRIBUTE_UNUSED, 1307 const DexFile& initial_dex_file ATTRIBUTE_UNUSED, 1308 const DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED, 1309 /*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED, 1310 /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED) 1311 REQUIRES_SHARED(Locks::mutator_lock_) {} 1312 1313 // A class has been loaded. 1314 // Note: the class may be temporary, in which case a following ClassPrepare event will be a 1315 // different object. It is the listener's responsibility to handle this. 1316 virtual void ClassLoad(Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0; 1317 1318 // A class has been prepared, i.e., resolved. As the ClassLoad event might have been for a 1319 // temporary class, provide both the former and the current class. 1320 virtual void ClassPrepare(Handle<mirror::Class> temp_klass, 1321 Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0; 1322}; 1323 1324} // namespace art 1325 1326#endif // ART_RUNTIME_CLASS_LINKER_H_ 1327