class_linker.h revision be0562fb14e6754ee932b8d9c97e2a6df3a91119
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 <string> 21#include <utility> 22#include <vector> 23 24#include "base/macros.h" 25#include "base/mutex.h" 26#include "dex_file.h" 27#include "gtest/gtest.h" 28#include "jni.h" 29#include "oat_file.h" 30#include "object_callbacks.h" 31#include "read_barrier.h" 32 33namespace art { 34 35namespace gc { 36namespace space { 37 class ImageSpace; 38} // namespace space 39} // namespace gc 40namespace mirror { 41 class ClassLoader; 42 class DexCache; 43 class DexCacheTest_Open_Test; 44 class IfTable; 45 template<class T> class ObjectArray; 46 class StackTraceElement; 47} // namespace mirror 48 49class InternTable; 50template<class T> class ObjectLock; 51class ScopedObjectAccessAlreadyRunnable; 52template<class T> class Handle; 53 54typedef bool (ClassVisitor)(mirror::Class* c, void* arg); 55 56enum VisitRootFlags : uint8_t; 57 58class ClassLinker { 59 public: 60 explicit ClassLinker(InternTable* intern_table); 61 ~ClassLinker(); 62 63 // Initialize class linker by bootstraping from dex files 64 void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) 65 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 66 67 // Initialize class linker from one or more images. 68 void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 69 70 bool IsInBootClassPath(const char* descriptor); 71 72 // Finds a class by its descriptor, loading it if necessary. 73 // If class_loader is null, searches boot_class_path_. 74 mirror::Class* FindClass(Thread* self, const char* descriptor, 75 Handle<mirror::ClassLoader> class_loader) 76 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 77 78 // Finds a class by its descriptor using the "system" class loader, ie by searching the 79 // boot_class_path_. 80 mirror::Class* FindSystemClass(Thread* self, const char* descriptor) 81 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 82 83 // Finds the array class given for the element class. 84 mirror::Class* FindArrayClass(Thread* self, mirror::Class** element_class) 85 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 86 87 // Reutrns true if the class linker is initialized. 88 bool IsInitialized() const; 89 90 // Define a new a class based on a ClassDef from a DexFile 91 mirror::Class* DefineClass(const char* descriptor, 92 Handle<mirror::ClassLoader> class_loader, 93 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def) 94 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 95 96 // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded 97 // by the given 'class_loader'. 98 mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader) 99 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 100 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 101 102 // Finds all the classes with the given descriptor, regardless of ClassLoader. 103 void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes) 104 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 105 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 106 107 mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 108 109 // General class unloading is not supported, this is used to prune 110 // unwanted classes during image writing. 111 bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) 112 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 113 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 114 115 void DumpAllClasses(int flags) 116 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 117 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 118 119 void DumpForSigQuit(std::ostream& os) 120 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 121 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 122 123 size_t NumLoadedClasses() 124 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 125 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 126 127 // Resolve a String with the given index from the DexFile, storing the 128 // result in the DexCache. The referrer is used to identify the 129 // target DexCache and ClassLoader to use for resolution. 130 mirror::String* ResolveString(uint32_t string_idx, mirror::ArtMethod* referrer) 131 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 132 133 // Resolve a String with the given index from the DexFile, storing the 134 // result in the DexCache. 135 mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx, 136 Handle<mirror::DexCache> dex_cache) 137 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 138 139 // Resolve a Type with the given index from the DexFile, storing the 140 // result in the DexCache. The referrer is used to identity the 141 // target DexCache and ClassLoader to use for resolution. 142 mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, mirror::Class* referrer) 143 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 144 145 // Resolve a Type with the given index from the DexFile, storing the 146 // result in the DexCache. The referrer is used to identify the 147 // target DexCache and ClassLoader to use for resolution. 148 mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtMethod* referrer) 149 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 150 151 mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtField* referrer) 152 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 153 154 // Resolve a type with the given ID from the DexFile, storing the 155 // result in DexCache. The ClassLoader is used to search for the 156 // type, since it may be referenced from but not contained within 157 // the given DexFile. 158 mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, 159 Handle<mirror::DexCache> dex_cache, 160 Handle<mirror::ClassLoader> class_loader) 161 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 162 163 // Resolve a method with a given ID from the DexFile, storing the 164 // result in DexCache. The ClassLinker and ClassLoader are used as 165 // in ResolveType. What is unique is the method type argument which 166 // is used to determine if this method is a direct, static, or 167 // virtual method. 168 mirror::ArtMethod* ResolveMethod(const DexFile& dex_file, 169 uint32_t method_idx, 170 Handle<mirror::DexCache> dex_cache, 171 Handle<mirror::ClassLoader> class_loader, 172 Handle<mirror::ArtMethod> referrer, 173 InvokeType type) 174 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 175 176 mirror::ArtMethod* GetResolvedMethod(uint32_t method_idx, mirror::ArtMethod* referrer, 177 InvokeType type) 178 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 179 mirror::ArtMethod* ResolveMethod(Thread* self, uint32_t method_idx, mirror::ArtMethod** referrer, 180 InvokeType type) 181 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 182 183 mirror::ArtField* GetResolvedField(uint32_t field_idx, mirror::Class* field_declaring_class) 184 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 185 mirror::ArtField* ResolveField(uint32_t field_idx, mirror::ArtMethod* referrer, 186 bool is_static) 187 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 188 189 // Resolve a field with a given ID from the DexFile, storing the 190 // result in DexCache. The ClassLinker and ClassLoader are used as 191 // in ResolveType. What is unique is the is_static argument which is 192 // used to determine if we are resolving a static or non-static 193 // field. 194 mirror::ArtField* ResolveField(const DexFile& dex_file, 195 uint32_t field_idx, 196 Handle<mirror::DexCache> dex_cache, 197 Handle<mirror::ClassLoader> class_loader, 198 bool is_static) 199 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 200 201 // Resolve a field with a given ID from the DexFile, storing the 202 // result in DexCache. The ClassLinker and ClassLoader are used as 203 // in ResolveType. No is_static argument is provided so that Java 204 // field resolution semantics are followed. 205 mirror::ArtField* ResolveFieldJLS(const DexFile& dex_file, uint32_t field_idx, 206 Handle<mirror::DexCache> dex_cache, 207 Handle<mirror::ClassLoader> class_loader) 208 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 209 210 // Get shorty from method index without resolution. Used to do handlerization. 211 const char* MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer, uint32_t* length) 212 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 213 214 // Returns true on success, false if there's an exception pending. 215 // can_run_clinit=false allows the compiler to attempt to init a class, 216 // given the restriction that no <clinit> execution is possible. 217 bool EnsureInitialized(Handle<mirror::Class> c, bool can_init_fields, bool can_init_parents) 218 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 219 220 // Initializes classes that have instances in the image but that have 221 // <clinit> methods so they could not be initialized by the compiler. 222 void RunRootClinits() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 223 224 void RegisterDexFile(const DexFile& dex_file) 225 LOCKS_EXCLUDED(dex_lock_) 226 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 227 void RegisterDexFile(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) 228 LOCKS_EXCLUDED(dex_lock_) 229 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 230 231 const OatFile* RegisterOatFile(const OatFile* oat_file) 232 LOCKS_EXCLUDED(dex_lock_); 233 234 const std::vector<const DexFile*>& GetBootClassPath() { 235 return boot_class_path_; 236 } 237 238 void VisitClasses(ClassVisitor* visitor, void* arg) 239 LOCKS_EXCLUDED(dex_lock_) 240 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 241 // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_ 242 // when calling the visitor. 243 void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) 244 LOCKS_EXCLUDED(dex_lock_) 245 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 246 247 void VisitClassRoots(RootCallback* callback, void* arg, VisitRootFlags flags) 248 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_); 249 void VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags) 250 LOCKS_EXCLUDED(dex_lock_); 251 252 mirror::DexCache* FindDexCache(const DexFile& dex_file) 253 LOCKS_EXCLUDED(dex_lock_) 254 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 255 bool IsDexFileRegistered(const DexFile& dex_file) 256 LOCKS_EXCLUDED(dex_lock_) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 257 void FixupDexCaches(mirror::ArtMethod* resolution_method) 258 LOCKS_EXCLUDED(dex_lock_) 259 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 260 261 // Generate an oat file from a dex file 262 bool GenerateOatFile(const char* dex_filename, 263 int oat_fd, 264 const char* oat_cache_filename, 265 std::string* error_msg) 266 LOCKS_EXCLUDED(Locks::mutator_lock_); 267 268 const OatFile* FindOatFileFromOatLocation(const std::string& location, 269 std::string* error_msg) 270 LOCKS_EXCLUDED(dex_lock_); 271 272 // Find or create the oat file holding dex_location. Then load all corresponding dex files 273 // (if multidex) into the given vector. 274 bool OpenDexFilesFromOat(const char* dex_location, const char* oat_location, 275 std::vector<std::string>* error_msgs, 276 std::vector<const DexFile*>* dex_files) 277 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 278 279 // Returns true if oat file contains the dex file with the given location and checksum. 280 static bool VerifyOatFileChecksums(const OatFile* oat_file, 281 const char* dex_location, 282 uint32_t dex_location_checksum, 283 InstructionSet instruction_set, 284 std::string* error_msg); 285 286 // TODO: replace this with multiple methods that allocate the correct managed type. 287 template <class T> 288 mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length) 289 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 290 291 mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length) 292 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 293 294 mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length) 295 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 296 297 mirror::ObjectArray<mirror::ArtMethod>* AllocArtMethodArray(Thread* self, size_t length) 298 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 299 300 mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount) 301 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 302 303 mirror::ObjectArray<mirror::ArtField>* AllocArtFieldArray(Thread* self, size_t length) 304 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 305 306 mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self, 307 size_t length) 308 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 309 310 void VerifyClass(Handle<mirror::Class> klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 311 bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass, 312 mirror::Class::Status& oat_file_class_status) 313 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 314 void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, 315 Handle<mirror::Class> klass) 316 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 317 void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::ArtMethod* klass) 318 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 319 320 mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name, 321 jobjectArray interfaces, jobject loader, jobjectArray methods, 322 jobjectArray throws) 323 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 324 std::string GetDescriptorForProxy(mirror::Class* proxy_class) 325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 326 mirror::ArtMethod* FindMethodForProxy(mirror::Class* proxy_class, 327 mirror::ArtMethod* proxy_method) 328 LOCKS_EXCLUDED(dex_lock_) 329 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 330 331 // Get the oat code for a method when its class isn't yet initialized 332 const void* GetQuickOatCodeFor(mirror::ArtMethod* method) 333 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 334 const void* GetPortableOatCodeFor(mirror::ArtMethod* method, bool* have_portable_code) 335 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 336 337 // Get the oat code for a method from a method index. 338 const void* GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx) 339 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 340 const void* GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx) 341 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 342 343 pid_t GetClassesLockOwner(); // For SignalCatcher. 344 pid_t GetDexLockOwner(); // For SignalCatcher. 345 346 const void* GetPortableResolutionTrampoline() const { 347 return portable_resolution_trampoline_; 348 } 349 350 const void* GetQuickGenericJniTrampoline() const { 351 return quick_generic_jni_trampoline_; 352 } 353 354 const void* GetQuickResolutionTrampoline() const { 355 return quick_resolution_trampoline_; 356 } 357 358 const void* GetPortableImtConflictTrampoline() const { 359 return portable_imt_conflict_trampoline_; 360 } 361 362 const void* GetQuickImtConflictTrampoline() const { 363 return quick_imt_conflict_trampoline_; 364 } 365 366 const void* GetQuickToInterpreterBridgeTrampoline() const { 367 return quick_to_interpreter_bridge_trampoline_; 368 } 369 370 InternTable* GetInternTable() const { 371 return intern_table_; 372 } 373 374 // Attempts to insert a class into a class table. Returns NULL if 375 // the class was inserted, otherwise returns an existing class with 376 // the same descriptor and ClassLoader. 377 mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash) 378 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 379 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 380 381 // Special code to allocate an art method, use this instead of class->AllocObject. 382 mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 383 384 mirror::ObjectArray<mirror::Class>* GetClassRoots() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 385 mirror::ObjectArray<mirror::Class>* class_roots = 386 ReadBarrier::BarrierForRoot<mirror::ObjectArray<mirror::Class>, kWithReadBarrier>( 387 &class_roots_); 388 DCHECK(class_roots != NULL); 389 return class_roots; 390 } 391 392 private: 393 const OatFile::OatMethod GetOatMethodFor(mirror::ArtMethod* method) 394 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 395 396 OatFile& GetImageOatFile(gc::space::ImageSpace* space) 397 LOCKS_EXCLUDED(dex_lock_) 398 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 399 400 void FinishInit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 401 402 // For early bootstrapping by Init 403 mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size) 404 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 405 406 // Alloc* convenience functions to avoid needing to pass in mirror::Class* 407 // values that are known to the ClassLinker such as 408 // kObjectArrayClass and kJavaLangString etc. 409 mirror::Class* AllocClass(Thread* self, uint32_t class_size) 410 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 411 mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file) 412 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 413 mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 414 415 mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type) 416 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 417 mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) 418 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 419 420 421 mirror::Class* CreateArrayClass(Thread* self, const char* descriptor, 422 Handle<mirror::ClassLoader> class_loader) 423 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 424 425 void AppendToBootClassPath(const DexFile& dex_file) 426 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 427 void AppendToBootClassPath(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) 428 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 429 430 void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, 431 mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map) 432 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 433 434 // Precomputes size needed for Class, in the case of a non-temporary class this size must be 435 // sufficient to hold all static fields. 436 uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file, 437 const DexFile::ClassDef& dex_class_def); 438 439 void LoadClass(const DexFile& dex_file, 440 const DexFile::ClassDef& dex_class_def, 441 Handle<mirror::Class> klass, 442 mirror::ClassLoader* class_loader) 443 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 444 void LoadClassMembers(const DexFile& dex_file, 445 const byte* class_data, 446 Handle<mirror::Class> klass, 447 mirror::ClassLoader* class_loader, 448 const OatFile::OatClass* oat_class) 449 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 450 451 void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, 452 Handle<mirror::Class> klass, Handle<mirror::ArtField> dst) 453 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 454 455 mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file, 456 const ClassDataItemIterator& dex_method, 457 Handle<mirror::Class> klass) 458 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 459 460 void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 461 462 // Finds the associated oat class for a dex_file and descriptor 463 OatFile::OatClass GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) 464 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 465 466 void RegisterDexFileLocked(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) 467 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_) 468 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 469 bool IsDexFileRegisteredLocked(const DexFile& dex_file) 470 SHARED_LOCKS_REQUIRED(dex_lock_, Locks::mutator_lock_); 471 472 bool InitializeClass(Handle<mirror::Class> klass, bool can_run_clinit, 473 bool can_init_parents) 474 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 475 bool WaitForInitializeClass(Handle<mirror::Class> klass, Thread* self, 476 ObjectLock<mirror::Class>& lock); 477 bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass) 478 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 479 480 bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor, 481 Handle<mirror::ClassLoader> class_loader1, 482 Handle<mirror::ClassLoader> class_loader2) 483 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 484 485 bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, mirror::ArtMethod* method, 486 mirror::Class* klass1, 487 mirror::Class* klass2) 488 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 489 490 bool LinkClass(Thread* self, const char* descriptor, Handle<mirror::Class> klass, 491 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 492 mirror::Class** new_class) 493 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 494 495 bool LinkSuperClass(Handle<mirror::Class> klass) 496 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 497 498 bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) 499 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 500 501 bool LinkMethods(Thread* self, Handle<mirror::Class> klass, 502 Handle<mirror::ObjectArray<mirror::Class>> interfaces) 503 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 504 505 bool LinkVirtualMethods(Thread* self, Handle<mirror::Class> klass) 506 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 507 508 bool LinkInterfaceMethods(Handle<mirror::Class> klass, 509 Handle<mirror::ObjectArray<mirror::Class>> interfaces) 510 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 511 512 bool LinkStaticFields(Handle<mirror::Class> klass, size_t* class_size) 513 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 514 bool LinkInstanceFields(Handle<mirror::Class> klass) 515 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 516 bool LinkFields(Handle<mirror::Class> klass, bool is_static, size_t* class_size) 517 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 518 void LinkCode(Handle<mirror::ArtMethod> method, const OatFile::OatClass* oat_class, 519 const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index) 520 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 521 522 void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) 523 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 524 void CreateReferenceStaticOffsets(Handle<mirror::Class> klass) 525 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 526 void CreateReferenceOffsets(Handle<mirror::Class> klass, bool is_static, 527 uint32_t reference_offsets) 528 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 529 530 // For use by ImageWriter to find DexCaches for its roots 531 ReaderWriterMutex* DexLock() 532 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCK_RETURNED(dex_lock_) { 533 return &dex_lock_; 534 } 535 size_t GetDexCacheCount() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_) { 536 return dex_caches_.size(); 537 } 538 mirror::DexCache* GetDexCache(size_t idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_); 539 540 const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file) 541 LOCKS_EXCLUDED(dex_lock_) 542 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 543 544 // Find an opened oat file that contains dex_location. If oat_location is not nullptr, the file 545 // must have that location, else any oat location is accepted. 546 const OatFile* FindOpenedOatFile(const char* oat_location, const char* dex_location, 547 const uint32_t* const dex_location_checksum) 548 LOCKS_EXCLUDED(dex_lock_); 549 const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location) 550 LOCKS_EXCLUDED(dex_lock_); 551 552 // Note: will not register the oat file. 553 const OatFile* FindOatFileInOatLocationForDexFile(const char* dex_location, 554 uint32_t dex_location_checksum, 555 const char* oat_location, 556 std::string* error_msg) 557 LOCKS_EXCLUDED(dex_lock_); 558 559 // Creates the oat file from the dex_location to the oat_location. Needs a file descriptor for 560 // the file to be written, which is assumed to be under a lock. 561 const OatFile* CreateOatFileForDexLocation(const char* dex_location, 562 int fd, const char* oat_location, 563 std::vector<std::string>* error_msgs) 564 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 565 566 // Finds an OatFile that contains a DexFile for the given a DexFile location. 567 // 568 // Note 1: this will not check open oat files, which are assumed to be stale when this is run. 569 // Note 2: Does not register the oat file. It is the caller's job to register if the file is to 570 // be kept. 571 const OatFile* FindOatFileContainingDexFileFromDexLocation(const char* location, 572 const uint32_t* const location_checksum, 573 InstructionSet isa, 574 std::vector<std::string>* error_msgs) 575 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 576 577 // Find a verify an oat file with the given dex file. Will return nullptr when the oat file 578 // was not found or the dex file could not be verified. 579 // Note: Does not register the oat file. 580 const OatFile* LoadOatFileAndVerifyDexFile(const std::string& oat_file_location, 581 const char* dex_location, 582 std::string* error_msg, 583 bool* open_failed) 584 LOCKS_EXCLUDED(dex_lock_); 585 586 mirror::ArtMethod* CreateProxyConstructor(Thread* self, Handle<mirror::Class> klass, 587 mirror::Class* proxy_class) 588 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 589 mirror::ArtMethod* CreateProxyMethod(Thread* self, Handle<mirror::Class> klass, 590 Handle<mirror::ArtMethod> prototype) 591 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 592 593 std::vector<const DexFile*> boot_class_path_; 594 595 mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 596 std::vector<size_t> new_dex_cache_roots_ GUARDED_BY(dex_lock_);; 597 std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_); 598 std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_); 599 600 601 // multimap from a string hash code of a class descriptor to 602 // mirror::Class* instances. Results should be compared for a matching 603 // Class::descriptor_ and Class::class_loader_. 604 typedef std::multimap<size_t, mirror::Class*> Table; 605 // This contains strong roots. To enable concurrent root scanning of 606 // the class table, be careful to use a read barrier when accessing this. 607 Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_); 608 std::vector<std::pair<size_t, mirror::Class*>> new_class_roots_; 609 610 // Do we need to search dex caches to find image classes? 611 bool dex_cache_image_class_lookup_required_; 612 // Number of times we've searched dex caches for a class. After a certain number of misses we move 613 // the classes into the class_table_ to avoid dex cache based searches. 614 AtomicInteger failed_dex_cache_class_lookups_; 615 616 mirror::Class* LookupClassFromTableLocked(const char* descriptor, 617 const mirror::ClassLoader* class_loader, 618 size_t hash) 619 SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_); 620 621 mirror::Class* UpdateClass(const char* descriptor, mirror::Class* klass, size_t hash) 622 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 623 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 624 625 void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 626 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 627 mirror::Class* LookupClassFromImage(const char* descriptor) 628 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 629 630 // EnsureResolved is called to make sure that a class in the class_table_ has been resolved 631 // before returning it to the caller. Its the responsibility of the thread that placed the class 632 // in the table to make it resolved. The thread doing resolution must notify on the class' lock 633 // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may 634 // retire a class, the version of the class in the table is returned and this may differ from 635 // the class passed in. 636 mirror::Class* EnsureResolved(Thread* self, const char* descriptor, mirror::Class* klass) 637 WARN_UNUSED SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 638 639 void FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class) 640 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 641 642 // indexes into class_roots_. 643 // needs to be kept in sync with class_roots_descriptors_. 644 enum ClassRoot { 645 kJavaLangClass, 646 kJavaLangObject, 647 kClassArrayClass, 648 kObjectArrayClass, 649 kJavaLangString, 650 kJavaLangDexCache, 651 kJavaLangRefReference, 652 kJavaLangReflectArtField, 653 kJavaLangReflectArtMethod, 654 kJavaLangReflectProxy, 655 kJavaLangStringArrayClass, 656 kJavaLangReflectArtFieldArrayClass, 657 kJavaLangReflectArtMethodArrayClass, 658 kJavaLangClassLoader, 659 kJavaLangThrowable, 660 kJavaLangClassNotFoundException, 661 kJavaLangStackTraceElement, 662 kPrimitiveBoolean, 663 kPrimitiveByte, 664 kPrimitiveChar, 665 kPrimitiveDouble, 666 kPrimitiveFloat, 667 kPrimitiveInt, 668 kPrimitiveLong, 669 kPrimitiveShort, 670 kPrimitiveVoid, 671 kBooleanArrayClass, 672 kByteArrayClass, 673 kCharArrayClass, 674 kDoubleArrayClass, 675 kFloatArrayClass, 676 kIntArrayClass, 677 kLongArrayClass, 678 kShortArrayClass, 679 kJavaLangStackTraceElementArrayClass, 680 kClassRootsMax, 681 }; 682 mirror::ObjectArray<mirror::Class>* class_roots_; 683 684 mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 685 686 void SetClassRoot(ClassRoot class_root, mirror::Class* klass) 687 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 688 689 static const char* class_roots_descriptors_[]; 690 691 const char* GetClassRootDescriptor(ClassRoot class_root) { 692 const char* descriptor = class_roots_descriptors_[class_root]; 693 CHECK(descriptor != NULL); 694 return descriptor; 695 } 696 697 // The interface table used by all arrays. 698 mirror::IfTable* array_iftable_; 699 700 // A cache of the last FindArrayClass results. The cache serves to avoid creating array class 701 // descriptors for the sake of performing FindClass. 702 static constexpr size_t kFindArrayCacheSize = 16; 703 mirror::Class* find_array_class_cache_[kFindArrayCacheSize]; 704 size_t find_array_class_cache_next_victim_; 705 706 bool init_done_; 707 bool log_new_dex_caches_roots_ GUARDED_BY(dex_lock_); 708 bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); 709 710 InternTable* intern_table_; 711 712 // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single 713 // patch point within the image. TODO: make these proper relocations. 714 const void* portable_resolution_trampoline_; 715 const void* quick_resolution_trampoline_; 716 const void* portable_imt_conflict_trampoline_; 717 const void* quick_imt_conflict_trampoline_; 718 const void* quick_generic_jni_trampoline_; 719 const void* quick_to_interpreter_bridge_trampoline_; 720 721 friend class ImageWriter; // for GetClassRoots 722 FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors); 723 FRIEND_TEST(mirror::DexCacheTest, Open); 724 FRIEND_TEST(ExceptionTest, FindExceptionHandler); 725 FRIEND_TEST(ObjectTest, AllocObjectArray); 726 DISALLOW_COPY_AND_ASSIGN(ClassLinker); 727}; 728 729} // namespace art 730 731#endif // ART_RUNTIME_CLASS_LINKER_H_ 732