class_linker.h revision c0542af3e2170143ba40d89136e284997e16bf64 
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 <deque>
21#include <string>
22#include <utility>
23#include <vector>
24
25#include "base/allocator.h"
26#include "base/macros.h"
27#include "base/mutex.h"
28#include "dex_file.h"
29#include "gc_root.h"
30#include "gtest/gtest.h"
31#include "jni.h"
32#include "oat_file.h"
33#include "object_callbacks.h"
34
35namespace art {
36
37namespace gc {
38namespace space {
39  class ImageSpace;
40}  // namespace space
41}  // namespace gc
42namespace mirror {
43  class ClassLoader;
44  class DexCache;
45  class DexCacheTest_Open_Test;
46  class IfTable;
47  template<class T> class ObjectArray;
48  class StackTraceElement;
49}  // namespace mirror
50
51template<class T> class ConstHandle;
52class InternTable;
53template<class T> class ObjectLock;
54class ScopedObjectAccessAlreadyRunnable;
55template<class T> class Handle;
56
57typedef bool (ClassVisitor)(mirror::Class* c, void* arg);
58
59enum VisitRootFlags : uint8_t;
60
61class ClassLinker {
62 public:
63  explicit ClassLinker(InternTable* intern_table);
64  ~ClassLinker();
65
66  // Initialize class linker by bootstraping from dex files.
67  void InitWithoutImage(const std::vector<const DexFile*>& boot_class_path)
68      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
69
70  // Initialize class linker from one or more images.
71  void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
72
73  // Finds a class by its descriptor, loading it if necessary.
74  // If class_loader is null, searches boot_class_path_.
75  mirror::Class* FindClass(Thread* self, const char* descriptor,
76                           ConstHandle<mirror::ClassLoader> class_loader)
77      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
78
79  // Finds a class by its descriptor using the "system" class loader, ie by searching the
80  // boot_class_path_.
81  mirror::Class* FindSystemClass(Thread* self, const char* descriptor)
82      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
83
84  // Finds the array class given for the element class.
85  mirror::Class* FindArrayClass(Thread* self, mirror::Class** element_class)
86      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
87
88  // Returns true if the class linker is initialized.
89  bool IsInitialized() const;
90
91  // Define a new a class based on a ClassDef from a DexFile
92  mirror::Class* DefineClass(const char* descriptor,
93                             ConstHandle<mirror::ClassLoader> class_loader,
94                             const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
95      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
96
97  // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
98  // by the given 'class_loader'.
99  mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader)
100      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
101      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
102
103  // Finds all the classes with the given descriptor, regardless of ClassLoader.
104  void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes)
105      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
106      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
107
108  mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
109
110  // General class unloading is not supported, this is used to prune
111  // unwanted classes during image writing.
112  bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader)
113      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
114      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
115
116  void DumpAllClasses(int flags)
117      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
118      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
119
120  void DumpForSigQuit(std::ostream& os)
121      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
122      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
123
124  size_t NumLoadedClasses()
125      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
126      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
127
128  // Resolve a String with the given index from the DexFile, storing the
129  // result in the DexCache. The referrer is used to identify the
130  // target DexCache and ClassLoader to use for resolution.
131  mirror::String* ResolveString(uint32_t string_idx, mirror::ArtMethod* referrer)
132      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
133
134  // Resolve a String with the given index from the DexFile, storing the
135  // result in the DexCache.
136  mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx,
137                                ConstHandle<mirror::DexCache> dex_cache)
138      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
139
140  // Resolve a Type with the given index from the DexFile, storing the
141  // result in the DexCache. The referrer is used to identity the
142  // target DexCache and ClassLoader to use for resolution.
143  mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, mirror::Class* referrer)
144      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
145
146  // Resolve a Type with the given index from the DexFile, storing the
147  // result in the DexCache. The referrer is used to identify the
148  // target DexCache and ClassLoader to use for resolution.
149  mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtMethod* referrer)
150      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
151
152  mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtField* referrer)
153      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
154
155  // Resolve a type with the given ID from the DexFile, storing the
156  // result in DexCache. The ClassLoader is used to search for the
157  // type, since it may be referenced from but not contained within
158  // the given DexFile.
159  mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx,
160                             ConstHandle<mirror::DexCache> dex_cache,
161                             ConstHandle<mirror::ClassLoader> class_loader)
162      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
163
164  // Resolve a method with a given ID from the DexFile, storing the
165  // result in DexCache. The ClassLinker and ClassLoader are used as
166  // in ResolveType. What is unique is the method type argument which
167  // is used to determine if this method is a direct, static, or
168  // virtual method.
169  mirror::ArtMethod* ResolveMethod(const DexFile& dex_file,
170                                   uint32_t method_idx,
171                                   ConstHandle<mirror::DexCache> dex_cache,
172                                   ConstHandle<mirror::ClassLoader> class_loader,
173                                   ConstHandle<mirror::ArtMethod> referrer,
174                                   InvokeType type)
175      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
176
177  mirror::ArtMethod* GetResolvedMethod(uint32_t method_idx, mirror::ArtMethod* referrer,
178                                       InvokeType type)
179      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
180  mirror::ArtMethod* ResolveMethod(Thread* self, uint32_t method_idx, mirror::ArtMethod** referrer,
181                                   InvokeType type)
182      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
183
184  mirror::ArtField* GetResolvedField(uint32_t field_idx, mirror::Class* field_declaring_class)
185      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
186  mirror::ArtField* ResolveField(uint32_t field_idx, mirror::ArtMethod* referrer,
187                                 bool is_static)
188      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
189
190  // Resolve a field with a given ID from the DexFile, storing the
191  // result in DexCache. The ClassLinker and ClassLoader are used as
192  // in ResolveType. What is unique is the is_static argument which is
193  // used to determine if we are resolving a static or non-static
194  // field.
195  mirror::ArtField* ResolveField(const DexFile& dex_file,
196                                 uint32_t field_idx,
197                                 ConstHandle<mirror::DexCache> dex_cache,
198                                 ConstHandle<mirror::ClassLoader> class_loader,
199                                 bool is_static)
200      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
201
202  // Resolve a field with a given ID from the DexFile, storing the
203  // result in DexCache. The ClassLinker and ClassLoader are used as
204  // in ResolveType. No is_static argument is provided so that Java
205  // field resolution semantics are followed.
206  mirror::ArtField* ResolveFieldJLS(const DexFile& dex_file, uint32_t field_idx,
207                                    ConstHandle<mirror::DexCache> dex_cache,
208                                    ConstHandle<mirror::ClassLoader> class_loader)
209      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
210
211  // Get shorty from method index without resolution. Used to do handlerization.
212  const char* MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer, uint32_t* length)
213      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
214
215  // Returns true on success, false if there's an exception pending.
216  // can_run_clinit=false allows the compiler to attempt to init a class,
217  // given the restriction that no <clinit> execution is possible.
218  bool EnsureInitialized(ConstHandle<mirror::Class> c, bool can_init_fields, bool can_init_parents)
219      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
220
221  // Initializes classes that have instances in the image but that have
222  // <clinit> methods so they could not be initialized by the compiler.
223  void RunRootClinits() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
224
225  void RegisterDexFile(const DexFile& dex_file)
226      LOCKS_EXCLUDED(dex_lock_)
227      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
228  void RegisterDexFile(const DexFile& dex_file, ConstHandle<mirror::DexCache> dex_cache)
229      LOCKS_EXCLUDED(dex_lock_)
230      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
231
232  const OatFile* RegisterOatFile(const OatFile* oat_file)
233      LOCKS_EXCLUDED(dex_lock_);
234
235  const std::vector<const DexFile*>& GetBootClassPath() {
236    return boot_class_path_;
237  }
238
239  void VisitClasses(ClassVisitor* visitor, void* arg)
240      LOCKS_EXCLUDED(dex_lock_)
241      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
242  // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_
243  // when calling the visitor.
244  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg)
245      LOCKS_EXCLUDED(dex_lock_)
246      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
247
248  void VisitClassRoots(RootCallback* callback, void* arg, VisitRootFlags flags)
249      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
250      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
251  void VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags)
252      LOCKS_EXCLUDED(dex_lock_)
253      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
254
255  mirror::DexCache* FindDexCache(const DexFile& dex_file)
256      LOCKS_EXCLUDED(dex_lock_)
257      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
258  bool IsDexFileRegistered(const DexFile& dex_file)
259      LOCKS_EXCLUDED(dex_lock_) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
260  void FixupDexCaches(mirror::ArtMethod* resolution_method)
261      LOCKS_EXCLUDED(dex_lock_)
262      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
263
264  // Generate an oat file from a dex file
265  bool GenerateOatFile(const char* dex_filename,
266                       int oat_fd,
267                       const char* oat_cache_filename,
268                       std::string* error_msg)
269      LOCKS_EXCLUDED(Locks::mutator_lock_);
270
271  // Find or create the oat file holding dex_location. Then load all corresponding dex files
272  // (if multidex) into the given vector.
273  bool OpenDexFilesFromOat(const char* dex_location, const char* oat_location,
274                           std::vector<std::string>* error_msgs,
275                           std::vector<const DexFile*>* dex_files)
276      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
277
278  // Returns true if the given oat file has the same image checksum as the image it is paired with.
279  static bool VerifyOatImageChecksum(const OatFile* oat_file, const InstructionSet instruction_set);
280  // Returns true if the oat file checksums match with the image and the offsets are such that it
281  // could be loaded with it.
282  static bool VerifyOatChecksums(const OatFile* oat_file, const InstructionSet instruction_set,
283                                 std::string* error_msg);
284  // Returns true if oat file contains the dex file with the given location and checksum.
285  static bool VerifyOatAndDexFileChecksums(const OatFile* oat_file,
286                                           const char* dex_location,
287                                           uint32_t dex_location_checksum,
288                                           InstructionSet instruction_set,
289                                           std::string* error_msg);
290
291  // Allocate an instance of a java.lang.Object.
292  mirror::Object* AllocObject(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
293
294  // TODO: replace this with multiple methods that allocate the correct managed type.
295  template <class T>
296  mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
297      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
298
299  mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length)
300      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
301
302  mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
303      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
304
305  mirror::ObjectArray<mirror::ArtMethod>* AllocArtMethodArray(Thread* self, size_t length)
306      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
307
308  mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
309      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
310
311  mirror::ObjectArray<mirror::ArtField>* AllocArtFieldArray(Thread* self, size_t length)
312      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
313
314  mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
315                                                                              size_t length)
316      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
317
318  void VerifyClass(ConstHandle<mirror::Class> klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
319  bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
320                               mirror::Class::Status& oat_file_class_status)
321      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
322  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file,
323                                         ConstHandle<mirror::Class> klass)
324      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
325  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::ArtMethod* klass)
326      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
327
328  mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name,
329                                  jobjectArray interfaces, jobject loader, jobjectArray methods,
330                                  jobjectArray throws)
331      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
332  std::string GetDescriptorForProxy(mirror::Class* proxy_class)
333      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
334  mirror::ArtMethod* FindMethodForProxy(mirror::Class* proxy_class,
335                                        mirror::ArtMethod* proxy_method)
336      LOCKS_EXCLUDED(dex_lock_)
337      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
338
339  // Get the oat code for a method when its class isn't yet initialized
340  const void* GetQuickOatCodeFor(mirror::ArtMethod* method)
341      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
342  const void* GetPortableOatCodeFor(mirror::ArtMethod* method, bool* have_portable_code)
343      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
344
345  // Get the oat code for a method from a method index.
346  const void* GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
347      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
348  const void* GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
349      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
350
351  // Get compiled code for a method, return null if no code
352  // exists. This is unlike Get..OatCodeFor which will return a bridge
353  // or interpreter entrypoint.
354  const void* GetOatMethodQuickCodeFor(mirror::ArtMethod* method)
355      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
356  const void* GetOatMethodPortableCodeFor(mirror::ArtMethod* method)
357      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
358
359  pid_t GetClassesLockOwner();  // For SignalCatcher.
360  pid_t GetDexLockOwner();  // For SignalCatcher.
361
362  const void* GetPortableResolutionTrampoline() const {
363    return portable_resolution_trampoline_;
364  }
365
366  const void* GetQuickGenericJniTrampoline() const {
367    return quick_generic_jni_trampoline_;
368  }
369
370  const void* GetQuickResolutionTrampoline() const {
371    return quick_resolution_trampoline_;
372  }
373
374  const void* GetPortableImtConflictTrampoline() const {
375    return portable_imt_conflict_trampoline_;
376  }
377
378  const void* GetQuickImtConflictTrampoline() const {
379    return quick_imt_conflict_trampoline_;
380  }
381
382  const void* GetQuickToInterpreterBridgeTrampoline() const {
383    return quick_to_interpreter_bridge_trampoline_;
384  }
385
386  InternTable* GetInternTable() const {
387    return intern_table_;
388  }
389
390  // Attempts to insert a class into a class table.  Returns NULL if
391  // the class was inserted, otherwise returns an existing class with
392  // the same descriptor and ClassLoader.
393  mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash)
394      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
395      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
396
397  // Special code to allocate an art method, use this instead of class->AllocObject.
398  mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
399
400  mirror::ObjectArray<mirror::Class>* GetClassRoots() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
401    mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
402    DCHECK(class_roots != NULL);
403    return class_roots;
404  }
405
406 private:
407  const OatFile::OatMethod FindOatMethodFor(mirror::ArtMethod* method, bool* found)
408      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
409
410  OatFile& GetImageOatFile(gc::space::ImageSpace* space)
411      LOCKS_EXCLUDED(dex_lock_)
412      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
413
414  void FinishInit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
415
416  // For early bootstrapping by Init
417  mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size)
418      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
419
420  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
421  // values that are known to the ClassLinker such as
422  // kObjectArrayClass and kJavaLangString etc.
423  mirror::Class* AllocClass(Thread* self, uint32_t class_size)
424      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
425  mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
426      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
427  mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
428
429  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
430      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
431  mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
432      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
433
434
435  mirror::Class* CreateArrayClass(Thread* self, const char* descriptor,
436                                  ConstHandle<mirror::ClassLoader> class_loader)
437      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
438
439  void AppendToBootClassPath(const DexFile& dex_file)
440      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
441  void AppendToBootClassPath(const DexFile& dex_file, ConstHandle<mirror::DexCache> dex_cache)
442      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
443
444  // Precomputes size needed for Class, in the case of a non-temporary class this size must be
445  // sufficient to hold all static fields.
446  uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
447                                            const DexFile::ClassDef& dex_class_def);
448
449  void LoadClass(const DexFile& dex_file,
450                 const DexFile::ClassDef& dex_class_def,
451                 ConstHandle<mirror::Class> klass,
452                 mirror::ClassLoader* class_loader)
453      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
454  void LoadClassMembers(const DexFile& dex_file,
455                        const byte* class_data,
456                        ConstHandle<mirror::Class> klass,
457                        mirror::ClassLoader* class_loader,
458                        const OatFile::OatClass* oat_class)
459      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
460
461  void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
462                 ConstHandle<mirror::Class> klass, ConstHandle<mirror::ArtField> dst)
463      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
464
465  mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file,
466                                const ClassDataItemIterator& dex_method,
467                                ConstHandle<mirror::Class> klass)
468      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
469
470  void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
471
472  // Finds the associated oat class for a dex_file and descriptor. Returns an invalid OatClass on
473  // error and sets found to false.
474  OatFile::OatClass FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, bool* found)
475      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
476
477  void RegisterDexFileLocked(const DexFile& dex_file, ConstHandle<mirror::DexCache> dex_cache)
478      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
479      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
480  bool IsDexFileRegisteredLocked(const DexFile& dex_file)
481      SHARED_LOCKS_REQUIRED(dex_lock_, Locks::mutator_lock_);
482
483  bool InitializeClass(ConstHandle<mirror::Class> klass, bool can_run_clinit,
484                       bool can_init_parents)
485      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
486  bool WaitForInitializeClass(ConstHandle<mirror::Class> klass, Thread* self,
487                              ObjectLock<mirror::Class>& lock);
488  bool ValidateSuperClassDescriptors(ConstHandle<mirror::Class> klass)
489      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
490
491  bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor,
492                                                ConstHandle<mirror::ClassLoader> class_loader1,
493                                                ConstHandle<mirror::ClassLoader> class_loader2)
494      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
495
496  bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, mirror::ArtMethod* method,
497                                                     mirror::Class* klass1,
498                                                     mirror::Class* klass2)
499      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
500
501  bool LinkClass(Thread* self, const char* descriptor, ConstHandle<mirror::Class> klass,
502                 ConstHandle<mirror::ObjectArray<mirror::Class>> interfaces,
503                 mirror::Class** new_class)
504      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
505
506  bool LinkSuperClass(ConstHandle<mirror::Class> klass)
507      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
508
509  bool LoadSuperAndInterfaces(ConstHandle<mirror::Class> klass, const DexFile& dex_file)
510      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
511
512  bool LinkMethods(Thread* self, ConstHandle<mirror::Class> klass,
513                   ConstHandle<mirror::ObjectArray<mirror::Class>> interfaces)
514      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
515
516  bool LinkVirtualMethods(Thread* self, ConstHandle<mirror::Class> klass)
517      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
518
519  bool LinkInterfaceMethods(ConstHandle<mirror::Class> klass,
520                            ConstHandle<mirror::ObjectArray<mirror::Class>> interfaces)
521      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
522
523  bool LinkStaticFields(ConstHandle<mirror::Class> klass, size_t* class_size)
524      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
525  bool LinkInstanceFields(ConstHandle<mirror::Class> klass)
526      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
527  bool LinkFields(ConstHandle<mirror::Class> klass, bool is_static, size_t* class_size)
528      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
529  void LinkCode(ConstHandle<mirror::ArtMethod> method, const OatFile::OatClass* oat_class,
530                const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index)
531      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
532  void CreateReferenceInstanceOffsets(ConstHandle<mirror::Class> klass)
533      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
534  void CreateReferenceStaticOffsets(ConstHandle<mirror::Class> klass)
535      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
536  void CreateReferenceOffsets(ConstHandle<mirror::Class> klass, bool is_static,
537                              uint32_t reference_offsets)
538      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
539
540  // For use by ImageWriter to find DexCaches for its roots
541  ReaderWriterMutex* DexLock()
542      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCK_RETURNED(dex_lock_) {
543    return &dex_lock_;
544  }
545  size_t GetDexCacheCount() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_) {
546    return dex_caches_.size();
547  }
548  mirror::DexCache* GetDexCache(size_t idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_);
549
550  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
551      LOCKS_EXCLUDED(dex_lock_)
552      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
553
554  // Find an opened oat file that contains dex_location. If oat_location is not nullptr, the file
555  // must have that location, else any oat location is accepted.
556  const OatFile* FindOpenedOatFile(const char* oat_location, const char* dex_location,
557                                   const uint32_t* const dex_location_checksum)
558      LOCKS_EXCLUDED(dex_lock_);
559
560  // Will open the oat file directly without relocating, even if we could/should do relocation.
561  const OatFile* FindOatFileFromOatLocation(const std::string& oat_location,
562                                            std::string* error_msg)
563      LOCKS_EXCLUDED(dex_lock_);
564
565  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
566      LOCKS_EXCLUDED(dex_lock_);
567
568  const OatFile* OpenOatFileFromDexLocation(const std::string& dex_location,
569                                            InstructionSet isa,
570                                            bool* already_opened,
571                                            bool* obsolete_file_cleanup_failed,
572                                            std::vector<std::string>* error_msg)
573      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
574
575  const OatFile* GetInterpretedOnlyOat(const std::string& oat_path,
576                                       InstructionSet isa,
577                                       std::string* error_msg);
578
579  const OatFile* PatchAndRetrieveOat(const std::string& input, const std::string& output,
580                                     const std::string& image_location, InstructionSet isa,
581                                     std::string* error_msg)
582      LOCKS_EXCLUDED(Locks::mutator_lock_);
583
584  bool CheckOatFile(const OatFile* oat_file, InstructionSet isa,
585                    bool* checksum_verified, std::string* error_msg);
586  int32_t GetRequiredDelta(const OatFile* oat_file, InstructionSet isa);
587
588  // Note: will not register the oat file.
589  const OatFile* FindOatFileInOatLocationForDexFile(const char* dex_location,
590                                                    uint32_t dex_location_checksum,
591                                                    const char* oat_location,
592                                                    std::string* error_msg)
593      LOCKS_EXCLUDED(dex_lock_);
594
595  // Creates the oat file from the dex_location to the oat_location. Needs a file descriptor for
596  // the file to be written, which is assumed to be under a lock.
597  const OatFile* CreateOatFileForDexLocation(const char* dex_location,
598                                             int fd, const char* oat_location,
599                                             std::vector<std::string>* error_msgs)
600      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
601
602  // Finds an OatFile that contains a DexFile for the given a DexFile location.
603  //
604  // Note 1: this will not check open oat files, which are assumed to be stale when this is run.
605  // Note 2: Does not register the oat file. It is the caller's job to register if the file is to
606  //         be kept.
607  const OatFile* FindOatFileContainingDexFileFromDexLocation(const char* location,
608                                                             const uint32_t* const location_checksum,
609                                                             InstructionSet isa,
610                                                             std::vector<std::string>* error_msgs,
611                                                             bool* obsolete_file_cleanup_failed)
612      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
613
614  // verify an oat file with the given dex file. Will return false when the dex file could not be
615  // verified. Will return true otherwise.
616  bool VerifyOatWithDexFile(const OatFile* oat_file, const char* dex_location,
617                            std::string* error_msg);
618
619  mirror::ArtMethod* CreateProxyConstructor(Thread* self, ConstHandle<mirror::Class> klass,
620                                            mirror::Class* proxy_class)
621      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
622  mirror::ArtMethod* CreateProxyMethod(Thread* self, ConstHandle<mirror::Class> klass,
623                                       ConstHandle<mirror::ArtMethod> prototype)
624      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
625
626  std::vector<const DexFile*> boot_class_path_;
627
628  mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
629  std::vector<size_t> new_dex_cache_roots_ GUARDED_BY(dex_lock_);;
630  std::vector<GcRoot<mirror::DexCache>> dex_caches_ GUARDED_BY(dex_lock_);
631  std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
632
633
634  // multimap from a string hash code of a class descriptor to
635  // mirror::Class* instances. Results should be compared for a matching
636  // Class::descriptor_ and Class::class_loader_.
637  typedef AllocationTrackingMultiMap<size_t, GcRoot<mirror::Class>, kAllocatorTagClassTable> Table;
638  // This contains strong roots. To enable concurrent root scanning of
639  // the class table, be careful to use a read barrier when accessing this.
640  Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
641  std::vector<std::pair<size_t, GcRoot<mirror::Class>>> new_class_roots_;
642
643  // Do we need to search dex caches to find image classes?
644  bool dex_cache_image_class_lookup_required_;
645  // Number of times we've searched dex caches for a class. After a certain number of misses we move
646  // the classes into the class_table_ to avoid dex cache based searches.
647  Atomic<uint32_t> failed_dex_cache_class_lookups_;
648
649  mirror::Class* LookupClassFromTableLocked(const char* descriptor,
650                                            const mirror::ClassLoader* class_loader,
651                                            size_t hash)
652      SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
653
654  mirror::Class* UpdateClass(const char* descriptor, mirror::Class* klass, size_t hash)
655      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
656      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
657
658  void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
659      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
660  mirror::Class* LookupClassFromImage(const char* descriptor)
661      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
662
663  // EnsureResolved is called to make sure that a class in the class_table_ has been resolved
664  // before returning it to the caller. Its the responsibility of the thread that placed the class
665  // in the table to make it resolved. The thread doing resolution must notify on the class' lock
666  // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may
667  // retire a class, the version of the class in the table is returned and this may differ from
668  // the class passed in.
669  mirror::Class* EnsureResolved(Thread* self, const char* descriptor, mirror::Class* klass)
670      WARN_UNUSED SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
671
672  void FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class)
673      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
674
675  // indexes into class_roots_.
676  // needs to be kept in sync with class_roots_descriptors_.
677  enum ClassRoot {
678    kJavaLangClass,
679    kJavaLangObject,
680    kClassArrayClass,
681    kObjectArrayClass,
682    kJavaLangString,
683    kJavaLangDexCache,
684    kJavaLangRefReference,
685    kJavaLangReflectArtField,
686    kJavaLangReflectArtMethod,
687    kJavaLangReflectProxy,
688    kJavaLangStringArrayClass,
689    kJavaLangReflectArtFieldArrayClass,
690    kJavaLangReflectArtMethodArrayClass,
691    kJavaLangClassLoader,
692    kJavaLangThrowable,
693    kJavaLangClassNotFoundException,
694    kJavaLangStackTraceElement,
695    kPrimitiveBoolean,
696    kPrimitiveByte,
697    kPrimitiveChar,
698    kPrimitiveDouble,
699    kPrimitiveFloat,
700    kPrimitiveInt,
701    kPrimitiveLong,
702    kPrimitiveShort,
703    kPrimitiveVoid,
704    kBooleanArrayClass,
705    kByteArrayClass,
706    kCharArrayClass,
707    kDoubleArrayClass,
708    kFloatArrayClass,
709    kIntArrayClass,
710    kLongArrayClass,
711    kShortArrayClass,
712    kJavaLangStackTraceElementArrayClass,
713    kClassRootsMax,
714  };
715  GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_;
716
717  mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
718
719  void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
720      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
721
722  static const char* class_roots_descriptors_[];
723
724  const char* GetClassRootDescriptor(ClassRoot class_root) {
725    const char* descriptor = class_roots_descriptors_[class_root];
726    CHECK(descriptor != NULL);
727    return descriptor;
728  }
729
730  // The interface table used by all arrays.
731  GcRoot<mirror::IfTable> array_iftable_;
732
733  // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
734  // descriptors for the sake of performing FindClass.
735  static constexpr size_t kFindArrayCacheSize = 16;
736  GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize];
737  size_t find_array_class_cache_next_victim_;
738
739  bool init_done_;
740  bool log_new_dex_caches_roots_ GUARDED_BY(dex_lock_);
741  bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
742
743  InternTable* intern_table_;
744
745  // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single
746  // patch point within the image. TODO: make these proper relocations.
747  const void* portable_resolution_trampoline_;
748  const void* quick_resolution_trampoline_;
749  const void* portable_imt_conflict_trampoline_;
750  const void* quick_imt_conflict_trampoline_;
751  const void* quick_generic_jni_trampoline_;
752  const void* quick_to_interpreter_bridge_trampoline_;
753
754  friend class ImageWriter;  // for GetClassRoots
755  friend class ImageDumper;  // for FindOpenedOatFileFromOatLocation
756  friend class ElfPatcher;  // for FindOpenedOatFileForDexFile & FindOpenedOatFileFromOatLocation
757  friend class NoDex2OatTest;  // for FindOpenedOatFileForDexFile
758  friend class NoPatchoatTest;  // for FindOpenedOatFileForDexFile
759  FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
760  FRIEND_TEST(mirror::DexCacheTest, Open);
761  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
762  FRIEND_TEST(ObjectTest, AllocObjectArray);
763  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
764};
765
766}  // namespace art
767
768#endif  // ART_RUNTIME_CLASS_LINKER_H_
769