class_linker.h revision a59dd80f9f48cb750d329d4d4af2d99d72b484d1
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 // Find or create the oat file holding dex_location. Then load all corresponding dex files 269 // (if multidex) into the given vector. 270 bool OpenDexFilesFromOat(const char* dex_location, const char* oat_location, 271 std::vector<std::string>* error_msgs, 272 std::vector<const DexFile*>* dex_files) 273 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 274 275 // Returns true if oat file contains the dex file with the given location and checksum. 276 static bool VerifyOatFileChecksums(const OatFile* oat_file, 277 const char* dex_location, 278 uint32_t dex_location_checksum, 279 InstructionSet instruction_set, 280 std::string* error_msg); 281 282 // TODO: replace this with multiple methods that allocate the correct managed type. 283 template <class T> 284 mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length) 285 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 286 287 mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length) 288 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 289 290 mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length) 291 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 292 293 mirror::ObjectArray<mirror::ArtMethod>* AllocArtMethodArray(Thread* self, size_t length) 294 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 295 296 mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount) 297 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 298 299 mirror::ObjectArray<mirror::ArtField>* AllocArtFieldArray(Thread* self, size_t length) 300 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 301 302 mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self, 303 size_t length) 304 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 305 306 void VerifyClass(Handle<mirror::Class> klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 307 bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass, 308 mirror::Class::Status& oat_file_class_status) 309 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 310 void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, 311 Handle<mirror::Class> klass) 312 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 313 void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::ArtMethod* klass) 314 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 315 316 mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name, 317 jobjectArray interfaces, jobject loader, jobjectArray methods, 318 jobjectArray throws) 319 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 320 std::string GetDescriptorForProxy(mirror::Class* proxy_class) 321 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 322 mirror::ArtMethod* FindMethodForProxy(mirror::Class* proxy_class, 323 mirror::ArtMethod* proxy_method) 324 LOCKS_EXCLUDED(dex_lock_) 325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 326 327 // Get the oat code for a method when its class isn't yet initialized 328 const void* GetQuickOatCodeFor(mirror::ArtMethod* method) 329 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 330 const void* GetPortableOatCodeFor(mirror::ArtMethod* method, bool* have_portable_code) 331 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 332 333 // Get the oat code for a method from a method index. 334 const void* GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx) 335 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 336 const void* GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx) 337 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 338 339 pid_t GetClassesLockOwner(); // For SignalCatcher. 340 pid_t GetDexLockOwner(); // For SignalCatcher. 341 342 const void* GetPortableResolutionTrampoline() const { 343 return portable_resolution_trampoline_; 344 } 345 346 const void* GetQuickGenericJniTrampoline() const { 347 return quick_generic_jni_trampoline_; 348 } 349 350 const void* GetQuickResolutionTrampoline() const { 351 return quick_resolution_trampoline_; 352 } 353 354 const void* GetPortableImtConflictTrampoline() const { 355 return portable_imt_conflict_trampoline_; 356 } 357 358 const void* GetQuickImtConflictTrampoline() const { 359 return quick_imt_conflict_trampoline_; 360 } 361 362 const void* GetQuickToInterpreterBridgeTrampoline() const { 363 return quick_to_interpreter_bridge_trampoline_; 364 } 365 366 InternTable* GetInternTable() const { 367 return intern_table_; 368 } 369 370 // Attempts to insert a class into a class table. Returns NULL if 371 // the class was inserted, otherwise returns an existing class with 372 // the same descriptor and ClassLoader. 373 mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash) 374 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 375 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 376 377 // Special code to allocate an art method, use this instead of class->AllocObject. 378 mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 379 380 mirror::ObjectArray<mirror::Class>* GetClassRoots() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 381 mirror::ObjectArray<mirror::Class>* class_roots = 382 ReadBarrier::BarrierForRoot<mirror::ObjectArray<mirror::Class>, kWithReadBarrier>( 383 &class_roots_); 384 DCHECK(class_roots != NULL); 385 return class_roots; 386 } 387 388 private: 389 const OatFile::OatMethod GetOatMethodFor(mirror::ArtMethod* method) 390 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 391 392 OatFile& GetImageOatFile(gc::space::ImageSpace* space) 393 LOCKS_EXCLUDED(dex_lock_) 394 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 395 396 void FinishInit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 397 398 // For early bootstrapping by Init 399 mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size) 400 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 401 402 // Alloc* convenience functions to avoid needing to pass in mirror::Class* 403 // values that are known to the ClassLinker such as 404 // kObjectArrayClass and kJavaLangString etc. 405 mirror::Class* AllocClass(Thread* self, uint32_t class_size) 406 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 407 mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file) 408 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 409 mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 410 411 mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type) 412 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 413 mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) 414 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 415 416 417 mirror::Class* CreateArrayClass(Thread* self, const char* descriptor, 418 Handle<mirror::ClassLoader> class_loader) 419 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 420 421 void AppendToBootClassPath(const DexFile& dex_file) 422 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 423 void AppendToBootClassPath(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) 424 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 425 426 void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, 427 mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map) 428 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 429 430 // Precomputes size needed for Class, in the case of a non-temporary class this size must be 431 // sufficient to hold all static fields. 432 uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file, 433 const DexFile::ClassDef& dex_class_def); 434 435 void LoadClass(const DexFile& dex_file, 436 const DexFile::ClassDef& dex_class_def, 437 Handle<mirror::Class> klass, 438 mirror::ClassLoader* class_loader) 439 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 440 void LoadClassMembers(const DexFile& dex_file, 441 const byte* class_data, 442 Handle<mirror::Class> klass, 443 mirror::ClassLoader* class_loader, 444 const OatFile::OatClass* oat_class) 445 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 446 447 void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, 448 Handle<mirror::Class> klass, Handle<mirror::ArtField> dst) 449 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 450 451 mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file, 452 const ClassDataItemIterator& dex_method, 453 Handle<mirror::Class> klass) 454 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 455 456 void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 457 458 // Finds the associated oat class for a dex_file and descriptor 459 OatFile::OatClass GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) 460 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 461 462 void RegisterDexFileLocked(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) 463 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_) 464 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 465 bool IsDexFileRegisteredLocked(const DexFile& dex_file) 466 SHARED_LOCKS_REQUIRED(dex_lock_, Locks::mutator_lock_); 467 468 bool InitializeClass(Handle<mirror::Class> klass, bool can_run_clinit, 469 bool can_init_parents) 470 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 471 bool WaitForInitializeClass(Handle<mirror::Class> klass, Thread* self, 472 ObjectLock<mirror::Class>& lock); 473 bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass) 474 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 475 476 bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor, 477 Handle<mirror::ClassLoader> class_loader1, 478 Handle<mirror::ClassLoader> class_loader2) 479 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 480 481 bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, mirror::ArtMethod* method, 482 mirror::Class* klass1, 483 mirror::Class* klass2) 484 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 485 486 bool LinkClass(Thread* self, const char* descriptor, Handle<mirror::Class> klass, 487 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 488 mirror::Class** new_class) 489 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 490 491 bool LinkSuperClass(Handle<mirror::Class> klass) 492 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 493 494 bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) 495 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 496 497 bool LinkMethods(Thread* self, Handle<mirror::Class> klass, 498 Handle<mirror::ObjectArray<mirror::Class>> interfaces) 499 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 500 501 bool LinkVirtualMethods(Thread* self, Handle<mirror::Class> klass) 502 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 503 504 bool LinkInterfaceMethods(Handle<mirror::Class> klass, 505 Handle<mirror::ObjectArray<mirror::Class>> interfaces) 506 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 507 508 bool LinkStaticFields(Handle<mirror::Class> klass, size_t* class_size) 509 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 510 bool LinkInstanceFields(Handle<mirror::Class> klass) 511 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 512 bool LinkFields(Handle<mirror::Class> klass, bool is_static, size_t* class_size) 513 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 514 void LinkCode(Handle<mirror::ArtMethod> method, const OatFile::OatClass* oat_class, 515 const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index) 516 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 517 518 void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) 519 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 520 void CreateReferenceStaticOffsets(Handle<mirror::Class> klass) 521 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 522 void CreateReferenceOffsets(Handle<mirror::Class> klass, bool is_static, 523 uint32_t reference_offsets) 524 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 525 526 // For use by ImageWriter to find DexCaches for its roots 527 ReaderWriterMutex* DexLock() 528 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCK_RETURNED(dex_lock_) { 529 return &dex_lock_; 530 } 531 size_t GetDexCacheCount() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_) { 532 return dex_caches_.size(); 533 } 534 mirror::DexCache* GetDexCache(size_t idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_); 535 536 const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file) 537 LOCKS_EXCLUDED(dex_lock_) 538 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 539 540 // Find an opened oat file that contains dex_location. If oat_location is not nullptr, the file 541 // must have that location, else any oat location is accepted. 542 const OatFile* FindOpenedOatFile(const char* oat_location, const char* dex_location, 543 const uint32_t* const dex_location_checksum) 544 LOCKS_EXCLUDED(dex_lock_); 545 546 // Will open the oat file directly without relocating, even if we could/should do relocation. 547 const OatFile* FindOatFileFromOatLocation(const std::string& oat_location, 548 std::string* error_msg) 549 LOCKS_EXCLUDED(dex_lock_); 550 551 const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location) 552 LOCKS_EXCLUDED(dex_lock_); 553 554 const OatFile* OpenOatFileFromDexLocation(const std::string& dex_location, 555 InstructionSet isa, 556 bool* already_opened, 557 bool* obsolete_file_cleanup_failed, 558 std::vector<std::string>* error_msg) 559 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 560 561 const OatFile* PatchAndRetrieveOat(const std::string& input, const std::string& output, 562 const std::string& image_location, InstructionSet isa, 563 std::string* error_msg) 564 LOCKS_EXCLUDED(Locks::mutator_lock_); 565 566 bool CheckOatFile(const OatFile* oat_file, InstructionSet isa, 567 bool* checksum_verified, std::string* error_msg); 568 int32_t GetRequiredDelta(const OatFile* oat_file, InstructionSet isa); 569 570 // Note: will not register the oat file. 571 const OatFile* FindOatFileInOatLocationForDexFile(const char* dex_location, 572 uint32_t dex_location_checksum, 573 const char* oat_location, 574 std::string* error_msg) 575 LOCKS_EXCLUDED(dex_lock_); 576 577 // Creates the oat file from the dex_location to the oat_location. Needs a file descriptor for 578 // the file to be written, which is assumed to be under a lock. 579 const OatFile* CreateOatFileForDexLocation(const char* dex_location, 580 int fd, const char* oat_location, 581 std::vector<std::string>* error_msgs) 582 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 583 584 // Finds an OatFile that contains a DexFile for the given a DexFile location. 585 // 586 // Note 1: this will not check open oat files, which are assumed to be stale when this is run. 587 // Note 2: Does not register the oat file. It is the caller's job to register if the file is to 588 // be kept. 589 const OatFile* FindOatFileContainingDexFileFromDexLocation(const char* location, 590 const uint32_t* const location_checksum, 591 InstructionSet isa, 592 std::vector<std::string>* error_msgs, 593 bool* obsolete_file_cleanup_failed) 594 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_); 595 596 // verify an oat file with the given dex file. Will return false when the dex file could not be 597 // verified. Will return true otherwise. 598 bool VerifyOatWithDexFile(const OatFile* oat_file, const char* dex_location, 599 std::string* error_msg); 600 601 mirror::ArtMethod* CreateProxyConstructor(Thread* self, Handle<mirror::Class> klass, 602 mirror::Class* proxy_class) 603 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 604 mirror::ArtMethod* CreateProxyMethod(Thread* self, Handle<mirror::Class> klass, 605 Handle<mirror::ArtMethod> prototype) 606 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 607 608 std::vector<const DexFile*> boot_class_path_; 609 610 mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 611 std::vector<size_t> new_dex_cache_roots_ GUARDED_BY(dex_lock_);; 612 std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_); 613 std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_); 614 615 616 // multimap from a string hash code of a class descriptor to 617 // mirror::Class* instances. Results should be compared for a matching 618 // Class::descriptor_ and Class::class_loader_. 619 typedef std::multimap<size_t, mirror::Class*> Table; 620 // This contains strong roots. To enable concurrent root scanning of 621 // the class table, be careful to use a read barrier when accessing this. 622 Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_); 623 std::vector<std::pair<size_t, mirror::Class*>> new_class_roots_; 624 625 // Do we need to search dex caches to find image classes? 626 bool dex_cache_image_class_lookup_required_; 627 // Number of times we've searched dex caches for a class. After a certain number of misses we move 628 // the classes into the class_table_ to avoid dex cache based searches. 629 AtomicInteger failed_dex_cache_class_lookups_; 630 631 mirror::Class* LookupClassFromTableLocked(const char* descriptor, 632 const mirror::ClassLoader* class_loader, 633 size_t hash) 634 SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_); 635 636 mirror::Class* UpdateClass(const char* descriptor, mirror::Class* klass, size_t hash) 637 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 638 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 639 640 void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_) 641 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 642 mirror::Class* LookupClassFromImage(const char* descriptor) 643 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 644 645 // EnsureResolved is called to make sure that a class in the class_table_ has been resolved 646 // before returning it to the caller. Its the responsibility of the thread that placed the class 647 // in the table to make it resolved. The thread doing resolution must notify on the class' lock 648 // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may 649 // retire a class, the version of the class in the table is returned and this may differ from 650 // the class passed in. 651 mirror::Class* EnsureResolved(Thread* self, const char* descriptor, mirror::Class* klass) 652 WARN_UNUSED SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 653 654 void FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class) 655 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 656 657 // indexes into class_roots_. 658 // needs to be kept in sync with class_roots_descriptors_. 659 enum ClassRoot { 660 kJavaLangClass, 661 kJavaLangObject, 662 kClassArrayClass, 663 kObjectArrayClass, 664 kJavaLangString, 665 kJavaLangDexCache, 666 kJavaLangRefReference, 667 kJavaLangReflectArtField, 668 kJavaLangReflectArtMethod, 669 kJavaLangReflectProxy, 670 kJavaLangStringArrayClass, 671 kJavaLangReflectArtFieldArrayClass, 672 kJavaLangReflectArtMethodArrayClass, 673 kJavaLangClassLoader, 674 kJavaLangThrowable, 675 kJavaLangClassNotFoundException, 676 kJavaLangStackTraceElement, 677 kPrimitiveBoolean, 678 kPrimitiveByte, 679 kPrimitiveChar, 680 kPrimitiveDouble, 681 kPrimitiveFloat, 682 kPrimitiveInt, 683 kPrimitiveLong, 684 kPrimitiveShort, 685 kPrimitiveVoid, 686 kBooleanArrayClass, 687 kByteArrayClass, 688 kCharArrayClass, 689 kDoubleArrayClass, 690 kFloatArrayClass, 691 kIntArrayClass, 692 kLongArrayClass, 693 kShortArrayClass, 694 kJavaLangStackTraceElementArrayClass, 695 kClassRootsMax, 696 }; 697 mirror::ObjectArray<mirror::Class>* class_roots_; 698 699 mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 700 701 void SetClassRoot(ClassRoot class_root, mirror::Class* klass) 702 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 703 704 static const char* class_roots_descriptors_[]; 705 706 const char* GetClassRootDescriptor(ClassRoot class_root) { 707 const char* descriptor = class_roots_descriptors_[class_root]; 708 CHECK(descriptor != NULL); 709 return descriptor; 710 } 711 712 // The interface table used by all arrays. 713 mirror::IfTable* array_iftable_; 714 715 // A cache of the last FindArrayClass results. The cache serves to avoid creating array class 716 // descriptors for the sake of performing FindClass. 717 static constexpr size_t kFindArrayCacheSize = 16; 718 mirror::Class* find_array_class_cache_[kFindArrayCacheSize]; 719 size_t find_array_class_cache_next_victim_; 720 721 bool init_done_; 722 bool log_new_dex_caches_roots_ GUARDED_BY(dex_lock_); 723 bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); 724 725 InternTable* intern_table_; 726 727 // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single 728 // patch point within the image. TODO: make these proper relocations. 729 const void* portable_resolution_trampoline_; 730 const void* quick_resolution_trampoline_; 731 const void* portable_imt_conflict_trampoline_; 732 const void* quick_imt_conflict_trampoline_; 733 const void* quick_generic_jni_trampoline_; 734 const void* quick_to_interpreter_bridge_trampoline_; 735 736 friend class ImageWriter; // for GetClassRoots 737 friend class ImageDumper; // for FindOpenedOatFileFromOatLocation 738 friend class ElfPatcher; // for FindOpenedOatFileForDexFile & FindOpenedOatFileFromOatLocation 739 FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors); 740 FRIEND_TEST(mirror::DexCacheTest, Open); 741 FRIEND_TEST(ExceptionTest, FindExceptionHandler); 742 FRIEND_TEST(ObjectTest, AllocObjectArray); 743 DISALLOW_COPY_AND_ASSIGN(ClassLinker); 744}; 745 746} // namespace art 747 748#endif // ART_RUNTIME_CLASS_LINKER_H_ 749