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