class_linker.h revision 946593d7c593c912684022a808fd156e17852248 
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 identify 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
616  ArtMethod* AddMethodToConflictTable(mirror::Class* klass,
617                                      ArtMethod* conflict_method,
618                                      ArtMethod* interface_method,
619                                      ArtMethod* method,
620                                      bool force_new_conflict_method)
621      SHARED_REQUIRES(Locks::mutator_lock_);
622
623  struct DexCacheData {
624    // Weak root to the DexCache. Note: Do not decode this unnecessarily or else class unloading may
625    // not work properly.
626    jweak weak_root;
627    // The following two fields are caches to the DexCache's fields and here to avoid unnecessary
628    // jweak decode that triggers read barriers (and mark them alive unnecessarily and mess with
629    // class unloading.)
630    const DexFile* dex_file;
631    GcRoot<mirror::Class>* resolved_types;
632  };
633
634 private:
635  struct ClassLoaderData {
636    jweak weak_root;  // Weak root to enable class unloading.
637    ClassTable* class_table;
638    LinearAlloc* allocator;
639  };
640
641  // Ensures that the supertype of 'klass' ('supertype') is verified. Returns false and throws
642  // appropriate exceptions if verification failed hard. Returns true for successful verification or
643  // soft-failures.
644  bool AttemptSupertypeVerification(Thread* self,
645                                    Handle<mirror::Class> klass,
646                                    Handle<mirror::Class> supertype)
647      REQUIRES(!dex_lock_)
648      SHARED_REQUIRES(Locks::mutator_lock_);
649
650  static void DeleteClassLoader(Thread* self, const ClassLoaderData& data)
651      REQUIRES(Locks::classlinker_classes_lock_)
652      SHARED_REQUIRES(Locks::mutator_lock_);
653
654  void VisitClassLoaders(ClassLoaderVisitor* visitor) const
655      SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
656
657  void VisitClassesInternal(ClassVisitor* visitor)
658      SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
659
660  // Returns the number of zygote and image classes.
661  size_t NumZygoteClasses() const
662      REQUIRES(Locks::classlinker_classes_lock_)
663      SHARED_REQUIRES(Locks::mutator_lock_);
664
665  // Returns the number of non zygote nor image classes.
666  size_t NumNonZygoteClasses() const
667      REQUIRES(Locks::classlinker_classes_lock_)
668      SHARED_REQUIRES(Locks::mutator_lock_);
669
670  void FinishInit(Thread* self)
671      SHARED_REQUIRES(Locks::mutator_lock_)
672      REQUIRES(!dex_lock_, !Roles::uninterruptible_);
673
674  // For early bootstrapping by Init
675  mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size)
676      SHARED_REQUIRES(Locks::mutator_lock_)
677      REQUIRES(!Roles::uninterruptible_);
678
679  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
680  // values that are known to the ClassLinker such as
681  // kObjectArrayClass and kJavaLangString etc.
682  mirror::Class* AllocClass(Thread* self, uint32_t class_size)
683      SHARED_REQUIRES(Locks::mutator_lock_)
684      REQUIRES(!Roles::uninterruptible_);
685  mirror::DexCache* AllocDexCache(Thread* self,
686                                  const DexFile& dex_file,
687                                  LinearAlloc* linear_alloc)
688      SHARED_REQUIRES(Locks::mutator_lock_)
689      REQUIRES(!Roles::uninterruptible_);
690
691  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
692      SHARED_REQUIRES(Locks::mutator_lock_)
693      REQUIRES(!Roles::uninterruptible_);
694  mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
695      SHARED_REQUIRES(Locks::mutator_lock_)
696      REQUIRES(!Roles::uninterruptible_);
697
698  mirror::Class* CreateArrayClass(Thread* self,
699                                  const char* descriptor,
700                                  size_t hash,
701                                  Handle<mirror::ClassLoader> class_loader)
702      SHARED_REQUIRES(Locks::mutator_lock_)
703      REQUIRES(!dex_lock_, !Roles::uninterruptible_);
704
705  void AppendToBootClassPath(Thread* self, const DexFile& dex_file)
706      SHARED_REQUIRES(Locks::mutator_lock_)
707      REQUIRES(!dex_lock_);
708  void AppendToBootClassPath(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache)
709      SHARED_REQUIRES(Locks::mutator_lock_)
710      REQUIRES(!dex_lock_);
711
712  // Precomputes size needed for Class, in the case of a non-temporary class this size must be
713  // sufficient to hold all static fields.
714  uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
715                                            const DexFile::ClassDef& dex_class_def);
716
717  // Setup the classloader, class def index, type idx so that we can insert this class in the class
718  // table.
719  void SetupClass(const DexFile& dex_file,
720                  const DexFile::ClassDef& dex_class_def,
721                  Handle<mirror::Class> klass,
722                  mirror::ClassLoader* class_loader)
723      SHARED_REQUIRES(Locks::mutator_lock_);
724
725  void LoadClass(Thread* self,
726                 const DexFile& dex_file,
727                 const DexFile::ClassDef& dex_class_def,
728                 Handle<mirror::Class> klass)
729      SHARED_REQUIRES(Locks::mutator_lock_);
730  void LoadClassMembers(Thread* self,
731                        const DexFile& dex_file,
732                        const uint8_t* class_data,
733                        Handle<mirror::Class> klass,
734                        const OatFile::OatClass* oat_class)
735      SHARED_REQUIRES(Locks::mutator_lock_);
736
737  void LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtField* dst)
738      SHARED_REQUIRES(Locks::mutator_lock_);
739
740  void LoadMethod(Thread* self,
741                  const DexFile& dex_file,
742                  const ClassDataItemIterator& it,
743                  Handle<mirror::Class> klass, ArtMethod* dst)
744      SHARED_REQUIRES(Locks::mutator_lock_);
745
746  void FixupStaticTrampolines(mirror::Class* klass) SHARED_REQUIRES(Locks::mutator_lock_);
747
748  // Finds the associated oat class for a dex_file and descriptor. Returns an invalid OatClass on
749  // error and sets found to false.
750  OatFile::OatClass FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, bool* found)
751      SHARED_REQUIRES(Locks::mutator_lock_);
752
753  void RegisterDexFileLocked(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache)
754      REQUIRES(dex_lock_)
755      SHARED_REQUIRES(Locks::mutator_lock_);
756  mirror::DexCache* FindDexCacheLocked(Thread* self, const DexFile& dex_file, bool allow_failure)
757      REQUIRES(dex_lock_)
758      SHARED_REQUIRES(Locks::mutator_lock_);
759
760  bool InitializeClass(Thread* self,
761                       Handle<mirror::Class> klass,
762                       bool can_run_clinit,
763                       bool can_init_parents)
764      SHARED_REQUIRES(Locks::mutator_lock_)
765      REQUIRES(!dex_lock_);
766  bool InitializeDefaultInterfaceRecursive(Thread* self,
767                                           Handle<mirror::Class> klass,
768                                           bool can_run_clinit,
769                                           bool can_init_parents)
770      REQUIRES(!dex_lock_)
771      SHARED_REQUIRES(Locks::mutator_lock_);
772  bool WaitForInitializeClass(Handle<mirror::Class> klass,
773                              Thread* self,
774                              ObjectLock<mirror::Class>& lock);
775  bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass)
776      SHARED_REQUIRES(Locks::mutator_lock_);
777
778  bool IsSameDescriptorInDifferentClassContexts(Thread* self,
779                                                const char* descriptor,
780                                                Handle<mirror::ClassLoader> class_loader1,
781                                                Handle<mirror::ClassLoader> class_loader2)
782      SHARED_REQUIRES(Locks::mutator_lock_);
783
784  bool IsSameMethodSignatureInDifferentClassContexts(Thread* self,
785                                                     ArtMethod* method,
786                                                     mirror::Class* klass1,
787                                                     mirror::Class* klass2)
788      SHARED_REQUIRES(Locks::mutator_lock_);
789
790  bool LinkClass(Thread* self,
791                 const char* descriptor,
792                 Handle<mirror::Class> klass,
793                 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
794                 MutableHandle<mirror::Class>* h_new_class_out)
795      SHARED_REQUIRES(Locks::mutator_lock_)
796      REQUIRES(!Locks::classlinker_classes_lock_);
797
798  bool LinkSuperClass(Handle<mirror::Class> klass)
799      SHARED_REQUIRES(Locks::mutator_lock_);
800
801  bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file)
802      SHARED_REQUIRES(Locks::mutator_lock_)
803      REQUIRES(!dex_lock_);
804
805  bool LinkMethods(Thread* self,
806                   Handle<mirror::Class> klass,
807                   Handle<mirror::ObjectArray<mirror::Class>> interfaces,
808                   ArtMethod** out_imt)
809      SHARED_REQUIRES(Locks::mutator_lock_);
810
811  // Does anything needed to make sure that the compiler will not generate a direct invoke to this
812  // method. Should only be called on non-invokable methods.
813  void EnsureThrowsInvocationError(ArtMethod* method)
814      SHARED_REQUIRES(Locks::mutator_lock_);
815
816  // A wrapper class representing the result of a method translation used for linking methods and
817  // updating superclass default methods. For each method in a classes vtable there are 4 states it
818  // could be in:
819  // 1) No translation is necessary. In this case there is no MethodTranslation object for it. This
820  //    is the standard case and is true when the method is not overridable by a default method,
821  //    the class defines a concrete implementation of the method, the default method implementation
822  //    remains the same, or an abstract method stayed abstract.
823  // 2) The method must be translated to a different default method. We note this with
824  //    CreateTranslatedMethod.
825  // 3) The method must be replaced with a conflict method. This happens when a superclass
826  //    implements an interface with a default method and this class implements an unrelated
827  //    interface that also defines that default method. We note this with CreateConflictingMethod.
828  // 4) The method must be replaced with an abstract miranda method. This happens when a superclass
829  //    implements an interface with a default method and this class implements a subinterface of
830  //    the superclass's interface which declares the default method abstract. We note this with
831  //    CreateAbstractMethod.
832  //
833  // When a method translation is unnecessary (case #1), we don't put it into the
834  // default_translation maps. So an instance of MethodTranslation must be in one of #2-#4.
835  class MethodTranslation {
836   public:
837    // This slot must become a default conflict method.
838    static MethodTranslation CreateConflictingMethod() {
839      return MethodTranslation(Type::kConflict, /*translation*/nullptr);
840    }
841
842    // This slot must become an abstract method.
843    static MethodTranslation CreateAbstractMethod() {
844      return MethodTranslation(Type::kAbstract, /*translation*/nullptr);
845    }
846
847    // Use the given method as the current value for this vtable slot during translation.
848    static MethodTranslation CreateTranslatedMethod(ArtMethod* new_method) {
849      return MethodTranslation(Type::kTranslation, new_method);
850    }
851
852    // Returns true if this is a method that must become a conflict method.
853    bool IsInConflict() const {
854      return type_ == Type::kConflict;
855    }
856
857    // Returns true if this is a method that must become an abstract method.
858    bool IsAbstract() const {
859      return type_ == Type::kAbstract;
860    }
861
862    // Returns true if this is a method that must become a different method.
863    bool IsTranslation() const {
864      return type_ == Type::kTranslation;
865    }
866
867    // Get the translated version of this method.
868    ArtMethod* GetTranslation() const {
869      DCHECK(IsTranslation());
870      DCHECK(translation_ != nullptr);
871      return translation_;
872    }
873
874   private:
875    enum class Type {
876      kTranslation,
877      kConflict,
878      kAbstract,
879    };
880
881    MethodTranslation(Type type, ArtMethod* translation)
882        : translation_(translation), type_(type) {}
883
884    ArtMethod* const translation_;
885    const Type type_;
886  };
887
888  // Links the virtual methods for the given class and records any default methods that will need to
889  // be updated later.
890  //
891  // Arguments:
892  // * self - The current thread.
893  // * klass - class, whose vtable will be filled in.
894  // * default_translations - Vtable index to new method map.
895  //                          Any vtable entries that need to be updated with new default methods
896  //                          are stored into the default_translations map. The default_translations
897  //                          map is keyed on the vtable index that needs to be updated. We use this
898  //                          map because if we override a default method with another default
899  //                          method we need to update the vtable to point to the new method.
900  //                          Unfortunately since we copy the ArtMethod* we cannot just do a simple
901  //                          scan, we therefore store the vtable index's that might need to be
902  //                          updated with the method they will turn into.
903  // TODO This whole default_translations thing is very dirty. There should be a better way.
904  bool LinkVirtualMethods(
905        Thread* self,
906        Handle<mirror::Class> klass,
907        /*out*/std::unordered_map<size_t, MethodTranslation>* default_translations)
908      SHARED_REQUIRES(Locks::mutator_lock_);
909
910  // Sets up the interface lookup table (IFTable) in the correct order to allow searching for
911  // default methods.
912  bool SetupInterfaceLookupTable(Thread* self,
913                                 Handle<mirror::Class> klass,
914                                 Handle<mirror::ObjectArray<mirror::Class>> interfaces)
915      SHARED_REQUIRES(Locks::mutator_lock_);
916
917
918  enum class DefaultMethodSearchResult {
919    kDefaultFound,
920    kAbstractFound,
921    kDefaultConflict
922  };
923
924  // Find the default method implementation for 'interface_method' in 'klass', if one exists.
925  //
926  // Arguments:
927  // * self - The current thread.
928  // * target_method - The method we are trying to find a default implementation for.
929  // * klass - The class we are searching for a definition of target_method.
930  // * out_default_method - The pointer we will store the found default method to on success.
931  //
932  // Return value:
933  // * kDefaultFound - There were no conflicting method implementations found in the class while
934  //                   searching for target_method. The default method implementation is stored into
935  //                   out_default_method.
936  // * kAbstractFound - There were no conflicting method implementations found in the class while
937  //                   searching for target_method but no default implementation was found either.
938  //                   out_default_method is set to null and the method should be considered not
939  //                   implemented.
940  // * kDefaultConflict - Conflicting method implementations were found when searching for
941  //                      target_method. The value of *out_default_method is null.
942  DefaultMethodSearchResult FindDefaultMethodImplementation(
943          Thread* self,
944          ArtMethod* target_method,
945          Handle<mirror::Class> klass,
946          /*out*/ArtMethod** out_default_method) const
947      SHARED_REQUIRES(Locks::mutator_lock_);
948
949  // Sets the imt entries and fixes up the vtable for the given class by linking all the interface
950  // methods. See LinkVirtualMethods for an explanation of what default_translations is.
951  bool LinkInterfaceMethods(
952          Thread* self,
953          Handle<mirror::Class> klass,
954          const std::unordered_map<size_t, MethodTranslation>& default_translations,
955          ArtMethod** out_imt)
956      SHARED_REQUIRES(Locks::mutator_lock_);
957
958  bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size)
959      SHARED_REQUIRES(Locks::mutator_lock_);
960  bool LinkInstanceFields(Thread* self, Handle<mirror::Class> klass)
961      SHARED_REQUIRES(Locks::mutator_lock_);
962  bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size)
963      SHARED_REQUIRES(Locks::mutator_lock_);
964  void LinkCode(ArtMethod* method,
965                const OatFile::OatClass* oat_class,
966                uint32_t class_def_method_index)
967      SHARED_REQUIRES(Locks::mutator_lock_);
968  void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass)
969      SHARED_REQUIRES(Locks::mutator_lock_);
970
971  void CheckProxyConstructor(ArtMethod* constructor) const
972      SHARED_REQUIRES(Locks::mutator_lock_);
973  void CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const
974      SHARED_REQUIRES(Locks::mutator_lock_);
975
976  // For use by ImageWriter to find DexCaches for its roots
977  ReaderWriterMutex* DexLock()
978      SHARED_REQUIRES(Locks::mutator_lock_)
979      LOCK_RETURNED(dex_lock_) {
980    return &dex_lock_;
981  }
982  size_t GetDexCacheCount() SHARED_REQUIRES(Locks::mutator_lock_, dex_lock_) {
983    return dex_caches_.size();
984  }
985  const std::list<DexCacheData>& GetDexCachesData()
986      SHARED_REQUIRES(Locks::mutator_lock_, dex_lock_) {
987    return dex_caches_;
988  }
989
990  void CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out)
991      SHARED_REQUIRES(Locks::mutator_lock_);
992  void CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, ArtMethod* out)
993      SHARED_REQUIRES(Locks::mutator_lock_);
994
995  // Ensures that methods have the kAccSkipAccessChecks bit set. We use the
996  // kAccVerificationAttempted bit on the class access flags to determine whether this has been done
997  // before.
998  void EnsureSkipAccessChecksMethods(Handle<mirror::Class> c)
999      SHARED_REQUIRES(Locks::mutator_lock_);
1000
1001  mirror::Class* LookupClassFromBootImage(const char* descriptor)
1002      SHARED_REQUIRES(Locks::mutator_lock_);
1003
1004  // Register a class loader and create its class table and allocator. Should not be called if
1005  // these are already created.
1006  void RegisterClassLoader(mirror::ClassLoader* class_loader)
1007      SHARED_REQUIRES(Locks::mutator_lock_)
1008      REQUIRES(Locks::classlinker_classes_lock_);
1009
1010  // Returns null if not found.
1011  ClassTable* ClassTableForClassLoader(mirror::ClassLoader* class_loader)
1012      SHARED_REQUIRES(Locks::mutator_lock_);
1013
1014  // Insert a new class table if not found.
1015  ClassTable* InsertClassTableForClassLoader(mirror::ClassLoader* class_loader)
1016      SHARED_REQUIRES(Locks::mutator_lock_)
1017      REQUIRES(Locks::classlinker_classes_lock_);
1018
1019  // EnsureResolved is called to make sure that a class in the class_table_ has been resolved
1020  // before returning it to the caller. Its the responsibility of the thread that placed the class
1021  // in the table to make it resolved. The thread doing resolution must notify on the class' lock
1022  // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may
1023  // retire a class, the version of the class in the table is returned and this may differ from
1024  // the class passed in.
1025  mirror::Class* EnsureResolved(Thread* self, const char* descriptor, mirror::Class* klass)
1026      WARN_UNUSED
1027      SHARED_REQUIRES(Locks::mutator_lock_)
1028      REQUIRES(!dex_lock_);
1029
1030  void FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class)
1031      SHARED_REQUIRES(Locks::mutator_lock_);
1032
1033  void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
1034      SHARED_REQUIRES(Locks::mutator_lock_);
1035
1036  // Return the quick generic JNI stub for testing.
1037  const void* GetRuntimeQuickGenericJniStub() const;
1038
1039  // Throw the class initialization failure recorded when first trying to initialize the given
1040  // class.
1041  void ThrowEarlierClassFailure(mirror::Class* c, bool wrap_in_no_class_def = false)
1042      SHARED_REQUIRES(Locks::mutator_lock_)
1043      REQUIRES(!dex_lock_);
1044
1045  bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics, bool can_init_parents)
1046      SHARED_REQUIRES(Locks::mutator_lock_);
1047
1048  void UpdateClassMethods(mirror::Class* klass,
1049                          LengthPrefixedArray<ArtMethod>* new_methods)
1050      SHARED_REQUIRES(Locks::mutator_lock_)
1051      REQUIRES(!Locks::classlinker_classes_lock_);
1052
1053  // new_class_set is the set of classes that were read from the class table section in the image.
1054  // If there was no class table section, it is null.
1055  bool UpdateAppImageClassLoadersAndDexCaches(
1056      gc::space::ImageSpace* space,
1057      Handle<mirror::ClassLoader> class_loader,
1058      Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
1059      ClassTable::ClassSet* new_class_set,
1060      bool* out_forward_dex_cache_array,
1061      std::string* out_error_msg)
1062      REQUIRES(!dex_lock_)
1063      SHARED_REQUIRES(Locks::mutator_lock_);
1064
1065  // Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise.
1066  void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor)
1067      REQUIRES(!dex_lock_)
1068      SHARED_REQUIRES(Locks::mutator_lock_);
1069
1070  // Sets imt_ref appropriately for LinkInterfaceMethods.
1071  // If there is no method in the imt location of imt_ref it will store the given method there.
1072  // Otherwise it will set the conflict method which will figure out which method to use during
1073  // runtime.
1074  void SetIMTRef(ArtMethod* unimplemented_method,
1075                 ArtMethod* imt_conflict_method,
1076                 ArtMethod* current_method,
1077                 /*out*/ArtMethod** imt_ref) SHARED_REQUIRES(Locks::mutator_lock_);
1078
1079  void ConstructIMTFromIfTable(mirror::IfTable* if_table,
1080                               ArtMethod* unimplemented_method,
1081                               ArtMethod* imt_conflict_method,
1082                               mirror::Class* klass,
1083                               bool create_conflict_tables,
1084                               bool ignore_copied_methods,
1085                               ArtMethod** out_imt) SHARED_REQUIRES(Locks::mutator_lock_);
1086
1087  void FillImtFromSuperClass(Handle<mirror::Class> klass,
1088                             ArtMethod* unimplemented_method,
1089                             ArtMethod* imt_conflict_method,
1090                             ArtMethod** out_imt) SHARED_REQUIRES(Locks::mutator_lock_);
1091
1092  std::vector<const DexFile*> boot_class_path_;
1093  std::vector<std::unique_ptr<const DexFile>> boot_dex_files_;
1094
1095  mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
1096  // JNI weak globals and side data to allow dex caches to get unloaded. We lazily delete weak
1097  // globals when we register new dex files.
1098  std::list<DexCacheData> dex_caches_ GUARDED_BY(dex_lock_);
1099
1100  // This contains the class loaders which have class tables. It is populated by
1101  // InsertClassTableForClassLoader.
1102  std::list<ClassLoaderData> class_loaders_
1103      GUARDED_BY(Locks::classlinker_classes_lock_);
1104
1105  // Boot class path table. Since the class loader for this is null.
1106  ClassTable boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
1107
1108  // New class roots, only used by CMS since the GC needs to mark these in the pause.
1109  std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
1110
1111  // Do we need to search dex caches to find boot image classes?
1112  bool dex_cache_boot_image_class_lookup_required_;
1113  // Number of times we've searched dex caches for a class. After a certain number of misses we move
1114  // the classes into the class_table_ to avoid dex cache based searches.
1115  Atomic<uint32_t> failed_dex_cache_class_lookups_;
1116
1117  // Well known mirror::Class roots.
1118  GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_;
1119
1120  // The interface table used by all arrays.
1121  GcRoot<mirror::IfTable> array_iftable_;
1122
1123  // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
1124  // descriptors for the sake of performing FindClass.
1125  static constexpr size_t kFindArrayCacheSize = 16;
1126  GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize];
1127  size_t find_array_class_cache_next_victim_;
1128
1129  bool init_done_;
1130  bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
1131
1132  InternTable* intern_table_;
1133
1134  // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single
1135  // patch point within the image. TODO: make these proper relocations.
1136  const void* quick_resolution_trampoline_;
1137  const void* quick_imt_conflict_trampoline_;
1138  const void* quick_generic_jni_trampoline_;
1139  const void* quick_to_interpreter_bridge_trampoline_;
1140
1141  // Image pointer size.
1142  size_t image_pointer_size_;
1143
1144  friend class ImageDumper;  // for DexLock
1145  friend class ImageWriter;  // for GetClassRoots
1146  friend class JniCompilerTest;  // for GetRuntimeQuickGenericJniStub
1147  friend class JniInternalTest;  // for GetRuntimeQuickGenericJniStub
1148  ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName);  // for DexLock, and RegisterDexFileLocked
1149  ART_FRIEND_TEST(mirror::DexCacheTest, Open);  // for AllocDexCache
1150  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
1151};
1152
1153}  // namespace art
1154
1155#endif  // ART_RUNTIME_CLASS_LINKER_H_
1156