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