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