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