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