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