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