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