class_linker.h revision 9e050df94df5c6736e1e24705194f62fbc119114 
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
39namespace art {
40
41namespace gc {
42namespace space {
43  class ImageSpace;
44}  // namespace space
45}  // namespace gc
46namespace 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
63class ClassHierarchyAnalysis;
64class ClassTable;
65template<class T> class Handle;
66class ImtConflictTable;
67template<typename T> class LengthPrefixedArray;
68template<class T> class MutableHandle;
69class InternTable;
70class LinearAlloc;
71class OatFile;
72template<class T> class ObjectLock;
73class Runtime;
74class ScopedObjectAccessAlreadyRunnable;
75template<size_t kNumReferences> class PACKED(4) StackHandleScope;
76
77enum VisitRootFlags : uint8_t;
78
79class ClassVisitor {
80 public:
81  virtual ~ClassVisitor() {}
82  // Return true to continue visiting.
83  virtual bool operator()(ObjPtr<mirror::Class> klass) = 0;
84};
85
86class ClassLoaderVisitor {
87 public:
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
93class 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_.
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.
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
401  const std::vector<const DexFile*>& GetBootClassPath() {
402    return boot_class_path_;
403  }
404
405  void VisitClasses(ClassVisitor* visitor)
406      REQUIRES(!Locks::classlinker_classes_lock_)
407      REQUIRES_SHARED(Locks::mutator_lock_);
408
409  // Less efficient variant of VisitClasses that copies the class_table_ into secondary storage
410  // so that it can visit individual classes without holding the doesn't hold the
411  // Locks::classlinker_classes_lock_. As the Locks::classlinker_classes_lock_ isn't held this code
412  // can race with insertion and deletion of classes while the visitor is being called.
413  void VisitClassesWithoutClassesLock(ClassVisitor* visitor)
414      REQUIRES_SHARED(Locks::mutator_lock_)
415      REQUIRES(!Locks::dex_lock_);
416
417  void VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags)
418      REQUIRES(!Locks::classlinker_classes_lock_, !Locks::trace_lock_)
419      REQUIRES_SHARED(Locks::mutator_lock_);
420  void VisitRoots(RootVisitor* visitor, VisitRootFlags flags)
421      REQUIRES(!Locks::dex_lock_, !Locks::classlinker_classes_lock_, !Locks::trace_lock_)
422      REQUIRES_SHARED(Locks::mutator_lock_);
423
424  bool IsDexFileRegistered(Thread* self, const DexFile& dex_file)
425      REQUIRES(!Locks::dex_lock_)
426      REQUIRES_SHARED(Locks::mutator_lock_);
427  ObjPtr<mirror::DexCache> FindDexCache(Thread* self, const DexFile& dex_file)
428      REQUIRES(!Locks::dex_lock_)
429      REQUIRES_SHARED(Locks::mutator_lock_);
430  ClassTable* FindClassTable(Thread* self, ObjPtr<mirror::DexCache> dex_cache)
431      REQUIRES(!Locks::dex_lock_)
432      REQUIRES_SHARED(Locks::mutator_lock_);
433
434  LengthPrefixedArray<ArtField>* AllocArtFieldArray(Thread* self,
435                                                    LinearAlloc* allocator,
436                                                    size_t length);
437
438  LengthPrefixedArray<ArtMethod>* AllocArtMethodArray(Thread* self,
439                                                      LinearAlloc* allocator,
440                                                      size_t length);
441
442  mirror::PointerArray* AllocPointerArray(Thread* self, size_t length)
443      REQUIRES_SHARED(Locks::mutator_lock_)
444      REQUIRES(!Roles::uninterruptible_);
445
446  mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
447      REQUIRES_SHARED(Locks::mutator_lock_)
448      REQUIRES(!Roles::uninterruptible_);
449
450  mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
451                                                                              size_t length)
452      REQUIRES_SHARED(Locks::mutator_lock_)
453      REQUIRES(!Roles::uninterruptible_);
454
455  verifier::FailureKind VerifyClass(
456      Thread* self,
457      Handle<mirror::Class> klass,
458      verifier::HardFailLogMode log_level = verifier::HardFailLogMode::kLogNone)
459      REQUIRES_SHARED(Locks::mutator_lock_)
460      REQUIRES(!Locks::dex_lock_);
461  bool VerifyClassUsingOatFile(const DexFile& dex_file,
462                               ObjPtr<mirror::Class> klass,
463                               mirror::Class::Status& oat_file_class_status)
464      REQUIRES_SHARED(Locks::mutator_lock_)
465      REQUIRES(!Locks::dex_lock_);
466  void ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass)
467      REQUIRES_SHARED(Locks::mutator_lock_)
468      REQUIRES(!Locks::dex_lock_);
469  void ResolveMethodExceptionHandlerTypes(ArtMethod* klass)
470      REQUIRES_SHARED(Locks::mutator_lock_)
471      REQUIRES(!Locks::dex_lock_);
472
473  mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa,
474                                  jstring name,
475                                  jobjectArray interfaces,
476                                  jobject loader,
477                                  jobjectArray methods,
478                                  jobjectArray throws)
479      REQUIRES_SHARED(Locks::mutator_lock_);
480  std::string GetDescriptorForProxy(ObjPtr<mirror::Class> proxy_class)
481      REQUIRES_SHARED(Locks::mutator_lock_);
482  ArtMethod* FindMethodForProxy(ArtMethod* proxy_method)
483      REQUIRES(!Locks::dex_lock_)
484      REQUIRES_SHARED(Locks::mutator_lock_);
485
486  // Get the oat code for a method when its class isn't yet initialized.
487  const void* GetQuickOatCodeFor(ArtMethod* method)
488      REQUIRES_SHARED(Locks::mutator_lock_);
489
490  pid_t GetClassesLockOwner();  // For SignalCatcher.
491  pid_t GetDexLockOwner();  // For SignalCatcher.
492
493  mirror::Class* GetClassRoot(ClassRoot class_root) REQUIRES_SHARED(Locks::mutator_lock_);
494
495  static const char* GetClassRootDescriptor(ClassRoot class_root);
496
497  // Is the given entry point quick code to run the resolution stub?
498  bool IsQuickResolutionStub(const void* entry_point) const;
499
500  // Is the given entry point quick code to bridge into the interpreter?
501  bool IsQuickToInterpreterBridge(const void* entry_point) const;
502
503  // Is the given entry point quick code to run the generic JNI stub?
504  bool IsQuickGenericJniStub(const void* entry_point) const;
505
506  const void* GetQuickToInterpreterBridgeTrampoline() const {
507    return quick_to_interpreter_bridge_trampoline_;
508  }
509
510  InternTable* GetInternTable() const {
511    return intern_table_;
512  }
513
514  // Set the entrypoints up for method to the given code.
515  void SetEntryPointsToCompiledCode(ArtMethod* method, const void* method_code) const
516      REQUIRES_SHARED(Locks::mutator_lock_);
517
518  // Set the entrypoints up for method to the enter the interpreter.
519  void SetEntryPointsToInterpreter(ArtMethod* method) const
520      REQUIRES_SHARED(Locks::mutator_lock_);
521
522  // Set the entrypoints up for an obsolete method.
523  void SetEntryPointsForObsoleteMethod(ArtMethod* method) const
524      REQUIRES_SHARED(Locks::mutator_lock_);
525
526  // Attempts to insert a class into a class table.  Returns null if
527  // the class was inserted, otherwise returns an existing class with
528  // the same descriptor and ClassLoader.
529  mirror::Class* InsertClass(const char* descriptor, ObjPtr<mirror::Class> klass, size_t hash)
530      REQUIRES(!Locks::classlinker_classes_lock_)
531      REQUIRES_SHARED(Locks::mutator_lock_);
532
533  // Add an oat file with .bss GC roots to be visited again at the end of GC
534  // for collector types that need it.
535  void WriteBarrierForBootOatFileBssRoots(const OatFile* oat_file)
536      REQUIRES(!Locks::classlinker_classes_lock_)
537      REQUIRES_SHARED(Locks::mutator_lock_);
538
539  mirror::ObjectArray<mirror::Class>* GetClassRoots() REQUIRES_SHARED(Locks::mutator_lock_) {
540    mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
541    DCHECK(class_roots != nullptr);
542    return class_roots;
543  }
544
545  // Move the class table to the pre-zygote table to reduce memory usage. This works by ensuring
546  // that no more classes are ever added to the pre zygote table which makes it that the pages
547  // always remain shared dirty instead of private dirty.
548  void MoveClassTableToPreZygote()
549      REQUIRES(!Locks::classlinker_classes_lock_)
550      REQUIRES_SHARED(Locks::mutator_lock_);
551
552  // Creates a GlobalRef PathClassLoader or DelegateLastClassLoader (specified by loader_class)
553  // that can be used to load classes from the given dex files. The parent of the class loader
554  // will be set to `parent_loader`. If `parent_loader` is null the parent will be
555  // the boot class loader.
556  // If class_loader points to a different class than PathClassLoader or DelegateLastClassLoader
557  // this method will abort.
558  // Note: the objects are not completely set up. Do not use this outside of tests and the compiler.
559  jobject CreateWellKnownClassLoader(Thread* self,
560                                     const std::vector<const DexFile*>& dex_files,
561                                     jclass loader_class,
562                                     jobject parent_loader)
563      REQUIRES_SHARED(Locks::mutator_lock_)
564      REQUIRES(!Locks::dex_lock_);
565
566  // Calls CreateWellKnownClassLoader(self,
567  //                                  dex_files,
568  //                                  WellKnownClasses::dalvik_system_PathClassLoader,
569  //                                  nullptr)
570  jobject CreatePathClassLoader(Thread* self, const std::vector<const DexFile*>& dex_files)
571      REQUIRES_SHARED(Locks::mutator_lock_)
572      REQUIRES(!Locks::dex_lock_);
573
574  PointerSize GetImagePointerSize() const {
575    return image_pointer_size_;
576  }
577
578  // Used by image writer for checking.
579  bool ClassInClassTable(ObjPtr<mirror::Class> klass)
580      REQUIRES(Locks::classlinker_classes_lock_)
581      REQUIRES_SHARED(Locks::mutator_lock_);
582
583  // Clear the ArrayClass cache. This is necessary when cleaning up for the image, as the cache
584  // entries are roots, but potentially not image classes.
585  void DropFindArrayClassCache() REQUIRES_SHARED(Locks::mutator_lock_);
586
587  // Clean up class loaders, this needs to happen after JNI weak globals are cleared.
588  void CleanupClassLoaders()
589      REQUIRES(!Locks::classlinker_classes_lock_)
590      REQUIRES_SHARED(Locks::mutator_lock_);
591
592  // Unlike GetOrCreateAllocatorForClassLoader, GetAllocatorForClassLoader asserts that the
593  // allocator for this class loader is already created.
594  LinearAlloc* GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
595      REQUIRES_SHARED(Locks::mutator_lock_);
596
597  // Return the linear alloc for a class loader if it is already allocated, otherwise allocate and
598  // set it. TODO: Consider using a lock other than classlinker_classes_lock_.
599  LinearAlloc* GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
600      REQUIRES(!Locks::classlinker_classes_lock_)
601      REQUIRES_SHARED(Locks::mutator_lock_);
602
603  // May be called with null class_loader due to legacy code. b/27954959
604  void InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file,
605                                    ObjPtr<mirror::ClassLoader> class_loader)
606      REQUIRES(!Locks::classlinker_classes_lock_)
607      REQUIRES_SHARED(Locks::mutator_lock_);
608
609  static bool ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code)
610      REQUIRES_SHARED(Locks::mutator_lock_);
611
612  std::set<DexCacheResolvedClasses> GetResolvedClasses(bool ignore_boot_classes)
613      REQUIRES(!Locks::dex_lock_);
614
615  static bool IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
616                                ObjPtr<mirror::ClassLoader> class_loader)
617      REQUIRES_SHARED(Locks::mutator_lock_);
618
619  ArtMethod* AddMethodToConflictTable(ObjPtr<mirror::Class> klass,
620                                      ArtMethod* conflict_method,
621                                      ArtMethod* interface_method,
622                                      ArtMethod* method,
623                                      bool force_new_conflict_method)
624      REQUIRES_SHARED(Locks::mutator_lock_);
625
626  // Create a conflict table with a specified capacity.
627  ImtConflictTable* CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc);
628
629  // Static version for when the class linker is not yet created.
630  static ImtConflictTable* CreateImtConflictTable(size_t count,
631                                                  LinearAlloc* linear_alloc,
632                                                  PointerSize pointer_size);
633
634
635  // Create the IMT and conflict tables for a class.
636  void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
637
638  // Visit all of the class tables. This is used by dex2oat to allow pruning dex caches.
639  template <class Visitor>
640  void VisitClassTables(const Visitor& visitor)
641      REQUIRES(!Locks::classlinker_classes_lock_)
642      REQUIRES_SHARED(Locks::mutator_lock_);
643
644  // Throw the class initialization failure recorded when first trying to initialize the given
645  // class.
646  void ThrowEarlierClassFailure(ObjPtr<mirror::Class> c, bool wrap_in_no_class_def = false)
647      REQUIRES_SHARED(Locks::mutator_lock_)
648      REQUIRES(!Locks::dex_lock_);
649
650  // Get the actual holding class for a copied method. Pretty slow, don't call often.
651  mirror::Class* GetHoldingClassOfCopiedMethod(ArtMethod* method)
652      REQUIRES_SHARED(Locks::mutator_lock_);
653
654  // Returns null if not found.
655  // This returns a pointer to the class-table, without requiring any locking - including the
656  // boot class-table. It is the caller's responsibility to access this under lock, if required.
657  ClassTable* ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
658      REQUIRES_SHARED(Locks::mutator_lock_)
659      NO_THREAD_SAFETY_ANALYSIS;
660
661  void AppendToBootClassPath(Thread* self, const DexFile& dex_file)
662      REQUIRES_SHARED(Locks::mutator_lock_)
663      REQUIRES(!Locks::dex_lock_);
664
665  // Visit all of the class loaders in the class linker.
666  void VisitClassLoaders(ClassLoaderVisitor* visitor) const
667      REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
668
669  // Checks that a class and its superclass from another class loader have the same virtual methods.
670  bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass)
671      REQUIRES_SHARED(Locks::mutator_lock_);
672
673  ClassHierarchyAnalysis* GetClassHierarchyAnalysis() {
674    return cha_.get();
675  }
676
677  struct DexCacheData {
678    // Construct an invalid data object.
679    DexCacheData()
680        : weak_root(nullptr),
681          dex_file(nullptr),
682          resolved_methods(nullptr),
683          class_table(nullptr) { }
684
685    // Check if the data is valid.
686    bool IsValid() const {
687      return dex_file != nullptr;
688    }
689
690    // Weak root to the DexCache. Note: Do not decode this unnecessarily or else class unloading may
691    // not work properly.
692    jweak weak_root;
693    // The following two fields are caches to the DexCache's fields and here to avoid unnecessary
694    // jweak decode that triggers read barriers (and mark them alive unnecessarily and mess with
695    // class unloading.)
696    const DexFile* dex_file;
697    mirror::MethodDexCacheType* resolved_methods;
698    // Identify the associated class loader's class table. This is used to make sure that
699    // the Java call to native DexCache.setResolvedType() inserts the resolved type in that
700    // class table. It is also used to make sure we don't register the same dex cache with
701    // multiple class loaders.
702    ClassTable* class_table;
703  };
704
705 protected:
706  virtual bool InitializeClass(Thread* self,
707                               Handle<mirror::Class> klass,
708                               bool can_run_clinit,
709                               bool can_init_parents)
710      REQUIRES_SHARED(Locks::mutator_lock_)
711      REQUIRES(!Locks::dex_lock_);
712
713  virtual verifier::FailureKind PerformClassVerification(Thread* self,
714                                                         Handle<mirror::Class> klass,
715                                                         verifier::HardFailLogMode log_level,
716                                                         std::string* error_msg)
717      REQUIRES_SHARED(Locks::mutator_lock_);
718
719 private:
720  class LinkInterfaceMethodsHelper;
721
722  struct ClassLoaderData {
723    jweak weak_root;  // Weak root to enable class unloading.
724    ClassTable* class_table;
725    LinearAlloc* allocator;
726  };
727
728  // Ensures that the supertype of 'klass' ('supertype') is verified. Returns false and throws
729  // appropriate exceptions if verification failed hard. Returns true for successful verification or
730  // soft-failures.
731  bool AttemptSupertypeVerification(Thread* self,
732                                    Handle<mirror::Class> klass,
733                                    Handle<mirror::Class> supertype)
734      REQUIRES(!Locks::dex_lock_)
735      REQUIRES_SHARED(Locks::mutator_lock_);
736
737  void DeleteClassLoader(Thread* self, const ClassLoaderData& data)
738      REQUIRES_SHARED(Locks::mutator_lock_);
739
740  void VisitClassesInternal(ClassVisitor* visitor)
741      REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
742
743  // Returns the number of zygote and image classes.
744  size_t NumZygoteClasses() const
745      REQUIRES(Locks::classlinker_classes_lock_)
746      REQUIRES_SHARED(Locks::mutator_lock_);
747
748  // Returns the number of non zygote nor image classes.
749  size_t NumNonZygoteClasses() const
750      REQUIRES(Locks::classlinker_classes_lock_)
751      REQUIRES_SHARED(Locks::mutator_lock_);
752
753  void FinishInit(Thread* self)
754      REQUIRES_SHARED(Locks::mutator_lock_)
755      REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
756
757  // For early bootstrapping by Init
758  mirror::Class* AllocClass(Thread* self,
759                            ObjPtr<mirror::Class> java_lang_Class,
760                            uint32_t class_size)
761      REQUIRES_SHARED(Locks::mutator_lock_)
762      REQUIRES(!Roles::uninterruptible_);
763
764  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
765  // values that are known to the ClassLinker such as
766  // kObjectArrayClass and kJavaLangString etc.
767  mirror::Class* AllocClass(Thread* self, uint32_t class_size)
768      REQUIRES_SHARED(Locks::mutator_lock_)
769      REQUIRES(!Roles::uninterruptible_);
770
771  mirror::DexCache* AllocDexCache(ObjPtr<mirror::String>* out_location,
772                                  Thread* self,
773                                  const DexFile& dex_file)
774      REQUIRES_SHARED(Locks::mutator_lock_)
775      REQUIRES(!Roles::uninterruptible_);
776
777  // Used for tests and AppendToBootClassPath.
778  mirror::DexCache* AllocAndInitializeDexCache(Thread* self,
779                                               const DexFile& dex_file,
780                                               LinearAlloc* linear_alloc)
781      REQUIRES_SHARED(Locks::mutator_lock_)
782      REQUIRES(!Locks::dex_lock_)
783      REQUIRES(!Roles::uninterruptible_);
784
785  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
786      REQUIRES_SHARED(Locks::mutator_lock_)
787      REQUIRES(!Roles::uninterruptible_);
788  mirror::Class* InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class,
789                                          Primitive::Type type)
790      REQUIRES_SHARED(Locks::mutator_lock_)
791      REQUIRES(!Roles::uninterruptible_);
792
793  mirror::Class* CreateArrayClass(Thread* self,
794                                  const char* descriptor,
795                                  size_t hash,
796                                  Handle<mirror::ClassLoader> class_loader)
797      REQUIRES_SHARED(Locks::mutator_lock_)
798      REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
799
800  void AppendToBootClassPath(const DexFile& dex_file, ObjPtr<mirror::DexCache> dex_cache)
801      REQUIRES_SHARED(Locks::mutator_lock_)
802      REQUIRES(!Locks::dex_lock_);
803
804  // Precomputes size needed for Class, in the case of a non-temporary class this size must be
805  // sufficient to hold all static fields.
806  uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
807                                            const DexFile::ClassDef& dex_class_def);
808
809  // Setup the classloader, class def index, type idx so that we can insert this class in the class
810  // table.
811  void SetupClass(const DexFile& dex_file,
812                  const DexFile::ClassDef& dex_class_def,
813                  Handle<mirror::Class> klass,
814                  ObjPtr<mirror::ClassLoader> class_loader)
815      REQUIRES_SHARED(Locks::mutator_lock_);
816
817  void LoadClass(Thread* self,
818                 const DexFile& dex_file,
819                 const DexFile::ClassDef& dex_class_def,
820                 Handle<mirror::Class> klass)
821      REQUIRES_SHARED(Locks::mutator_lock_);
822  void LoadClassMembers(Thread* self,
823                        const DexFile& dex_file,
824                        const uint8_t* class_data,
825                        Handle<mirror::Class> klass)
826      REQUIRES_SHARED(Locks::mutator_lock_);
827
828  void LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtField* dst)
829      REQUIRES_SHARED(Locks::mutator_lock_);
830
831  void LoadMethod(const DexFile& dex_file,
832                  const ClassDataItemIterator& it,
833                  Handle<mirror::Class> klass, ArtMethod* dst)
834      REQUIRES_SHARED(Locks::mutator_lock_);
835
836  void FixupStaticTrampolines(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
837
838  // Finds a class in a Path- or DexClassLoader, loading it if necessary without using JNI. Hash
839  // function is supposed to be ComputeModifiedUtf8Hash(descriptor). Returns true if the
840  // class-loader chain could be handled, false otherwise, i.e., a non-supported class-loader
841  // was encountered while walking the parent chain (currently only BootClassLoader and
842  // PathClassLoader are supported).
843  bool FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
844                                     Thread* self,
845                                     const char* descriptor,
846                                     size_t hash,
847                                     Handle<mirror::ClassLoader> class_loader,
848                                     ObjPtr<mirror::Class>* result)
849      REQUIRES_SHARED(Locks::mutator_lock_)
850      REQUIRES(!Locks::dex_lock_);
851
852  // Finds the class in the classpath of the given class loader. It only searches the class loader
853  // dex files and does not recurse into its parent.
854  // The method checks that the provided class loader is either a PathClassLoader or a
855  // DexClassLoader.
856  // If the class is found the method returns the resolved class. Otherwise it returns null.
857  ObjPtr<mirror::Class> FindClassInBaseDexClassLoaderClassPath(
858          ScopedObjectAccessAlreadyRunnable& soa,
859          const char* descriptor,
860          size_t hash,
861          Handle<mirror::ClassLoader> class_loader)
862      REQUIRES_SHARED(Locks::mutator_lock_)
863      REQUIRES(!Locks::dex_lock_);
864
865  // Finds the class in the boot class loader.
866  // If the class is found the method returns the resolved class. Otherwise it returns null.
867  ObjPtr<mirror::Class> FindClassInBootClassLoaderClassPath(Thread* self,
868                                                            const char* descriptor,
869                                                            size_t hash)
870      REQUIRES_SHARED(Locks::mutator_lock_)
871      REQUIRES(!Locks::dex_lock_);
872
873  // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
874  // by the given 'class_loader'. Uses the provided hash for the descriptor.
875  mirror::Class* LookupClass(Thread* self,
876                             const char* descriptor,
877                             size_t hash,
878                             ObjPtr<mirror::ClassLoader> class_loader)
879      REQUIRES(!Locks::classlinker_classes_lock_)
880      REQUIRES_SHARED(Locks::mutator_lock_);
881
882  // Find a field by its field index.
883  ArtField* LookupResolvedField(uint32_t field_idx,
884                                ObjPtr<mirror::DexCache> dex_cache,
885                                ObjPtr<mirror::ClassLoader> class_loader,
886                                bool is_static)
887      REQUIRES_SHARED(Locks::mutator_lock_);
888
889  void RegisterDexFileLocked(const DexFile& dex_file,
890                             ObjPtr<mirror::DexCache> dex_cache,
891                             ObjPtr<mirror::ClassLoader> class_loader)
892      REQUIRES(Locks::dex_lock_)
893      REQUIRES_SHARED(Locks::mutator_lock_);
894  DexCacheData FindDexCacheDataLocked(const DexFile& dex_file)
895      REQUIRES(Locks::dex_lock_)
896      REQUIRES_SHARED(Locks::mutator_lock_);
897  static ObjPtr<mirror::DexCache> DecodeDexCache(Thread* self, const DexCacheData& data)
898      REQUIRES_SHARED(Locks::mutator_lock_);
899  // Called to ensure that the dex cache has been registered with the same class loader.
900  // If yes, returns the dex cache, otherwise throws InternalError and returns null.
901  ObjPtr<mirror::DexCache> EnsureSameClassLoader(Thread* self,
902                                                 ObjPtr<mirror::DexCache> dex_cache,
903                                                 const DexCacheData& data,
904                                                 ObjPtr<mirror::ClassLoader> class_loader)
905      REQUIRES(!Locks::dex_lock_)
906      REQUIRES_SHARED(Locks::mutator_lock_);
907
908  bool InitializeDefaultInterfaceRecursive(Thread* self,
909                                           Handle<mirror::Class> klass,
910                                           bool can_run_clinit,
911                                           bool can_init_parents)
912      REQUIRES(!Locks::dex_lock_)
913      REQUIRES_SHARED(Locks::mutator_lock_);
914  bool WaitForInitializeClass(Handle<mirror::Class> klass,
915                              Thread* self,
916                              ObjectLock<mirror::Class>& lock);
917
918  bool IsSameDescriptorInDifferentClassContexts(Thread* self,
919                                                const char* descriptor,
920                                                Handle<mirror::ClassLoader> class_loader1,
921                                                Handle<mirror::ClassLoader> class_loader2)
922      REQUIRES_SHARED(Locks::mutator_lock_);
923
924  bool IsSameMethodSignatureInDifferentClassContexts(Thread* self,
925                                                     ArtMethod* method,
926                                                     ObjPtr<mirror::Class> klass1,
927                                                     ObjPtr<mirror::Class> klass2)
928      REQUIRES_SHARED(Locks::mutator_lock_);
929
930  bool LinkClass(Thread* self,
931                 const char* descriptor,
932                 Handle<mirror::Class> klass,
933                 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
934                 MutableHandle<mirror::Class>* h_new_class_out)
935      REQUIRES_SHARED(Locks::mutator_lock_)
936      REQUIRES(!Locks::classlinker_classes_lock_);
937
938  bool LinkSuperClass(Handle<mirror::Class> klass)
939      REQUIRES_SHARED(Locks::mutator_lock_);
940
941  bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file)
942      REQUIRES_SHARED(Locks::mutator_lock_)
943      REQUIRES(!Locks::dex_lock_);
944
945  bool LinkMethods(Thread* self,
946                   Handle<mirror::Class> klass,
947                   Handle<mirror::ObjectArray<mirror::Class>> interfaces,
948                   bool* out_new_conflict,
949                   ArtMethod** out_imt)
950      REQUIRES_SHARED(Locks::mutator_lock_);
951
952  mirror::MethodHandle* ResolveMethodHandleForField(Thread* self,
953                                                    const DexFile::MethodHandleItem& method_handle,
954                                                    ArtMethod* referrer)
955      REQUIRES_SHARED(Locks::mutator_lock_);
956
957  mirror::MethodHandle* ResolveMethodHandleForMethod(Thread* self,
958                                                     const DexFile* const dex_file,
959                                                     const DexFile::MethodHandleItem& method_handle,
960                                                     ArtMethod* referrer)
961      REQUIRES_SHARED(Locks::mutator_lock_);
962
963  // A wrapper class representing the result of a method translation used for linking methods and
964  // updating superclass default methods. For each method in a classes vtable there are 4 states it
965  // could be in:
966  // 1) No translation is necessary. In this case there is no MethodTranslation object for it. This
967  //    is the standard case and is true when the method is not overridable by a default method,
968  //    the class defines a concrete implementation of the method, the default method implementation
969  //    remains the same, or an abstract method stayed abstract.
970  // 2) The method must be translated to a different default method. We note this with
971  //    CreateTranslatedMethod.
972  // 3) The method must be replaced with a conflict method. This happens when a superclass
973  //    implements an interface with a default method and this class implements an unrelated
974  //    interface that also defines that default method. We note this with CreateConflictingMethod.
975  // 4) The method must be replaced with an abstract miranda method. This happens when a superclass
976  //    implements an interface with a default method and this class implements a subinterface of
977  //    the superclass's interface which declares the default method abstract. We note this with
978  //    CreateAbstractMethod.
979  //
980  // When a method translation is unnecessary (case #1), we don't put it into the
981  // default_translation maps. So an instance of MethodTranslation must be in one of #2-#4.
982  class MethodTranslation {
983   public:
984    // This slot must become a default conflict method.
985    static MethodTranslation CreateConflictingMethod() {
986      return MethodTranslation(Type::kConflict, /*translation*/nullptr);
987    }
988
989    // This slot must become an abstract method.
990    static MethodTranslation CreateAbstractMethod() {
991      return MethodTranslation(Type::kAbstract, /*translation*/nullptr);
992    }
993
994    // Use the given method as the current value for this vtable slot during translation.
995    static MethodTranslation CreateTranslatedMethod(ArtMethod* new_method) {
996      return MethodTranslation(Type::kTranslation, new_method);
997    }
998
999    // Returns true if this is a method that must become a conflict method.
1000    bool IsInConflict() const {
1001      return type_ == Type::kConflict;
1002    }
1003
1004    // Returns true if this is a method that must become an abstract method.
1005    bool IsAbstract() const {
1006      return type_ == Type::kAbstract;
1007    }
1008
1009    // Returns true if this is a method that must become a different method.
1010    bool IsTranslation() const {
1011      return type_ == Type::kTranslation;
1012    }
1013
1014    // Get the translated version of this method.
1015    ArtMethod* GetTranslation() const {
1016      DCHECK(IsTranslation());
1017      DCHECK(translation_ != nullptr);
1018      return translation_;
1019    }
1020
1021   private:
1022    enum class Type {
1023      kTranslation,
1024      kConflict,
1025      kAbstract,
1026    };
1027
1028    MethodTranslation(Type type, ArtMethod* translation)
1029        : translation_(translation), type_(type) {}
1030
1031    ArtMethod* const translation_;
1032    const Type type_;
1033  };
1034
1035  // Links the virtual methods for the given class and records any default methods that will need to
1036  // be updated later.
1037  //
1038  // Arguments:
1039  // * self - The current thread.
1040  // * klass - class, whose vtable will be filled in.
1041  // * default_translations - Vtable index to new method map.
1042  //                          Any vtable entries that need to be updated with new default methods
1043  //                          are stored into the default_translations map. The default_translations
1044  //                          map is keyed on the vtable index that needs to be updated. We use this
1045  //                          map because if we override a default method with another default
1046  //                          method we need to update the vtable to point to the new method.
1047  //                          Unfortunately since we copy the ArtMethod* we cannot just do a simple
1048  //                          scan, we therefore store the vtable index's that might need to be
1049  //                          updated with the method they will turn into.
1050  // TODO This whole default_translations thing is very dirty. There should be a better way.
1051  bool LinkVirtualMethods(
1052        Thread* self,
1053        Handle<mirror::Class> klass,
1054        /*out*/std::unordered_map<size_t, MethodTranslation>* default_translations)
1055      REQUIRES_SHARED(Locks::mutator_lock_);
1056
1057  // Sets up the interface lookup table (IFTable) in the correct order to allow searching for
1058  // default methods.
1059  bool SetupInterfaceLookupTable(Thread* self,
1060                                 Handle<mirror::Class> klass,
1061                                 Handle<mirror::ObjectArray<mirror::Class>> interfaces)
1062      REQUIRES_SHARED(Locks::mutator_lock_);
1063
1064
1065  enum class DefaultMethodSearchResult {
1066    kDefaultFound,
1067    kAbstractFound,
1068    kDefaultConflict
1069  };
1070
1071  // Find the default method implementation for 'interface_method' in 'klass', if one exists.
1072  //
1073  // Arguments:
1074  // * self - The current thread.
1075  // * target_method - The method we are trying to find a default implementation for.
1076  // * klass - The class we are searching for a definition of target_method.
1077  // * out_default_method - The pointer we will store the found default method to on success.
1078  //
1079  // Return value:
1080  // * kDefaultFound - There were no conflicting method implementations found in the class while
1081  //                   searching for target_method. The default method implementation is stored into
1082  //                   out_default_method.
1083  // * kAbstractFound - There were no conflicting method implementations found in the class while
1084  //                   searching for target_method but no default implementation was found either.
1085  //                   out_default_method is set to null and the method should be considered not
1086  //                   implemented.
1087  // * kDefaultConflict - Conflicting method implementations were found when searching for
1088  //                      target_method. The value of *out_default_method is null.
1089  DefaultMethodSearchResult FindDefaultMethodImplementation(
1090      Thread* self,
1091      ArtMethod* target_method,
1092      Handle<mirror::Class> klass,
1093      /*out*/ArtMethod** out_default_method) const
1094      REQUIRES_SHARED(Locks::mutator_lock_);
1095
1096  // Sets the imt entries and fixes up the vtable for the given class by linking all the interface
1097  // methods. See LinkVirtualMethods for an explanation of what default_translations is.
1098  bool LinkInterfaceMethods(
1099      Thread* self,
1100      Handle<mirror::Class> klass,
1101      const std::unordered_map<size_t, MethodTranslation>& default_translations,
1102      bool* out_new_conflict,
1103      ArtMethod** out_imt)
1104      REQUIRES_SHARED(Locks::mutator_lock_);
1105
1106  bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size)
1107      REQUIRES_SHARED(Locks::mutator_lock_);
1108  bool LinkInstanceFields(Thread* self, Handle<mirror::Class> klass)
1109      REQUIRES_SHARED(Locks::mutator_lock_);
1110  bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size)
1111      REQUIRES_SHARED(Locks::mutator_lock_);
1112  void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass)
1113      REQUIRES_SHARED(Locks::mutator_lock_);
1114
1115  void CheckProxyConstructor(ArtMethod* constructor) const
1116      REQUIRES_SHARED(Locks::mutator_lock_);
1117  void CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const
1118      REQUIRES_SHARED(Locks::mutator_lock_);
1119
1120  size_t GetDexCacheCount() REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) {
1121    return dex_caches_.size();
1122  }
1123  const std::list<DexCacheData>& GetDexCachesData()
1124      REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) {
1125    return dex_caches_;
1126  }
1127
1128  void CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out)
1129      REQUIRES_SHARED(Locks::mutator_lock_);
1130  void CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, ArtMethod* out)
1131      REQUIRES_SHARED(Locks::mutator_lock_);
1132
1133  // Register a class loader and create its class table and allocator. Should not be called if
1134  // these are already created.
1135  void RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
1136      REQUIRES_SHARED(Locks::mutator_lock_)
1137      REQUIRES(Locks::classlinker_classes_lock_);
1138
1139  // Insert a new class table if not found.
1140  ClassTable* InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
1141      REQUIRES_SHARED(Locks::mutator_lock_)
1142      REQUIRES(Locks::classlinker_classes_lock_);
1143
1144  // EnsureResolved is called to make sure that a class in the class_table_ has been resolved
1145  // before returning it to the caller. Its the responsibility of the thread that placed the class
1146  // in the table to make it resolved. The thread doing resolution must notify on the class' lock
1147  // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may
1148  // retire a class, the version of the class in the table is returned and this may differ from
1149  // the class passed in.
1150  mirror::Class* EnsureResolved(Thread* self, const char* descriptor, ObjPtr<mirror::Class> klass)
1151      WARN_UNUSED
1152      REQUIRES_SHARED(Locks::mutator_lock_)
1153      REQUIRES(!Locks::dex_lock_);
1154
1155  void FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class,
1156                                    ObjPtr<mirror::Class> new_class)
1157      REQUIRES_SHARED(Locks::mutator_lock_);
1158
1159  void SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass)
1160      REQUIRES_SHARED(Locks::mutator_lock_);
1161
1162  // Return the quick generic JNI stub for testing.
1163  const void* GetRuntimeQuickGenericJniStub() const;
1164
1165  bool CanWeInitializeClass(ObjPtr<mirror::Class> klass,
1166                            bool can_init_statics,
1167                            bool can_init_parents)
1168      REQUIRES_SHARED(Locks::mutator_lock_);
1169
1170  void UpdateClassMethods(ObjPtr<mirror::Class> klass,
1171                          LengthPrefixedArray<ArtMethod>* new_methods)
1172      REQUIRES_SHARED(Locks::mutator_lock_)
1173      REQUIRES(!Locks::classlinker_classes_lock_);
1174
1175  // Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise.
1176  void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor)
1177      REQUIRES(!Locks::dex_lock_)
1178      REQUIRES_SHARED(Locks::mutator_lock_);
1179
1180  // Allocate method arrays for interfaces.
1181  bool AllocateIfTableMethodArrays(Thread* self,
1182                                   Handle<mirror::Class> klass,
1183                                   Handle<mirror::IfTable> iftable)
1184      REQUIRES_SHARED(Locks::mutator_lock_);
1185
1186  // Sets imt_ref appropriately for LinkInterfaceMethods.
1187  // If there is no method in the imt location of imt_ref it will store the given method there.
1188  // Otherwise it will set the conflict method which will figure out which method to use during
1189  // runtime.
1190  void SetIMTRef(ArtMethod* unimplemented_method,
1191                 ArtMethod* imt_conflict_method,
1192                 ArtMethod* current_method,
1193                 /*out*/bool* new_conflict,
1194                 /*out*/ArtMethod** imt_ref) REQUIRES_SHARED(Locks::mutator_lock_);
1195
1196  void FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table,
1197                          ArtMethod* unimplemented_method,
1198                          ArtMethod* imt_conflict_method,
1199                          ObjPtr<mirror::Class> klass,
1200                          bool create_conflict_tables,
1201                          bool ignore_copied_methods,
1202                          /*out*/bool* new_conflict,
1203                          /*out*/ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_);
1204
1205  void FillImtFromSuperClass(Handle<mirror::Class> klass,
1206                             ArtMethod* unimplemented_method,
1207                             ArtMethod* imt_conflict_method,
1208                             bool* new_conflict,
1209                             ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_);
1210
1211  // Check invoke type against the referenced class. Throws IncompatibleClassChangeError
1212  // (if `kThrowOnError`) and returns true on mismatch (kInterface on a non-interface class,
1213  // kVirtual on interface, kDefault on interface for dex files not supporting default methods),
1214  // otherwise returns false.
1215  template <bool kThrowOnError, typename ClassGetter>
1216  static bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache,
1217                                       InvokeType type,
1218                                       ClassGetter class_getter)
1219      REQUIRES_SHARED(Locks::mutator_lock_);
1220  // Helper that feeds the above function with `ClassGetter` doing `LookupResolvedType()`.
1221  template <bool kThrow>
1222  bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache,
1223                                InvokeType type,
1224                                uint32_t method_idx,
1225                                ObjPtr<mirror::ClassLoader> class_loader)
1226      REQUIRES_SHARED(Locks::mutator_lock_);
1227
1228  std::vector<const DexFile*> boot_class_path_;
1229  std::vector<std::unique_ptr<const DexFile>> boot_dex_files_;
1230
1231  // JNI weak globals and side data to allow dex caches to get unloaded. We lazily delete weak
1232  // globals when we register new dex files.
1233  std::list<DexCacheData> dex_caches_ GUARDED_BY(Locks::dex_lock_);
1234
1235  // This contains the class loaders which have class tables. It is populated by
1236  // InsertClassTableForClassLoader.
1237  std::list<ClassLoaderData> class_loaders_
1238      GUARDED_BY(Locks::classlinker_classes_lock_);
1239
1240  // Boot class path table. Since the class loader for this is null.
1241  std::unique_ptr<ClassTable> boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
1242
1243  // New class roots, only used by CMS since the GC needs to mark these in the pause.
1244  std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
1245
1246  // Boot image oat files with new .bss GC roots to be visited in the pause by CMS.
1247  std::vector<const OatFile*> new_bss_roots_boot_oat_files_
1248      GUARDED_BY(Locks::classlinker_classes_lock_);
1249
1250  // Number of times we've searched dex caches for a class. After a certain number of misses we move
1251  // the classes into the class_table_ to avoid dex cache based searches.
1252  Atomic<uint32_t> failed_dex_cache_class_lookups_;
1253
1254  // Well known mirror::Class roots.
1255  GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_;
1256
1257  // The interface table used by all arrays.
1258  GcRoot<mirror::IfTable> array_iftable_;
1259
1260  // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
1261  // descriptors for the sake of performing FindClass.
1262  static constexpr size_t kFindArrayCacheSize = 16;
1263  GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize];
1264  size_t find_array_class_cache_next_victim_;
1265
1266  bool init_done_;
1267  bool log_new_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
1268
1269  InternTable* intern_table_;
1270
1271  // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single
1272  // patch point within the image. TODO: make these proper relocations.
1273  const void* quick_resolution_trampoline_;
1274  const void* quick_imt_conflict_trampoline_;
1275  const void* quick_generic_jni_trampoline_;
1276  const void* quick_to_interpreter_bridge_trampoline_;
1277
1278  // Image pointer size.
1279  PointerSize image_pointer_size_;
1280
1281  std::unique_ptr<ClassHierarchyAnalysis> cha_;
1282
1283  class FindVirtualMethodHolderVisitor;
1284
1285  friend class AppImageClassLoadersAndDexCachesHelper;
1286  friend struct CompilationHelper;  // For Compile in ImageTest.
1287  friend class ImageDumper;  // for DexLock
1288  friend class ImageWriter;  // for GetClassRoots
1289  friend class JniCompilerTest;  // for GetRuntimeQuickGenericJniStub
1290  friend class JniInternalTest;  // for GetRuntimeQuickGenericJniStub
1291  friend class VMClassLoader;  // for LookupClass and FindClassInBaseDexClassLoader.
1292  ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName);  // for DexLock, and RegisterDexFileLocked
1293  ART_FRIEND_TEST(mirror::DexCacheMethodHandlesTest, Open);  // for AllocDexCache
1294  ART_FRIEND_TEST(mirror::DexCacheTest, Open);  // for AllocDexCache
1295  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
1296};
1297
1298class ClassLoadCallback {
1299 public:
1300  virtual ~ClassLoadCallback() {}
1301
1302  // If set we will replace initial_class_def & initial_dex_file with the final versions. The
1303  // callback author is responsible for ensuring these are allocated in such a way they can be
1304  // cleaned up if another transformation occurs. Note that both must be set or null/unchanged on
1305  // return.
1306  // Note: the class may be temporary, in which case a following ClassPrepare event will be a
1307  //       different object. It is the listener's responsibility to handle this.
1308  // Note: This callback is rarely useful so a default implementation has been given that does
1309  //       nothing.
1310  virtual void ClassPreDefine(const char* descriptor ATTRIBUTE_UNUSED,
1311                              Handle<mirror::Class> klass ATTRIBUTE_UNUSED,
1312                              Handle<mirror::ClassLoader> class_loader ATTRIBUTE_UNUSED,
1313                              const DexFile& initial_dex_file ATTRIBUTE_UNUSED,
1314                              const DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
1315                              /*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED,
1316                              /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED)
1317      REQUIRES_SHARED(Locks::mutator_lock_) {}
1318
1319  // A class has been loaded.
1320  // Note: the class may be temporary, in which case a following ClassPrepare event will be a
1321  //       different object. It is the listener's responsibility to handle this.
1322  virtual void ClassLoad(Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1323
1324  // A class has been prepared, i.e., resolved. As the ClassLoad event might have been for a
1325  // temporary class, provide both the former and the current class.
1326  virtual void ClassPrepare(Handle<mirror::Class> temp_klass,
1327                            Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1328};
1329
1330}  // namespace art
1331
1332#endif  // ART_RUNTIME_CLASS_LINKER_H_
1333