diff options
Diffstat (limited to 'runtime/class_linker.h')
| -rw-r--r-- | runtime/class_linker.h | 807 |
1 files changed, 441 insertions, 366 deletions
diff --git a/runtime/class_linker.h b/runtime/class_linker.h index 8aceffbdcc..7f652ecc94 100644 --- a/runtime/class_linker.h +++ b/runtime/class_linker.h @@ -24,17 +24,19 @@ #include <utility> #include <vector> -#include "base/allocator.h" -#include "base/hash_set.h" +#include "base/enums.h" #include "base/macros.h" #include "base/mutex.h" #include "class_table.h" #include "dex_cache_resolved_classes.h" #include "dex_file.h" +#include "dex_file_types.h" #include "gc_root.h" +#include "handle.h" #include "jni.h" -#include "oat_file.h" +#include "mirror/class.h" #include "object_callbacks.h" +#include "verifier/verifier_enums.h" namespace art { @@ -47,16 +49,22 @@ namespace mirror { class ClassLoader; class DexCache; class DexCachePointerArray; + class DexCacheMethodHandlesTest_Open_Test; class DexCacheTest_Open_Test; class IfTable; + class MethodHandle; + class MethodHandlesLookup; + class MethodType; template<class T> class ObjectArray; class StackTraceElement; } // namespace mirror -class ImtConflictTable; template<class T> class Handle; +class ImtConflictTable; +template<typename T> class LengthPrefixedArray; template<class T> class MutableHandle; class InternTable; +class OatFile; template<class T> class ObjectLock; class Runtime; class ScopedObjectAccessAlreadyRunnable; @@ -68,14 +76,14 @@ class ClassVisitor { public: virtual ~ClassVisitor() {} // Return true to continue visiting. - virtual bool operator()(mirror::Class* klass) = 0; + virtual bool operator()(ObjPtr<mirror::Class> klass) = 0; }; class ClassLoaderVisitor { public: virtual ~ClassLoaderVisitor() {} - virtual void Visit(mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_) = 0; + virtual void Visit(ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) = 0; }; class ClassLinker { @@ -97,10 +105,15 @@ class ClassLinker { kJavaLangReflectConstructorArrayClass, kJavaLangReflectFieldArrayClass, kJavaLangReflectMethodArrayClass, + kJavaLangInvokeCallSite, + kJavaLangInvokeMethodHandleImpl, + kJavaLangInvokeMethodHandlesLookup, + kJavaLangInvokeMethodType, kJavaLangClassLoader, kJavaLangThrowable, kJavaLangClassNotFoundException, kJavaLangStackTraceElement, + kDalvikSystemEmulatedStackFrame, kPrimitiveBoolean, kPrimitiveByte, kPrimitiveChar, @@ -119,6 +132,7 @@ class ClassLinker { kLongArrayClass, kShortArrayClass, kJavaLangStackTraceElementArrayClass, + kDalvikSystemClassExt, kClassRootsMax, }; @@ -128,13 +142,13 @@ class ClassLinker { // Initialize class linker by bootstraping from dex files. bool InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path, std::string* error_msg) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Initialize class linker from one or more boot images. bool InitFromBootImage(std::string* error_msg) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Add an image space to the class linker, may fix up classloader fields and dex cache fields. // The dex files that were newly opened for the space are placed in the out argument @@ -147,47 +161,35 @@ class ClassLinker { const char* dex_location, std::vector<std::unique_ptr<const DexFile>>* out_dex_files, std::string* error_msg) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); bool OpenImageDexFiles(gc::space::ImageSpace* space, std::vector<std::unique_ptr<const DexFile>>* out_dex_files, std::string* error_msg) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); // Finds a class by its descriptor, loading it if necessary. // If class_loader is null, searches boot_class_path_. mirror::Class* FindClass(Thread* self, const char* descriptor, Handle<mirror::ClassLoader> class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); - - // Finds a class in the path class loader, loading it if necessary without using JNI. Hash - // function is supposed to be ComputeModifiedUtf8Hash(descriptor). Returns true if the - // class-loader chain could be handled, false otherwise, i.e., a non-supported class-loader - // was encountered while walking the parent chain (currently only BootClassLoader and - // PathClassLoader are supported). - bool FindClassInPathClassLoader(ScopedObjectAccessAlreadyRunnable& soa, - Thread* self, - const char* descriptor, - size_t hash, - Handle<mirror::ClassLoader> class_loader, - mirror::Class** result) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Finds a class by its descriptor using the "system" class loader, ie by searching the // boot_class_path_. mirror::Class* FindSystemClass(Thread* self, const char* descriptor) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_) { + return FindClass(self, descriptor, ScopedNullHandle<mirror::ClassLoader>()); + } // Finds the array class given for the element class. - mirror::Class* FindArrayClass(Thread* self, mirror::Class** element_class) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + mirror::Class* FindArrayClass(Thread* self, ObjPtr<mirror::Class>* element_class) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Returns true if the class linker is initialized. bool IsInitialized() const { @@ -201,87 +203,84 @@ class ClassLinker { Handle<mirror::ClassLoader> class_loader, const DexFile& dex_file, const DexFile::ClassDef& dex_class_def) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Finds a class by its descriptor, returning null if it isn't wasn't loaded // by the given 'class_loader'. mirror::Class* LookupClass(Thread* self, const char* descriptor, - size_t hash, - mirror::ClassLoader* class_loader) + ObjPtr<mirror::ClassLoader> class_loader) REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) { + return LookupClass(self, descriptor, ComputeModifiedUtf8Hash(descriptor), class_loader); + } // Finds all the classes with the given descriptor, regardless of ClassLoader. - void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes) - REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - mirror::Class* FindPrimitiveClass(char type) SHARED_REQUIRES(Locks::mutator_lock_); - - // General class unloading is not supported, this is used to prune - // unwanted classes during image writing. - bool RemoveClass(const char* descriptor, mirror::ClassLoader* class_loader) + void LookupClasses(const char* descriptor, std::vector<ObjPtr<mirror::Class>>& classes) REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); - void DumpAllClasses(int flags) - REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + mirror::Class* FindPrimitiveClass(char type) REQUIRES_SHARED(Locks::mutator_lock_); void DumpForSigQuit(std::ostream& os) REQUIRES(!Locks::classlinker_classes_lock_); size_t NumLoadedClasses() REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Resolve a String with the given index from the DexFile, storing the - // result in the DexCache. The referrer is used to identify the - // target DexCache and ClassLoader to use for resolution. - mirror::String* ResolveString(uint32_t string_idx, ArtMethod* referrer) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Resolve a String with the given index from the DexFile, storing the // result in the DexCache. - mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx, + mirror::String* ResolveString(const DexFile& dex_file, + dex::StringIndex string_idx, Handle<mirror::DexCache> dex_cache) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Find a String with the given index from the DexFile, storing the // result in the DexCache if found. Return null if not found. - mirror::String* LookupString(const DexFile& dex_file, uint32_t string_idx, - Handle<mirror::DexCache> dex_cache) - SHARED_REQUIRES(Locks::mutator_lock_); + mirror::String* LookupString(const DexFile& dex_file, + dex::StringIndex string_idx, + ObjPtr<mirror::DexCache> dex_cache) + REQUIRES_SHARED(Locks::mutator_lock_); // Resolve a Type with the given index from the DexFile, storing the - // result in the DexCache. The referrer is used to identity the + // result in the DexCache. The referrer is used to identify the // target DexCache and ClassLoader to use for resolution. - mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, mirror::Class* referrer) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + mirror::Class* ResolveType(const DexFile& dex_file, + dex::TypeIndex type_idx, + ObjPtr<mirror::Class> referrer) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); // Resolve a Type with the given index from the DexFile, storing the // result in the DexCache. The referrer is used to identify the // target DexCache and ClassLoader to use for resolution. - mirror::Class* ResolveType(uint16_t type_idx, ArtMethod* referrer) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); - - mirror::Class* ResolveType(uint16_t type_idx, ArtField* referrer) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + mirror::Class* ResolveType(dex::TypeIndex type_idx, ArtMethod* referrer) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); + + // Look up a resolved type with the given ID from the DexFile. The ClassLoader is used to search + // for the type, since it may be referenced from but not contained within the given DexFile. + ObjPtr<mirror::Class> LookupResolvedType(const DexFile& dex_file, + dex::TypeIndex type_idx, + ObjPtr<mirror::DexCache> dex_cache, + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_); + static ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_idx, + ObjPtr<mirror::DexCache> dex_cache, + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_); // Resolve a type with the given ID from the DexFile, storing the // result in DexCache. The ClassLoader is used to search for the // type, since it may be referenced from but not contained within // the given DexFile. mirror::Class* ResolveType(const DexFile& dex_file, - uint16_t type_idx, + dex::TypeIndex type_idx, Handle<mirror::DexCache> dex_cache, Handle<mirror::ClassLoader> class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); // Determine whether a dex cache result should be trusted, or an IncompatibleClassChangeError // check should be performed even after a hit. @@ -302,11 +301,11 @@ class ClassLinker { Handle<mirror::ClassLoader> class_loader, ArtMethod* referrer, InvokeType type) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); ArtMethod* GetResolvedMethod(uint32_t method_idx, ArtMethod* referrer) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // This returns the class referred to by GetMethodId(method_idx).class_idx_. This might be // different then the declaring class of the resolved method due to copied @@ -314,26 +313,24 @@ class ClassLinker { mirror::Class* ResolveReferencedClassOfMethod(uint32_t method_idx, Handle<mirror::DexCache> dex_cache, Handle<mirror::ClassLoader> class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); template <ResolveMode kResolveMode> ArtMethod* ResolveMethod(Thread* self, uint32_t method_idx, ArtMethod* referrer, InvokeType type) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); ArtMethod* ResolveMethodWithoutInvokeType(const DexFile& dex_file, uint32_t method_idx, Handle<mirror::DexCache> dex_cache, Handle<mirror::ClassLoader> class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); - ArtField* GetResolvedField(uint32_t field_idx, mirror::Class* field_declaring_class) - SHARED_REQUIRES(Locks::mutator_lock_); - ArtField* GetResolvedField(uint32_t field_idx, mirror::DexCache* dex_cache) - SHARED_REQUIRES(Locks::mutator_lock_); + ArtField* LookupResolvedField(uint32_t field_idx, ArtMethod* referrer, bool is_static) + REQUIRES_SHARED(Locks::mutator_lock_); ArtField* ResolveField(uint32_t field_idx, ArtMethod* referrer, bool is_static) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); // Resolve a field with a given ID from the DexFile, storing the // result in DexCache. The ClassLinker and ClassLoader are used as @@ -343,8 +340,8 @@ class ClassLinker { ArtField* ResolveField(const DexFile& dex_file, uint32_t field_idx, Handle<mirror::DexCache> dex_cache, Handle<mirror::ClassLoader> class_loader, bool is_static) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); // Resolve a field with a given ID from the DexFile, storing the // result in DexCache. The ClassLinker and ClassLoader are used as @@ -354,12 +351,23 @@ class ClassLinker { uint32_t field_idx, Handle<mirror::DexCache> dex_cache, Handle<mirror::ClassLoader> class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); - - // Get shorty from method index without resolution. Used to do handlerization. - const char* MethodShorty(uint32_t method_idx, ArtMethod* referrer, uint32_t* length) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); + + // Resolve a method type with a given ID from the DexFile, storing + // the result in the DexCache. + mirror::MethodType* ResolveMethodType(const DexFile& dex_file, + uint32_t proto_idx, + Handle<mirror::DexCache> dex_cache, + Handle<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); + + // Resolve a method handle with a given ID from the DexFile. The + // result is not cached in the DexCache as the instance will only be + // used once in most circumstances. + mirror::MethodHandle* ResolveMethodHandle(uint32_t method_handle_idx, ArtMethod* referrer) + REQUIRES_SHARED(Locks::mutator_lock_); // Returns true on success, false if there's an exception pending. // can_run_clinit=false allows the compiler to attempt to init a class, @@ -368,22 +376,22 @@ class ClassLinker { Handle<mirror::Class> c, bool can_init_fields, bool can_init_parents) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); // Initializes classes that have instances in the image but that have // <clinit> methods so they could not be initialized by the compiler. void RunRootClinits() - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); - mirror::DexCache* RegisterDexFile(const DexFile& dex_file, - mirror::ClassLoader* class_loader) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - void RegisterDexFile(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + ObjPtr<mirror::DexCache> RegisterDexFile(const DexFile& dex_file, + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + void RegisterBootClassPathDexFile(const DexFile& dex_file, ObjPtr<mirror::DexCache> dex_cache) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); const std::vector<const DexFile*>& GetBootClassPath() { return boot_class_path_; @@ -391,50 +399,35 @@ class ClassLinker { void VisitClasses(ClassVisitor* visitor) REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Less efficient variant of VisitClasses that copies the class_table_ into secondary storage // so that it can visit individual classes without holding the doesn't hold the // Locks::classlinker_classes_lock_. As the Locks::classlinker_classes_lock_ isn't held this code // can race with insertion and deletion of classes while the visitor is being called. void VisitClassesWithoutClassesLock(ClassVisitor* visitor) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); void VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) - REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::classlinker_classes_lock_, !Locks::trace_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); void VisitRoots(RootVisitor* visitor, VisitRootFlags flags) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - mirror::DexCache* FindDexCache(Thread* self, - const DexFile& dex_file, - bool allow_failure = false) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_, !Locks::classlinker_classes_lock_, !Locks::trace_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + + bool IsDexFileRegistered(Thread* self, const DexFile& dex_file) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + ObjPtr<mirror::DexCache> FindDexCache(Thread* self, const DexFile& dex_file) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + ClassTable* FindClassTable(Thread* self, ObjPtr<mirror::DexCache> dex_cache) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); void FixupDexCaches(ArtMethod* resolution_method) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Allocate an instance of a java.lang.Object. - mirror::Object* AllocObject(Thread* self) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!Roles::uninterruptible_); - - // TODO: replace this with multiple methods that allocate the correct managed type. - template <class T> - mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!Roles::uninterruptible_); - - mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!Roles::uninterruptible_); - - mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!Roles::uninterruptible_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); LengthPrefixedArray<ArtField>* AllocArtFieldArray(Thread* self, LinearAlloc* allocator, @@ -445,34 +438,35 @@ class ClassLinker { size_t length); mirror::PointerArray* AllocPointerArray(Thread* self, size_t length) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self, size_t length) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); - void VerifyClass(Thread* self, - Handle<mirror::Class> klass, - LogSeverity log_level = LogSeverity::NONE) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + verifier::FailureKind VerifyClass( + Thread* self, + Handle<mirror::Class> klass, + verifier::HardFailLogMode log_level = verifier::HardFailLogMode::kLogNone) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); bool VerifyClassUsingOatFile(const DexFile& dex_file, - mirror::Class* klass, + ObjPtr<mirror::Class> klass, mirror::Class::Status& oat_file_class_status) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); void ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); void ResolveMethodExceptionHandlerTypes(ArtMethod* klass) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name, @@ -480,30 +474,22 @@ class ClassLinker { jobject loader, jobjectArray methods, jobjectArray throws) - SHARED_REQUIRES(Locks::mutator_lock_); - std::string GetDescriptorForProxy(mirror::Class* proxy_class) - SHARED_REQUIRES(Locks::mutator_lock_); - ArtMethod* FindMethodForProxy(mirror::Class* proxy_class, ArtMethod* proxy_method) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Get the oat code for a method when its class isn't yet initialized + REQUIRES_SHARED(Locks::mutator_lock_); + std::string GetDescriptorForProxy(ObjPtr<mirror::Class> proxy_class) + REQUIRES_SHARED(Locks::mutator_lock_); + template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> + ArtMethod* FindMethodForProxy(ObjPtr<mirror::Class> proxy_class, ArtMethod* proxy_method) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + + // Get the oat code for a method when its class isn't yet initialized. const void* GetQuickOatCodeFor(ArtMethod* method) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Get compiled code for a method, return null if no code - // exists. This is unlike Get..OatCodeFor which will return a bridge - // or interpreter entrypoint. - const void* GetOatMethodQuickCodeFor(ArtMethod* method) - SHARED_REQUIRES(Locks::mutator_lock_); - - const OatFile::OatMethod FindOatMethodFor(ArtMethod* method, bool* found) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); pid_t GetClassesLockOwner(); // For SignalCatcher. pid_t GetDexLockOwner(); // For SignalCatcher. - mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_REQUIRES(Locks::mutator_lock_); + mirror::Class* GetClassRoot(ClassRoot class_root) REQUIRES_SHARED(Locks::mutator_lock_); static const char* GetClassRootDescriptor(ClassRoot class_root); @@ -516,112 +502,114 @@ class ClassLinker { // Is the given entry point quick code to run the generic JNI stub? bool IsQuickGenericJniStub(const void* entry_point) const; + const void* GetQuickToInterpreterBridgeTrampoline() const { + return quick_to_interpreter_bridge_trampoline_; + } + InternTable* GetInternTable() const { return intern_table_; } // Set the entrypoints up for method to the given code. void SetEntryPointsToCompiledCode(ArtMethod* method, const void* method_code) const - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Set the entrypoints up for method to the enter the interpreter. void SetEntryPointsToInterpreter(ArtMethod* method) const - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); + + // Set the entrypoints up for an obsolete method. + void SetEntryPointsForObsoleteMethod(ArtMethod* method) const + REQUIRES_SHARED(Locks::mutator_lock_); // Attempts to insert a class into a class table. Returns null if // the class was inserted, otherwise returns an existing class with // the same descriptor and ClassLoader. - mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash) + mirror::Class* InsertClass(const char* descriptor, ObjPtr<mirror::Class> klass, size_t hash) REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); - mirror::ObjectArray<mirror::Class>* GetClassRoots() SHARED_REQUIRES(Locks::mutator_lock_) { + // Add an oat file with .bss GC roots to be visited again at the end of GC + // for collector types that need it. + void WriteBarrierForBootOatFileBssRoots(const OatFile* oat_file) + REQUIRES(!Locks::classlinker_classes_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + + mirror::ObjectArray<mirror::Class>* GetClassRoots() REQUIRES_SHARED(Locks::mutator_lock_) { mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read(); DCHECK(class_roots != nullptr); return class_roots; } - // Move all of the boot image classes into the class table for faster lookups. - void AddBootImageClassesToClassTable() - REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Add image classes to the class table. - void AddImageClassesToClassTable(std::vector<gc::space::ImageSpace*> image_spaces, - mirror::ClassLoader* class_loader) - REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - // Move the class table to the pre-zygote table to reduce memory usage. This works by ensuring // that no more classes are ever added to the pre zygote table which makes it that the pages // always remain shared dirty instead of private dirty. void MoveClassTableToPreZygote() REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Creates a GlobalRef PathClassLoader that can be used to load classes from the given dex files. // Note: the objects are not completely set up. Do not use this outside of tests and the compiler. jobject CreatePathClassLoader(Thread* self, const std::vector<const DexFile*>& dex_files) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); - size_t GetImagePointerSize() const { - DCHECK(ValidPointerSize(image_pointer_size_)) << image_pointer_size_; + PointerSize GetImagePointerSize() const { return image_pointer_size_; } // Used by image writer for checking. - bool ClassInClassTable(mirror::Class* klass) + bool ClassInClassTable(ObjPtr<mirror::Class> klass) REQUIRES(Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - - ArtMethod* CreateRuntimeMethod(LinearAlloc* linear_alloc); + REQUIRES_SHARED(Locks::mutator_lock_); // Clear the ArrayClass cache. This is necessary when cleaning up for the image, as the cache // entries are roots, but potentially not image classes. - void DropFindArrayClassCache() SHARED_REQUIRES(Locks::mutator_lock_); + void DropFindArrayClassCache() REQUIRES_SHARED(Locks::mutator_lock_); // Clean up class loaders, this needs to happen after JNI weak globals are cleared. void CleanupClassLoaders() REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Unlike GetOrCreateAllocatorForClassLoader, GetAllocatorForClassLoader asserts that the // allocator for this class loader is already created. - LinearAlloc* GetAllocatorForClassLoader(mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::mutator_lock_); + LinearAlloc* GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_); // Return the linear alloc for a class loader if it is already allocated, otherwise allocate and // set it. TODO: Consider using a lock other than classlinker_classes_lock_. - LinearAlloc* GetOrCreateAllocatorForClassLoader(mirror::ClassLoader* class_loader) + LinearAlloc* GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // May be called with null class_loader due to legacy code. b/27954959 - void InsertDexFileInToClassLoader(mirror::Object* dex_file, mirror::ClassLoader* class_loader) + void InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file, + ObjPtr<mirror::ClassLoader> class_loader) REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); static bool ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); std::set<DexCacheResolvedClasses> GetResolvedClasses(bool ignore_boot_classes) - REQUIRES(!dex_lock_); + REQUIRES(!Locks::dex_lock_); - std::unordered_set<std::string> GetClassDescriptorsForProfileKeys( + // Returns the class descriptors for loaded dex files. + std::unordered_set<std::string> GetClassDescriptorsForResolvedClasses( const std::set<DexCacheResolvedClasses>& classes) - REQUIRES(!dex_lock_); + REQUIRES(!Locks::dex_lock_); static bool IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa, - mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::mutator_lock_); + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_); - ArtMethod* AddMethodToConflictTable(mirror::Class* klass, + ArtMethod* AddMethodToConflictTable(ObjPtr<mirror::Class> klass, ArtMethod* conflict_method, ArtMethod* interface_method, ArtMethod* method, bool force_new_conflict_method) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Create a conflict table with a specified capacity. ImtConflictTable* CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc); @@ -629,29 +617,49 @@ class ClassLinker { // Static version for when the class linker is not yet created. static ImtConflictTable* CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc, - size_t pointer_size); + PointerSize pointer_size); // Create the IMT and conflict tables for a class. - void FillIMTAndConflictTables(mirror::Class* klass) SHARED_REQUIRES(Locks::mutator_lock_); + void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); // Clear class table strong roots (other than classes themselves). This is done by dex2oat to // allow pruning dex caches. void ClearClassTableStrongRoots() const REQUIRES(!Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Throw the class initialization failure recorded when first trying to initialize the given // class. - void ThrowEarlierClassFailure(mirror::Class* c, bool wrap_in_no_class_def = false) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + void ThrowEarlierClassFailure(ObjPtr<mirror::Class> c, bool wrap_in_no_class_def = false) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Get the actual holding class for a copied method. Pretty slow, don't call often. mirror::Class* GetHoldingClassOfCopiedMethod(ArtMethod* method) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); + + // Returns null if not found. + ClassTable* ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_); + + void AppendToBootClassPath(Thread* self, const DexFile& dex_file) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); struct DexCacheData { + // Construct an invalid data object. + DexCacheData() + : weak_root(nullptr), + dex_file(nullptr), + resolved_methods(nullptr), + class_table(nullptr) { } + + // Check if the data is valid. + bool IsValid() const { + return dex_file != nullptr; + } + // Weak root to the DexCache. Note: Do not decode this unnecessarily or else class unloading may // not work properly. jweak weak_root; @@ -659,10 +667,17 @@ class ClassLinker { // jweak decode that triggers read barriers (and mark them alive unnecessarily and mess with // class unloading.) const DexFile* dex_file; - GcRoot<mirror::Class>* resolved_types; + ArtMethod** resolved_methods; + // Identify the associated class loader's class table. This is used to make sure that + // the Java call to native DexCache.setResolvedType() inserts the resolved type in that + // class table. It is also used to make sure we don't register the same dex cache with + // multiple class loaders. + ClassTable* class_table; }; private: + class LinkInterfaceMethodsHelper; + struct ClassLoaderData { jweak weak_root; // Weak root to enable class unloading. ClassTable* class_table; @@ -675,69 +690,78 @@ class ClassLinker { bool AttemptSupertypeVerification(Thread* self, Handle<mirror::Class> klass, Handle<mirror::Class> supertype) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); static void DeleteClassLoader(Thread* self, const ClassLoaderData& data) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void VisitClassLoaders(ClassLoaderVisitor* visitor) const - SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_); + REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_); void VisitClassesInternal(ClassVisitor* visitor) - SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_); + REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_); // Returns the number of zygote and image classes. size_t NumZygoteClasses() const REQUIRES(Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Returns the number of non zygote nor image classes. size_t NumNonZygoteClasses() const REQUIRES(Locks::classlinker_classes_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void FinishInit(Thread* self) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); // For early bootstrapping by Init - mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size) - SHARED_REQUIRES(Locks::mutator_lock_) + mirror::Class* AllocClass(Thread* self, + ObjPtr<mirror::Class> java_lang_Class, + uint32_t class_size) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); // Alloc* convenience functions to avoid needing to pass in mirror::Class* // values that are known to the ClassLinker such as // kObjectArrayClass and kJavaLangString etc. mirror::Class* AllocClass(Thread* self, uint32_t class_size) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Roles::uninterruptible_); + + mirror::DexCache* AllocDexCache(ObjPtr<mirror::String>* out_location, + Thread* self, + const DexFile& dex_file) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); - mirror::DexCache* AllocDexCache(Thread* self, - const DexFile& dex_file, - LinearAlloc* linear_alloc) - SHARED_REQUIRES(Locks::mutator_lock_) + + // Used for tests and AppendToBootClassPath. + mirror::DexCache* AllocAndInitializeDexCache(Thread* self, + const DexFile& dex_file, + LinearAlloc* linear_alloc) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_) REQUIRES(!Roles::uninterruptible_); mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); - mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) - SHARED_REQUIRES(Locks::mutator_lock_) + mirror::Class* InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class, + Primitive::Type type) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); mirror::Class* CreateArrayClass(Thread* self, const char* descriptor, size_t hash, Handle<mirror::ClassLoader> class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_, !Roles::uninterruptible_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_); - void AppendToBootClassPath(Thread* self, const DexFile& dex_file) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); - void AppendToBootClassPath(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + void AppendToBootClassPath(const DexFile& dex_file, ObjPtr<mirror::DexCache> dex_cache) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); // Precomputes size needed for Class, in the case of a non-temporary class this size must be // sufficient to hold all static fields. @@ -749,100 +773,130 @@ class ClassLinker { void SetupClass(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, Handle<mirror::Class> klass, - mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::mutator_lock_); + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_); void LoadClass(Thread* self, const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, Handle<mirror::Class> klass) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void LoadClassMembers(Thread* self, const DexFile& dex_file, const uint8_t* class_data, - Handle<mirror::Class> klass, - const OatFile::OatClass* oat_class) - SHARED_REQUIRES(Locks::mutator_lock_); + Handle<mirror::Class> klass) + REQUIRES_SHARED(Locks::mutator_lock_); void LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtField* dst) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); - void LoadMethod(Thread* self, - const DexFile& dex_file, + void LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtMethod* dst) - SHARED_REQUIRES(Locks::mutator_lock_); - - void FixupStaticTrampolines(mirror::Class* klass) SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); - // Finds the associated oat class for a dex_file and descriptor. Returns an invalid OatClass on - // error and sets found to false. - OatFile::OatClass FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, bool* found) - SHARED_REQUIRES(Locks::mutator_lock_); + void FixupStaticTrampolines(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); - void RegisterDexFileLocked(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache) - REQUIRES(dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); - mirror::DexCache* FindDexCacheLocked(Thread* self, const DexFile& dex_file, bool allow_failure) - REQUIRES(dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + // Finds a class in a Path- or DexClassLoader, loading it if necessary without using JNI. Hash + // function is supposed to be ComputeModifiedUtf8Hash(descriptor). Returns true if the + // class-loader chain could be handled, false otherwise, i.e., a non-supported class-loader + // was encountered while walking the parent chain (currently only BootClassLoader and + // PathClassLoader are supported). + bool FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa, + Thread* self, + const char* descriptor, + size_t hash, + Handle<mirror::ClassLoader> class_loader, + ObjPtr<mirror::Class>* result) + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); + + // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded + // by the given 'class_loader'. Uses the provided hash for the descriptor. + mirror::Class* LookupClass(Thread* self, + const char* descriptor, + size_t hash, + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES(!Locks::classlinker_classes_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + + // Find a field by its field index. + ArtField* LookupResolvedField(uint32_t field_idx, + ObjPtr<mirror::DexCache> dex_cache, + ObjPtr<mirror::ClassLoader> class_loader, + bool is_static) + REQUIRES_SHARED(Locks::mutator_lock_); + + void RegisterDexFileLocked(const DexFile& dex_file, + ObjPtr<mirror::DexCache> dex_cache, + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES(Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + DexCacheData FindDexCacheDataLocked(const DexFile& dex_file) + REQUIRES(Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + static ObjPtr<mirror::DexCache> DecodeDexCache(Thread* self, const DexCacheData& data) + REQUIRES_SHARED(Locks::mutator_lock_); + // Called to ensure that the dex cache has been registered with the same class loader. + // If yes, returns the dex cache, otherwise throws InternalError and returns null. + ObjPtr<mirror::DexCache> EnsureSameClassLoader(Thread* self, + ObjPtr<mirror::DexCache> dex_cache, + const DexCacheData& data, + ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); bool InitializeClass(Thread* self, Handle<mirror::Class> klass, bool can_run_clinit, bool can_init_parents) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); bool InitializeDefaultInterfaceRecursive(Thread* self, Handle<mirror::Class> klass, bool can_run_clinit, bool can_init_parents) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); bool WaitForInitializeClass(Handle<mirror::Class> klass, Thread* self, ObjectLock<mirror::Class>& lock); bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor, Handle<mirror::ClassLoader> class_loader1, Handle<mirror::ClassLoader> class_loader2) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, ArtMethod* method, - mirror::Class* klass1, - mirror::Class* klass2) - SHARED_REQUIRES(Locks::mutator_lock_); + ObjPtr<mirror::Class> klass1, + ObjPtr<mirror::Class> klass2) + REQUIRES_SHARED(Locks::mutator_lock_); bool LinkClass(Thread* self, const char* descriptor, Handle<mirror::Class> klass, Handle<mirror::ObjectArray<mirror::Class>> interfaces, MutableHandle<mirror::Class>* h_new_class_out) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Locks::classlinker_classes_lock_); bool LinkSuperClass(Handle<mirror::Class> klass) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); bool LinkMethods(Thread* self, Handle<mirror::Class> klass, Handle<mirror::ObjectArray<mirror::Class>> interfaces, bool* out_new_conflict, ArtMethod** out_imt) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Does anything needed to make sure that the compiler will not generate a direct invoke to this - // method. Should only be called on non-invokable methods. - void EnsureThrowsInvocationError(ArtMethod* method) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // A wrapper class representing the result of a method translation used for linking methods and // updating superclass default methods. For each method in a classes vtable there are 4 states it @@ -936,14 +990,14 @@ class ClassLinker { Thread* self, Handle<mirror::Class> klass, /*out*/std::unordered_map<size_t, MethodTranslation>* default_translations) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Sets up the interface lookup table (IFTable) in the correct order to allow searching for // default methods. bool SetupInterfaceLookupTable(Thread* self, Handle<mirror::Class> klass, Handle<mirror::ObjectArray<mirror::Class>> interfaces) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); enum class DefaultMethodSearchResult { @@ -975,7 +1029,7 @@ class ClassLinker { ArtMethod* target_method, Handle<mirror::Class> klass, /*out*/ArtMethod** out_default_method) const - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Sets the imt entries and fixes up the vtable for the given class by linking all the interface // methods. See LinkVirtualMethods for an explanation of what default_translations is. @@ -985,67 +1039,44 @@ class ClassLinker { const std::unordered_map<size_t, MethodTranslation>& default_translations, bool* out_new_conflict, ArtMethod** out_imt) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); bool LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size) - SHARED_REQUIRES(Locks::mutator_lock_); - void LinkCode(ArtMethod* method, - const OatFile::OatClass* oat_class, - uint32_t class_def_method_index) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void CheckProxyConstructor(ArtMethod* constructor) const - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); - // For use by ImageWriter to find DexCaches for its roots - ReaderWriterMutex* DexLock() - SHARED_REQUIRES(Locks::mutator_lock_) - LOCK_RETURNED(dex_lock_) { - return &dex_lock_; - } - size_t GetDexCacheCount() SHARED_REQUIRES(Locks::mutator_lock_, dex_lock_) { + size_t GetDexCacheCount() REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) { return dex_caches_.size(); } const std::list<DexCacheData>& GetDexCachesData() - SHARED_REQUIRES(Locks::mutator_lock_, dex_lock_) { + REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) { return dex_caches_; } void CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); void CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, ArtMethod* out) - SHARED_REQUIRES(Locks::mutator_lock_); - - // Ensures that methods have the kAccSkipAccessChecks bit set. We use the - // kAccVerificationAttempted bit on the class access flags to determine whether this has been done - // before. - void EnsureSkipAccessChecksMethods(Handle<mirror::Class> c) - SHARED_REQUIRES(Locks::mutator_lock_); - - mirror::Class* LookupClassFromBootImage(const char* descriptor) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_); // Register a class loader and create its class table and allocator. Should not be called if // these are already created. - void RegisterClassLoader(mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) + void RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(Locks::classlinker_classes_lock_); - // Returns null if not found. - ClassTable* ClassTableForClassLoader(mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::mutator_lock_); - // Insert a new class table if not found. - ClassTable* InsertClassTableForClassLoader(mirror::ClassLoader* class_loader) - SHARED_REQUIRES(Locks::mutator_lock_) + ClassTable* InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(Locks::classlinker_classes_lock_); // EnsureResolved is called to make sure that a class in the class_table_ has been resolved @@ -1054,26 +1085,29 @@ class ClassLinker { // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may // retire a class, the version of the class in the table is returned and this may differ from // the class passed in. - mirror::Class* EnsureResolved(Thread* self, const char* descriptor, mirror::Class* klass) + mirror::Class* EnsureResolved(Thread* self, const char* descriptor, ObjPtr<mirror::Class> klass) WARN_UNUSED - SHARED_REQUIRES(Locks::mutator_lock_) - REQUIRES(!dex_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) + REQUIRES(!Locks::dex_lock_); - void FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class) - SHARED_REQUIRES(Locks::mutator_lock_); + void FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class, + ObjPtr<mirror::Class> new_class) + REQUIRES_SHARED(Locks::mutator_lock_); - void SetClassRoot(ClassRoot class_root, mirror::Class* klass) - SHARED_REQUIRES(Locks::mutator_lock_); + void SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass) + REQUIRES_SHARED(Locks::mutator_lock_); // Return the quick generic JNI stub for testing. const void* GetRuntimeQuickGenericJniStub() const; - bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics, bool can_init_parents) - SHARED_REQUIRES(Locks::mutator_lock_); + bool CanWeInitializeClass(ObjPtr<mirror::Class> klass, + bool can_init_statics, + bool can_init_parents) + REQUIRES_SHARED(Locks::mutator_lock_); - void UpdateClassMethods(mirror::Class* klass, + void UpdateClassMethods(ObjPtr<mirror::Class> klass, LengthPrefixedArray<ArtMethod>* new_methods) - SHARED_REQUIRES(Locks::mutator_lock_) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Locks::classlinker_classes_lock_); // new_class_set is the set of classes that were read from the class table section in the image. @@ -1085,13 +1119,19 @@ class ClassLinker { ClassTable::ClassSet* new_class_set, bool* out_forward_dex_cache_array, std::string* out_error_msg) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); // Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise. void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor) - REQUIRES(!dex_lock_) - SHARED_REQUIRES(Locks::mutator_lock_); + REQUIRES(!Locks::dex_lock_) + REQUIRES_SHARED(Locks::mutator_lock_); + + // Allocate method arrays for interfaces. + bool AllocateIfTableMethodArrays(Thread* self, + Handle<mirror::Class> klass, + Handle<mirror::IfTable> iftable) + REQUIRES_SHARED(Locks::mutator_lock_); // Sets imt_ref appropriately for LinkInterfaceMethods. // If there is no method in the imt location of imt_ref it will store the given method there. @@ -1101,30 +1141,29 @@ class ClassLinker { ArtMethod* imt_conflict_method, ArtMethod* current_method, /*out*/bool* new_conflict, - /*out*/ArtMethod** imt_ref) SHARED_REQUIRES(Locks::mutator_lock_); + /*out*/ArtMethod** imt_ref) REQUIRES_SHARED(Locks::mutator_lock_); - void FillIMTFromIfTable(mirror::IfTable* if_table, + void FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table, ArtMethod* unimplemented_method, ArtMethod* imt_conflict_method, - mirror::Class* klass, + ObjPtr<mirror::Class> klass, bool create_conflict_tables, bool ignore_copied_methods, /*out*/bool* new_conflict, - /*out*/ArtMethod** imt) SHARED_REQUIRES(Locks::mutator_lock_); + /*out*/ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_); void FillImtFromSuperClass(Handle<mirror::Class> klass, ArtMethod* unimplemented_method, ArtMethod* imt_conflict_method, bool* new_conflict, - ArtMethod** imt) SHARED_REQUIRES(Locks::mutator_lock_); + ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_); std::vector<const DexFile*> boot_class_path_; std::vector<std::unique_ptr<const DexFile>> boot_dex_files_; - mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; // JNI weak globals and side data to allow dex caches to get unloaded. We lazily delete weak // globals when we register new dex files. - std::list<DexCacheData> dex_caches_ GUARDED_BY(dex_lock_); + std::list<DexCacheData> dex_caches_ GUARDED_BY(Locks::dex_lock_); // This contains the class loaders which have class tables. It is populated by // InsertClassTableForClassLoader. @@ -1137,8 +1176,10 @@ class ClassLinker { // New class roots, only used by CMS since the GC needs to mark these in the pause. std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); - // Do we need to search dex caches to find boot image classes? - bool dex_cache_boot_image_class_lookup_required_; + // Boot image oat files with new .bss GC roots to be visited in the pause by CMS. + std::vector<const OatFile*> new_bss_roots_boot_oat_files_ + GUARDED_BY(Locks::classlinker_classes_lock_); + // Number of times we've searched dex caches for a class. After a certain number of misses we move // the classes into the class_table_ to avoid dex cache based searches. Atomic<uint32_t> failed_dex_cache_class_lookups_; @@ -1156,7 +1197,7 @@ class ClassLinker { size_t find_array_class_cache_next_victim_; bool init_done_; - bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); + bool log_new_roots_ GUARDED_BY(Locks::classlinker_classes_lock_); InternTable* intern_table_; @@ -1168,19 +1209,53 @@ class ClassLinker { const void* quick_to_interpreter_bridge_trampoline_; // Image pointer size. - size_t image_pointer_size_; + PointerSize image_pointer_size_; class FindVirtualMethodHolderVisitor; friend struct CompilationHelper; // For Compile in ImageTest. friend class ImageDumper; // for DexLock friend class ImageWriter; // for GetClassRoots + friend class VMClassLoader; // for LookupClass and FindClassInBaseDexClassLoader. friend class JniCompilerTest; // for GetRuntimeQuickGenericJniStub friend class JniInternalTest; // for GetRuntimeQuickGenericJniStub ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName); // for DexLock, and RegisterDexFileLocked + ART_FRIEND_TEST(mirror::DexCacheMethodHandlesTest, Open); // for AllocDexCache ART_FRIEND_TEST(mirror::DexCacheTest, Open); // for AllocDexCache DISALLOW_COPY_AND_ASSIGN(ClassLinker); }; +class ClassLoadCallback { + public: + virtual ~ClassLoadCallback() {} + + // If set we will replace initial_class_def & initial_dex_file with the final versions. The + // callback author is responsible for ensuring these are allocated in such a way they can be + // cleaned up if another transformation occurs. Note that both must be set or null/unchanged on + // return. + // Note: the class may be temporary, in which case a following ClassPrepare event will be a + // different object. It is the listener's responsibility to handle this. + // Note: This callback is rarely useful so a default implementation has been given that does + // nothing. + virtual void 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 DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED, + /*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED, + /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED) + REQUIRES_SHARED(Locks::mutator_lock_) {} + + // A class has been loaded. + // Note: the class may be temporary, in which case a following ClassPrepare event will be a + // different object. It is the listener's responsibility to handle this. + virtual void ClassLoad(Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0; + + // A class has been prepared, i.e., resolved. As the ClassLoad event might have been for a + // temporary class, provide both the former and the current class. + virtual void ClassPrepare(Handle<mirror::Class> temp_klass, + Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0; +}; + } // namespace art #endif // ART_RUNTIME_CLASS_LINKER_H_ |