class_linker.h revision abadf024efdc632f663d7fb503cd277b3f65fca2 
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 private:
714  class LinkInterfaceMethodsHelper;
715
716  struct ClassLoaderData {
717    jweak weak_root;  // Weak root to enable class unloading.
718    ClassTable* class_table;
719    LinearAlloc* allocator;
720  };
721
722  // Ensures that the supertype of 'klass' ('supertype') is verified. Returns false and throws
723  // appropriate exceptions if verification failed hard. Returns true for successful verification or
724  // soft-failures.
725  bool AttemptSupertypeVerification(Thread* self,
726                                    Handle<mirror::Class> klass,
727                                    Handle<mirror::Class> supertype)
728      REQUIRES(!Locks::dex_lock_)
729      REQUIRES_SHARED(Locks::mutator_lock_);
730
731  void DeleteClassLoader(Thread* self, const ClassLoaderData& data)
732      REQUIRES_SHARED(Locks::mutator_lock_);
733
734  void VisitClassesInternal(ClassVisitor* visitor)
735      REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
736
737  // Returns the number of zygote and image classes.
738  size_t NumZygoteClasses() const
739      REQUIRES(Locks::classlinker_classes_lock_)
740      REQUIRES_SHARED(Locks::mutator_lock_);
741
742  // Returns the number of non zygote nor image classes.
743  size_t NumNonZygoteClasses() const
744      REQUIRES(Locks::classlinker_classes_lock_)
745      REQUIRES_SHARED(Locks::mutator_lock_);
746
747  void FinishInit(Thread* self)
748      REQUIRES_SHARED(Locks::mutator_lock_)
749      REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
750
751  // For early bootstrapping by Init
752  mirror::Class* AllocClass(Thread* self,
753                            ObjPtr<mirror::Class> java_lang_Class,
754                            uint32_t class_size)
755      REQUIRES_SHARED(Locks::mutator_lock_)
756      REQUIRES(!Roles::uninterruptible_);
757
758  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
759  // values that are known to the ClassLinker such as
760  // kObjectArrayClass and kJavaLangString etc.
761  mirror::Class* AllocClass(Thread* self, uint32_t class_size)
762      REQUIRES_SHARED(Locks::mutator_lock_)
763      REQUIRES(!Roles::uninterruptible_);
764
765  mirror::DexCache* AllocDexCache(ObjPtr<mirror::String>* out_location,
766                                  Thread* self,
767                                  const DexFile& dex_file)
768      REQUIRES_SHARED(Locks::mutator_lock_)
769      REQUIRES(!Roles::uninterruptible_);
770
771  // Used for tests and AppendToBootClassPath.
772  mirror::DexCache* AllocAndInitializeDexCache(Thread* self,
773                                               const DexFile& dex_file,
774                                               LinearAlloc* linear_alloc)
775      REQUIRES_SHARED(Locks::mutator_lock_)
776      REQUIRES(!Locks::dex_lock_)
777      REQUIRES(!Roles::uninterruptible_);
778
779  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
780      REQUIRES_SHARED(Locks::mutator_lock_)
781      REQUIRES(!Roles::uninterruptible_);
782  mirror::Class* InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class,
783                                          Primitive::Type type)
784      REQUIRES_SHARED(Locks::mutator_lock_)
785      REQUIRES(!Roles::uninterruptible_);
786
787  mirror::Class* CreateArrayClass(Thread* self,
788                                  const char* descriptor,
789                                  size_t hash,
790                                  Handle<mirror::ClassLoader> class_loader)
791      REQUIRES_SHARED(Locks::mutator_lock_)
792      REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
793
794  void AppendToBootClassPath(const DexFile& dex_file, ObjPtr<mirror::DexCache> dex_cache)
795      REQUIRES_SHARED(Locks::mutator_lock_)
796      REQUIRES(!Locks::dex_lock_);
797
798  // Precomputes size needed for Class, in the case of a non-temporary class this size must be
799  // sufficient to hold all static fields.
800  uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
801                                            const DexFile::ClassDef& dex_class_def);
802
803  // Setup the classloader, class def index, type idx so that we can insert this class in the class
804  // table.
805  void SetupClass(const DexFile& dex_file,
806                  const DexFile::ClassDef& dex_class_def,
807                  Handle<mirror::Class> klass,
808                  ObjPtr<mirror::ClassLoader> class_loader)
809      REQUIRES_SHARED(Locks::mutator_lock_);
810
811  void LoadClass(Thread* self,
812                 const DexFile& dex_file,
813                 const DexFile::ClassDef& dex_class_def,
814                 Handle<mirror::Class> klass)
815      REQUIRES_SHARED(Locks::mutator_lock_);
816  void LoadClassMembers(Thread* self,
817                        const DexFile& dex_file,
818                        const uint8_t* class_data,
819                        Handle<mirror::Class> klass)
820      REQUIRES_SHARED(Locks::mutator_lock_);
821
822  void LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtField* dst)
823      REQUIRES_SHARED(Locks::mutator_lock_);
824
825  void LoadMethod(const DexFile& dex_file,
826                  const ClassDataItemIterator& it,
827                  Handle<mirror::Class> klass, ArtMethod* dst)
828      REQUIRES_SHARED(Locks::mutator_lock_);
829
830  void FixupStaticTrampolines(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
831
832  // Finds a class in a Path- or DexClassLoader, loading it if necessary without using JNI. Hash
833  // function is supposed to be ComputeModifiedUtf8Hash(descriptor). Returns true if the
834  // class-loader chain could be handled, false otherwise, i.e., a non-supported class-loader
835  // was encountered while walking the parent chain (currently only BootClassLoader and
836  // PathClassLoader are supported).
837  bool FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
838                                     Thread* self,
839                                     const char* descriptor,
840                                     size_t hash,
841                                     Handle<mirror::ClassLoader> class_loader,
842                                     ObjPtr<mirror::Class>* result)
843      REQUIRES_SHARED(Locks::mutator_lock_)
844      REQUIRES(!Locks::dex_lock_);
845
846  // Finds the class in the classpath of the given class loader. It only searches the class loader
847  // dex files and does not recurse into its parent.
848  // The method checks that the provided class loader is either a PathClassLoader or a
849  // DexClassLoader.
850  // If the class is found the method returns the resolved class. Otherwise it returns null.
851  ObjPtr<mirror::Class> FindClassInBaseDexClassLoaderClassPath(
852          ScopedObjectAccessAlreadyRunnable& soa,
853          const char* descriptor,
854          size_t hash,
855          Handle<mirror::ClassLoader> class_loader)
856      REQUIRES_SHARED(Locks::mutator_lock_)
857      REQUIRES(!Locks::dex_lock_);
858
859  // Finds the class in the boot class loader.
860  // If the class is found the method returns the resolved class. Otherwise it returns null.
861  ObjPtr<mirror::Class> FindClassInBootClassLoaderClassPath(Thread* self,
862                                                            const char* descriptor,
863                                                            size_t hash)
864      REQUIRES_SHARED(Locks::mutator_lock_)
865      REQUIRES(!Locks::dex_lock_);
866
867  // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
868  // by the given 'class_loader'. Uses the provided hash for the descriptor.
869  mirror::Class* LookupClass(Thread* self,
870                             const char* descriptor,
871                             size_t hash,
872                             ObjPtr<mirror::ClassLoader> class_loader)
873      REQUIRES(!Locks::classlinker_classes_lock_)
874      REQUIRES_SHARED(Locks::mutator_lock_);
875
876  // Find a field by its field index.
877  ArtField* LookupResolvedField(uint32_t field_idx,
878                                ObjPtr<mirror::DexCache> dex_cache,
879                                ObjPtr<mirror::ClassLoader> class_loader,
880                                bool is_static)
881      REQUIRES_SHARED(Locks::mutator_lock_);
882
883  void RegisterDexFileLocked(const DexFile& dex_file,
884                             ObjPtr<mirror::DexCache> dex_cache,
885                             ObjPtr<mirror::ClassLoader> class_loader)
886      REQUIRES(Locks::dex_lock_)
887      REQUIRES_SHARED(Locks::mutator_lock_);
888  DexCacheData FindDexCacheDataLocked(const DexFile& dex_file)
889      REQUIRES(Locks::dex_lock_)
890      REQUIRES_SHARED(Locks::mutator_lock_);
891  static ObjPtr<mirror::DexCache> DecodeDexCache(Thread* self, const DexCacheData& data)
892      REQUIRES_SHARED(Locks::mutator_lock_);
893  // Called to ensure that the dex cache has been registered with the same class loader.
894  // If yes, returns the dex cache, otherwise throws InternalError and returns null.
895  ObjPtr<mirror::DexCache> EnsureSameClassLoader(Thread* self,
896                                                 ObjPtr<mirror::DexCache> dex_cache,
897                                                 const DexCacheData& data,
898                                                 ObjPtr<mirror::ClassLoader> class_loader)
899      REQUIRES(!Locks::dex_lock_)
900      REQUIRES_SHARED(Locks::mutator_lock_);
901
902  bool InitializeDefaultInterfaceRecursive(Thread* self,
903                                           Handle<mirror::Class> klass,
904                                           bool can_run_clinit,
905                                           bool can_init_parents)
906      REQUIRES(!Locks::dex_lock_)
907      REQUIRES_SHARED(Locks::mutator_lock_);
908  bool WaitForInitializeClass(Handle<mirror::Class> klass,
909                              Thread* self,
910                              ObjectLock<mirror::Class>& lock);
911
912  bool IsSameDescriptorInDifferentClassContexts(Thread* self,
913                                                const char* descriptor,
914                                                Handle<mirror::ClassLoader> class_loader1,
915                                                Handle<mirror::ClassLoader> class_loader2)
916      REQUIRES_SHARED(Locks::mutator_lock_);
917
918  bool IsSameMethodSignatureInDifferentClassContexts(Thread* self,
919                                                     ArtMethod* method,
920                                                     ObjPtr<mirror::Class> klass1,
921                                                     ObjPtr<mirror::Class> klass2)
922      REQUIRES_SHARED(Locks::mutator_lock_);
923
924  bool LinkClass(Thread* self,
925                 const char* descriptor,
926                 Handle<mirror::Class> klass,
927                 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
928                 MutableHandle<mirror::Class>* h_new_class_out)
929      REQUIRES_SHARED(Locks::mutator_lock_)
930      REQUIRES(!Locks::classlinker_classes_lock_);
931
932  bool LinkSuperClass(Handle<mirror::Class> klass)
933      REQUIRES_SHARED(Locks::mutator_lock_);
934
935  bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file)
936      REQUIRES_SHARED(Locks::mutator_lock_)
937      REQUIRES(!Locks::dex_lock_);
938
939  bool LinkMethods(Thread* self,
940                   Handle<mirror::Class> klass,
941                   Handle<mirror::ObjectArray<mirror::Class>> interfaces,
942                   bool* out_new_conflict,
943                   ArtMethod** out_imt)
944      REQUIRES_SHARED(Locks::mutator_lock_);
945
946  mirror::MethodHandle* ResolveMethodHandleForField(Thread* self,
947                                                    const DexFile::MethodHandleItem& method_handle,
948                                                    ArtMethod* referrer)
949      REQUIRES_SHARED(Locks::mutator_lock_);
950
951  mirror::MethodHandle* ResolveMethodHandleForMethod(Thread* self,
952                                                     const DexFile* const dex_file,
953                                                     const DexFile::MethodHandleItem& method_handle,
954                                                     ArtMethod* referrer)
955      REQUIRES_SHARED(Locks::mutator_lock_);
956
957  // A wrapper class representing the result of a method translation used for linking methods and
958  // updating superclass default methods. For each method in a classes vtable there are 4 states it
959  // could be in:
960  // 1) No translation is necessary. In this case there is no MethodTranslation object for it. This
961  //    is the standard case and is true when the method is not overridable by a default method,
962  //    the class defines a concrete implementation of the method, the default method implementation
963  //    remains the same, or an abstract method stayed abstract.
964  // 2) The method must be translated to a different default method. We note this with
965  //    CreateTranslatedMethod.
966  // 3) The method must be replaced with a conflict method. This happens when a superclass
967  //    implements an interface with a default method and this class implements an unrelated
968  //    interface that also defines that default method. We note this with CreateConflictingMethod.
969  // 4) The method must be replaced with an abstract miranda method. This happens when a superclass
970  //    implements an interface with a default method and this class implements a subinterface of
971  //    the superclass's interface which declares the default method abstract. We note this with
972  //    CreateAbstractMethod.
973  //
974  // When a method translation is unnecessary (case #1), we don't put it into the
975  // default_translation maps. So an instance of MethodTranslation must be in one of #2-#4.
976  class MethodTranslation {
977   public:
978    // This slot must become a default conflict method.
979    static MethodTranslation CreateConflictingMethod() {
980      return MethodTranslation(Type::kConflict, /*translation*/nullptr);
981    }
982
983    // This slot must become an abstract method.
984    static MethodTranslation CreateAbstractMethod() {
985      return MethodTranslation(Type::kAbstract, /*translation*/nullptr);
986    }
987
988    // Use the given method as the current value for this vtable slot during translation.
989    static MethodTranslation CreateTranslatedMethod(ArtMethod* new_method) {
990      return MethodTranslation(Type::kTranslation, new_method);
991    }
992
993    // Returns true if this is a method that must become a conflict method.
994    bool IsInConflict() const {
995      return type_ == Type::kConflict;
996    }
997
998    // Returns true if this is a method that must become an abstract method.
999    bool IsAbstract() const {
1000      return type_ == Type::kAbstract;
1001    }
1002
1003    // Returns true if this is a method that must become a different method.
1004    bool IsTranslation() const {
1005      return type_ == Type::kTranslation;
1006    }
1007
1008    // Get the translated version of this method.
1009    ArtMethod* GetTranslation() const {
1010      DCHECK(IsTranslation());
1011      DCHECK(translation_ != nullptr);
1012      return translation_;
1013    }
1014
1015   private:
1016    enum class Type {
1017      kTranslation,
1018      kConflict,
1019      kAbstract,
1020    };
1021
1022    MethodTranslation(Type type, ArtMethod* translation)
1023        : translation_(translation), type_(type) {}
1024
1025    ArtMethod* const translation_;
1026    const Type type_;
1027  };
1028
1029  // Links the virtual methods for the given class and records any default methods that will need to
1030  // be updated later.
1031  //
1032  // Arguments:
1033  // * self - The current thread.
1034  // * klass - class, whose vtable will be filled in.
1035  // * default_translations - Vtable index to new method map.
1036  //                          Any vtable entries that need to be updated with new default methods
1037  //                          are stored into the default_translations map. The default_translations
1038  //                          map is keyed on the vtable index that needs to be updated. We use this
1039  //                          map because if we override a default method with another default
1040  //                          method we need to update the vtable to point to the new method.
1041  //                          Unfortunately since we copy the ArtMethod* we cannot just do a simple
1042  //                          scan, we therefore store the vtable index's that might need to be
1043  //                          updated with the method they will turn into.
1044  // TODO This whole default_translations thing is very dirty. There should be a better way.
1045  bool LinkVirtualMethods(
1046        Thread* self,
1047        Handle<mirror::Class> klass,
1048        /*out*/std::unordered_map<size_t, MethodTranslation>* default_translations)
1049      REQUIRES_SHARED(Locks::mutator_lock_);
1050
1051  // Sets up the interface lookup table (IFTable) in the correct order to allow searching for
1052  // default methods.
1053  bool SetupInterfaceLookupTable(Thread* self,
1054                                 Handle<mirror::Class> klass,
1055                                 Handle<mirror::ObjectArray<mirror::Class>> interfaces)
1056      REQUIRES_SHARED(Locks::mutator_lock_);
1057
1058
1059  enum class DefaultMethodSearchResult {
1060    kDefaultFound,
1061    kAbstractFound,
1062    kDefaultConflict
1063  };
1064
1065  // Find the default method implementation for 'interface_method' in 'klass', if one exists.
1066  //
1067  // Arguments:
1068  // * self - The current thread.
1069  // * target_method - The method we are trying to find a default implementation for.
1070  // * klass - The class we are searching for a definition of target_method.
1071  // * out_default_method - The pointer we will store the found default method to on success.
1072  //
1073  // Return value:
1074  // * kDefaultFound - There were no conflicting method implementations found in the class while
1075  //                   searching for target_method. The default method implementation is stored into
1076  //                   out_default_method.
1077  // * kAbstractFound - There were no conflicting method implementations found in the class while
1078  //                   searching for target_method but no default implementation was found either.
1079  //                   out_default_method is set to null and the method should be considered not
1080  //                   implemented.
1081  // * kDefaultConflict - Conflicting method implementations were found when searching for
1082  //                      target_method. The value of *out_default_method is null.
1083  DefaultMethodSearchResult FindDefaultMethodImplementation(
1084      Thread* self,
1085      ArtMethod* target_method,
1086      Handle<mirror::Class> klass,
1087      /*out*/ArtMethod** out_default_method) const
1088      REQUIRES_SHARED(Locks::mutator_lock_);
1089
1090  // Sets the imt entries and fixes up the vtable for the given class by linking all the interface
1091  // methods. See LinkVirtualMethods for an explanation of what default_translations is.
1092  bool LinkInterfaceMethods(
1093      Thread* self,
1094      Handle<mirror::Class> klass,
1095      const std::unordered_map<size_t, MethodTranslation>& default_translations,
1096      bool* out_new_conflict,
1097      ArtMethod** out_imt)
1098      REQUIRES_SHARED(Locks::mutator_lock_);
1099
1100  bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size)
1101      REQUIRES_SHARED(Locks::mutator_lock_);
1102  bool LinkInstanceFields(Thread* self, Handle<mirror::Class> klass)
1103      REQUIRES_SHARED(Locks::mutator_lock_);
1104  bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size)
1105      REQUIRES_SHARED(Locks::mutator_lock_);
1106  void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass)
1107      REQUIRES_SHARED(Locks::mutator_lock_);
1108
1109  void CheckProxyConstructor(ArtMethod* constructor) const
1110      REQUIRES_SHARED(Locks::mutator_lock_);
1111  void CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const
1112      REQUIRES_SHARED(Locks::mutator_lock_);
1113
1114  size_t GetDexCacheCount() REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) {
1115    return dex_caches_.size();
1116  }
1117  const std::list<DexCacheData>& GetDexCachesData()
1118      REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) {
1119    return dex_caches_;
1120  }
1121
1122  void CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out)
1123      REQUIRES_SHARED(Locks::mutator_lock_);
1124  void CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, ArtMethod* out)
1125      REQUIRES_SHARED(Locks::mutator_lock_);
1126
1127  // Register a class loader and create its class table and allocator. Should not be called if
1128  // these are already created.
1129  void RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
1130      REQUIRES_SHARED(Locks::mutator_lock_)
1131      REQUIRES(Locks::classlinker_classes_lock_);
1132
1133  // Insert a new class table if not found.
1134  ClassTable* InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
1135      REQUIRES_SHARED(Locks::mutator_lock_)
1136      REQUIRES(Locks::classlinker_classes_lock_);
1137
1138  // EnsureResolved is called to make sure that a class in the class_table_ has been resolved
1139  // before returning it to the caller. Its the responsibility of the thread that placed the class
1140  // in the table to make it resolved. The thread doing resolution must notify on the class' lock
1141  // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may
1142  // retire a class, the version of the class in the table is returned and this may differ from
1143  // the class passed in.
1144  mirror::Class* EnsureResolved(Thread* self, const char* descriptor, ObjPtr<mirror::Class> klass)
1145      WARN_UNUSED
1146      REQUIRES_SHARED(Locks::mutator_lock_)
1147      REQUIRES(!Locks::dex_lock_);
1148
1149  void FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class,
1150                                    ObjPtr<mirror::Class> new_class)
1151      REQUIRES_SHARED(Locks::mutator_lock_);
1152
1153  void SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass)
1154      REQUIRES_SHARED(Locks::mutator_lock_);
1155
1156  // Return the quick generic JNI stub for testing.
1157  const void* GetRuntimeQuickGenericJniStub() const;
1158
1159  bool CanWeInitializeClass(ObjPtr<mirror::Class> klass,
1160                            bool can_init_statics,
1161                            bool can_init_parents)
1162      REQUIRES_SHARED(Locks::mutator_lock_);
1163
1164  void UpdateClassMethods(ObjPtr<mirror::Class> klass,
1165                          LengthPrefixedArray<ArtMethod>* new_methods)
1166      REQUIRES_SHARED(Locks::mutator_lock_)
1167      REQUIRES(!Locks::classlinker_classes_lock_);
1168
1169  // Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise.
1170  void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor)
1171      REQUIRES(!Locks::dex_lock_)
1172      REQUIRES_SHARED(Locks::mutator_lock_);
1173
1174  // Allocate method arrays for interfaces.
1175  bool AllocateIfTableMethodArrays(Thread* self,
1176                                   Handle<mirror::Class> klass,
1177                                   Handle<mirror::IfTable> iftable)
1178      REQUIRES_SHARED(Locks::mutator_lock_);
1179
1180  // Sets imt_ref appropriately for LinkInterfaceMethods.
1181  // If there is no method in the imt location of imt_ref it will store the given method there.
1182  // Otherwise it will set the conflict method which will figure out which method to use during
1183  // runtime.
1184  void SetIMTRef(ArtMethod* unimplemented_method,
1185                 ArtMethod* imt_conflict_method,
1186                 ArtMethod* current_method,
1187                 /*out*/bool* new_conflict,
1188                 /*out*/ArtMethod** imt_ref) REQUIRES_SHARED(Locks::mutator_lock_);
1189
1190  void FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table,
1191                          ArtMethod* unimplemented_method,
1192                          ArtMethod* imt_conflict_method,
1193                          ObjPtr<mirror::Class> klass,
1194                          bool create_conflict_tables,
1195                          bool ignore_copied_methods,
1196                          /*out*/bool* new_conflict,
1197                          /*out*/ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_);
1198
1199  void FillImtFromSuperClass(Handle<mirror::Class> klass,
1200                             ArtMethod* unimplemented_method,
1201                             ArtMethod* imt_conflict_method,
1202                             bool* new_conflict,
1203                             ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_);
1204
1205  // Check invoke type against the referenced class. Throws IncompatibleClassChangeError
1206  // (if `kThrowOnError`) and returns true on mismatch (kInterface on a non-interface class,
1207  // kVirtual on interface, kDefault on interface for dex files not supporting default methods),
1208  // otherwise returns false.
1209  template <bool kThrowOnError, typename ClassGetter>
1210  static bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache,
1211                                       InvokeType type,
1212                                       ClassGetter class_getter)
1213      REQUIRES_SHARED(Locks::mutator_lock_);
1214  // Helper that feeds the above function with `ClassGetter` doing `LookupResolvedType()`.
1215  template <bool kThrow>
1216  bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache,
1217                                InvokeType type,
1218                                uint32_t method_idx,
1219                                ObjPtr<mirror::ClassLoader> class_loader)
1220      REQUIRES_SHARED(Locks::mutator_lock_);
1221
1222  std::vector<const DexFile*> boot_class_path_;
1223  std::vector<std::unique_ptr<const DexFile>> boot_dex_files_;
1224
1225  // JNI weak globals and side data to allow dex caches to get unloaded. We lazily delete weak
1226  // globals when we register new dex files.
1227  std::list<DexCacheData> dex_caches_ GUARDED_BY(Locks::dex_lock_);
1228
1229  // This contains the class loaders which have class tables. It is populated by
1230  // InsertClassTableForClassLoader.
1231  std::list<ClassLoaderData> class_loaders_
1232      GUARDED_BY(Locks::classlinker_classes_lock_);
1233
1234  // Boot class path table. Since the class loader for this is null.
1235  std::unique_ptr<ClassTable> boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
1236
1237  // New class roots, only used by CMS since the GC needs to mark these in the pause.
1238  std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
1239
1240  // Boot image oat files with new .bss GC roots to be visited in the pause by CMS.
1241  std::vector<const OatFile*> new_bss_roots_boot_oat_files_
1242      GUARDED_BY(Locks::classlinker_classes_lock_);
1243
1244  // Number of times we've searched dex caches for a class. After a certain number of misses we move
1245  // the classes into the class_table_ to avoid dex cache based searches.
1246  Atomic<uint32_t> failed_dex_cache_class_lookups_;
1247
1248  // Well known mirror::Class roots.
1249  GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_;
1250
1251  // The interface table used by all arrays.
1252  GcRoot<mirror::IfTable> array_iftable_;
1253
1254  // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
1255  // descriptors for the sake of performing FindClass.
1256  static constexpr size_t kFindArrayCacheSize = 16;
1257  GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize];
1258  size_t find_array_class_cache_next_victim_;
1259
1260  bool init_done_;
1261  bool log_new_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
1262
1263  InternTable* intern_table_;
1264
1265  // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single
1266  // patch point within the image. TODO: make these proper relocations.
1267  const void* quick_resolution_trampoline_;
1268  const void* quick_imt_conflict_trampoline_;
1269  const void* quick_generic_jni_trampoline_;
1270  const void* quick_to_interpreter_bridge_trampoline_;
1271
1272  // Image pointer size.
1273  PointerSize image_pointer_size_;
1274
1275  std::unique_ptr<ClassHierarchyAnalysis> cha_;
1276
1277  class FindVirtualMethodHolderVisitor;
1278
1279  friend class AppImageClassLoadersAndDexCachesHelper;
1280  friend struct CompilationHelper;  // For Compile in ImageTest.
1281  friend class ImageDumper;  // for DexLock
1282  friend class ImageWriter;  // for GetClassRoots
1283  friend class JniCompilerTest;  // for GetRuntimeQuickGenericJniStub
1284  friend class JniInternalTest;  // for GetRuntimeQuickGenericJniStub
1285  friend class VMClassLoader;  // for LookupClass and FindClassInBaseDexClassLoader.
1286  ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName);  // for DexLock, and RegisterDexFileLocked
1287  ART_FRIEND_TEST(mirror::DexCacheMethodHandlesTest, Open);  // for AllocDexCache
1288  ART_FRIEND_TEST(mirror::DexCacheTest, Open);  // for AllocDexCache
1289  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
1290};
1291
1292class ClassLoadCallback {
1293 public:
1294  virtual ~ClassLoadCallback() {}
1295
1296  // If set we will replace initial_class_def & initial_dex_file with the final versions. The
1297  // callback author is responsible for ensuring these are allocated in such a way they can be
1298  // cleaned up if another transformation occurs. Note that both must be set or null/unchanged on
1299  // return.
1300  // Note: the class may be temporary, in which case a following ClassPrepare event will be a
1301  //       different object. It is the listener's responsibility to handle this.
1302  // Note: This callback is rarely useful so a default implementation has been given that does
1303  //       nothing.
1304  virtual void ClassPreDefine(const char* descriptor ATTRIBUTE_UNUSED,
1305                              Handle<mirror::Class> klass ATTRIBUTE_UNUSED,
1306                              Handle<mirror::ClassLoader> class_loader ATTRIBUTE_UNUSED,
1307                              const DexFile& initial_dex_file ATTRIBUTE_UNUSED,
1308                              const DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
1309                              /*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED,
1310                              /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED)
1311      REQUIRES_SHARED(Locks::mutator_lock_) {}
1312
1313  // A class has been loaded.
1314  // Note: the class may be temporary, in which case a following ClassPrepare event will be a
1315  //       different object. It is the listener's responsibility to handle this.
1316  virtual void ClassLoad(Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1317
1318  // A class has been prepared, i.e., resolved. As the ClassLoad event might have been for a
1319  // temporary class, provide both the former and the current class.
1320  virtual void ClassPrepare(Handle<mirror::Class> temp_klass,
1321                            Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1322};
1323
1324}  // namespace art
1325
1326#endif  // ART_RUNTIME_CLASS_LINKER_H_
1327