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