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