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