class_linker.h revision 2afe49450f2e018f18b5de45428b9174bfd6f196 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ART_RUNTIME_CLASS_LINKER_H_
18#define ART_RUNTIME_CLASS_LINKER_H_
19
20#include <string>
21#include <utility>
22#include <vector>
23
24#include "base/macros.h"
25#include "base/mutex.h"
26#include "dex_file.h"
27#include "gtest/gtest.h"
28#include "jni.h"
29#include "oat_file.h"
30#include "object_callbacks.h"
31
32namespace art {
33namespace gc {
34namespace space {
35  class ImageSpace;
36}  // namespace space
37}  // namespace gc
38namespace mirror {
39  class ClassLoader;
40  class DexCache;
41  class DexCacheTest_Open_Test;
42  class IfTable;
43  template<class T> class ObjectArray;
44  class StackTraceElement;
45}  // namespace mirror
46
47class InternTable;
48template<class T> class ObjectLock;
49class ScopedObjectAccess;
50template<class T> class Handle;
51
52typedef bool (ClassVisitor)(mirror::Class* c, void* arg);
53
54enum VisitRootFlags : uint8_t;
55
56class ClassLinker {
57 public:
58  // Interface method table size. Increasing this value reduces the chance of two interface methods
59  // colliding in the interface method table but increases the size of classes that implement
60  // (non-marker) interfaces.
61  static constexpr size_t kImtSize = 64;
62
63  explicit ClassLinker(InternTable* intern_table);
64  ~ClassLinker();
65
66  // Initialize class linker by bootstraping from dex files
67  void InitFromCompiler(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  bool IsInBootClassPath(const char* descriptor);
74
75  // Finds a class by its descriptor, loading it if necessary.
76  // If class_loader is null, searches boot_class_path_.
77  mirror::Class* FindClass(Thread* self, const char* descriptor,
78                           const Handle<mirror::ClassLoader>& class_loader)
79      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
80
81  // Finds a class by its descriptor using the "system" class loader, ie by searching the
82  // boot_class_path_.
83  mirror::Class* FindSystemClass(Thread* self, const char* descriptor)
84      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
85
86  // Finds the array class given for the element class.
87  mirror::Class* FindArrayClass(Thread* self, mirror::Class* element_class)
88      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
89
90  // Reutrns true if the class linker is initialized.
91  bool IsInitialized() const;
92
93  // Define a new a class based on a ClassDef from a DexFile
94  mirror::Class* DefineClass(const char* descriptor,
95                             const Handle<mirror::ClassLoader>& class_loader,
96                             const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
97      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
98
99  // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
100  // by the given 'class_loader'.
101  mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader)
102      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
103      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
104
105  // Finds all the classes with the given descriptor, regardless of ClassLoader.
106  void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes)
107      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
108      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
109
110  mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
111
112  // General class unloading is not supported, this is used to prune
113  // unwanted classes during image writing.
114  bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader)
115      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
116      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
117
118  void DumpAllClasses(int flags)
119      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
120      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
121
122  void DumpForSigQuit(std::ostream& os)
123      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
124      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
125
126  size_t NumLoadedClasses()
127      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
128      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
129
130  // Resolve a String with the given index from the DexFile, storing the
131  // result in the DexCache. The referrer is used to identify the
132  // target DexCache and ClassLoader to use for resolution.
133  mirror::String* ResolveString(uint32_t string_idx, mirror::ArtMethod* referrer)
134      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
135
136  // Resolve a String with the given index from the DexFile, storing the
137  // result in the DexCache.
138  mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx,
139                                const Handle<mirror::DexCache>& dex_cache)
140      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
141
142  // Resolve a Type with the given index from the DexFile, storing the
143  // result in the DexCache. The referrer is used to identity the
144  // target DexCache and ClassLoader to use for resolution.
145  mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, mirror::Class* referrer)
146      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
147
148  // Resolve a Type with the given index from the DexFile, storing the
149  // result in the DexCache. The referrer is used to identify the
150  // target DexCache and ClassLoader to use for resolution.
151  mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtMethod* referrer)
152      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
153
154  mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtField* referrer)
155      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
156
157  // Resolve a type with the given ID from the DexFile, storing the
158  // result in DexCache. The ClassLoader is used to search for the
159  // type, since it may be referenced from but not contained within
160  // the given DexFile.
161  mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx,
162                             const Handle<mirror::DexCache>& dex_cache,
163                             const Handle<mirror::ClassLoader>& class_loader)
164      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
165
166  // Resolve a method with a given ID from the DexFile, storing the
167  // result in DexCache. The ClassLinker and ClassLoader are used as
168  // in ResolveType. What is unique is the method type argument which
169  // is used to determine if this method is a direct, static, or
170  // virtual method.
171  mirror::ArtMethod* ResolveMethod(const DexFile& dex_file,
172                                   uint32_t method_idx,
173                                   const Handle<mirror::DexCache>& dex_cache,
174                                   const Handle<mirror::ClassLoader>& class_loader,
175                                   mirror::ArtMethod* referrer,
176                                   InvokeType type)
177      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
178
179  mirror::ArtMethod* ResolveMethod(uint32_t method_idx, mirror::ArtMethod* referrer,
180                                   InvokeType type)
181      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
182
183  mirror::ArtField* ResolveField(uint32_t field_idx, mirror::ArtMethod* referrer,
184                                 bool is_static)
185      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
186
187  // Resolve a field with a given ID from the DexFile, storing the
188  // result in DexCache. The ClassLinker and ClassLoader are used as
189  // in ResolveType. What is unique is the is_static argument which is
190  // used to determine if we are resolving a static or non-static
191  // field.
192  mirror::ArtField* ResolveField(const DexFile& dex_file,
193                                 uint32_t field_idx,
194                                 const Handle<mirror::DexCache>& dex_cache,
195                                 const Handle<mirror::ClassLoader>& class_loader,
196                                 bool is_static)
197      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
198
199  // Resolve a field with a given ID from the DexFile, storing the
200  // result in DexCache. The ClassLinker and ClassLoader are used as
201  // in ResolveType. No is_static argument is provided so that Java
202  // field resolution semantics are followed.
203  mirror::ArtField* ResolveFieldJLS(const DexFile& dex_file,
204                                    uint32_t field_idx,
205                                    const Handle<mirror::DexCache>& dex_cache,
206                                    const Handle<mirror::ClassLoader>& class_loader)
207      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
208
209  // Get shorty from method index without resolution. Used to do handlerization.
210  const char* MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer, uint32_t* length)
211      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
212
213  // Returns true on success, false if there's an exception pending.
214  // can_run_clinit=false allows the compiler to attempt to init a class,
215  // given the restriction that no <clinit> execution is possible.
216  bool EnsureInitialized(const Handle<mirror::Class>& c,
217                         bool can_init_fields, bool can_init_parents)
218      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
219
220  // Initializes classes that have instances in the image but that have
221  // <clinit> methods so they could not be initialized by the compiler.
222  void RunRootClinits() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
223
224  void RegisterDexFile(const DexFile& dex_file)
225      LOCKS_EXCLUDED(dex_lock_)
226      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
227  void RegisterDexFile(const DexFile& dex_file, const Handle<mirror::DexCache>& dex_cache)
228      LOCKS_EXCLUDED(dex_lock_)
229      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
230
231  const OatFile* RegisterOatFile(const OatFile* oat_file)
232      LOCKS_EXCLUDED(dex_lock_);
233
234  const std::vector<const DexFile*>& GetBootClassPath() {
235    return boot_class_path_;
236  }
237
238  void VisitClasses(ClassVisitor* visitor, void* arg)
239      LOCKS_EXCLUDED(dex_lock_)
240      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
241  // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_
242  // when calling the visitor.
243  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg)
244      LOCKS_EXCLUDED(dex_lock_)
245      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
246
247  void VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags)
248      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_, dex_lock_);
249
250  mirror::DexCache* FindDexCache(const DexFile& dex_file) const
251      LOCKS_EXCLUDED(dex_lock_)
252      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
253  bool IsDexFileRegistered(const DexFile& dex_file) const
254      LOCKS_EXCLUDED(dex_lock_) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
255  void FixupDexCaches(mirror::ArtMethod* resolution_method) const
256      LOCKS_EXCLUDED(dex_lock_)
257      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
258
259  // Generate an oat file from a dex file
260  bool GenerateOatFile(const char* dex_filename,
261                       int oat_fd,
262                       const char* oat_cache_filename,
263                       std::string* error_msg)
264      LOCKS_EXCLUDED(Locks::mutator_lock_);
265
266  const OatFile* FindOatFileFromOatLocation(const std::string& location,
267                                            std::string* error_msg)
268      LOCKS_EXCLUDED(dex_lock_);
269
270  // Finds the oat file for a dex location, generating the oat file if
271  // it is missing or out of date. Returns the DexFile from within the
272  // created oat file.
273  const DexFile* FindOrCreateOatFileForDexLocation(const char* dex_location,
274                                                   uint32_t dex_location_checksum,
275                                                   const char* oat_location,
276                                                   std::vector<std::string>* error_msgs)
277      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
278  // Find a DexFile within an OatFile given a DexFile location. Note
279  // that this returns null if the location checksum of the DexFile
280  // does not match the OatFile.
281  const DexFile* FindDexFileInOatFileFromDexLocation(const char* location,
282                                                     const uint32_t* const location_checksum,
283                                                     InstructionSet isa,
284                                                     std::vector<std::string>* error_msgs)
285      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
286
287
288  // Returns true if oat file contains the dex file with the given location and checksum.
289  static bool VerifyOatFileChecksums(const OatFile* oat_file,
290                                     const char* dex_location,
291                                     uint32_t dex_location_checksum,
292                                     InstructionSet instruction_set,
293                                     std::string* error_msg);
294
295  // TODO: replace this with multiple methods that allocate the correct managed type.
296  template <class T>
297  mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
298      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
299
300  mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length)
301      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
302
303  mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
304      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
305
306  mirror::ObjectArray<mirror::ArtMethod>* AllocArtMethodArray(Thread* self, size_t length)
307      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
308
309  mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
310      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
311
312  mirror::ObjectArray<mirror::ArtField>* AllocArtFieldArray(Thread* self, size_t length)
313      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
314
315  mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
316                                                                              size_t length)
317      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
318
319  void VerifyClass(const Handle<mirror::Class>& klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
320  bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
321                               mirror::Class::Status& oat_file_class_status)
322      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
323  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file,
324                                         const Handle<mirror::Class>& klass)
325      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
326  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::ArtMethod* klass)
327      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
328
329  mirror::Class* CreateProxyClass(ScopedObjectAccess& soa, jstring name, jobjectArray interfaces,
330                                  jobject loader, jobjectArray methods, 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  pid_t GetClassesLockOwner();  // For SignalCatcher.
352  pid_t GetDexLockOwner();  // For SignalCatcher.
353
354  const void* GetPortableResolutionTrampoline() const {
355    return portable_resolution_trampoline_;
356  }
357
358  const void* GetQuickGenericJniTrampoline() const {
359    return quick_generic_jni_trampoline_;
360  }
361
362  const void* GetQuickResolutionTrampoline() const {
363    return quick_resolution_trampoline_;
364  }
365
366  const void* GetPortableImtConflictTrampoline() const {
367    return portable_imt_conflict_trampoline_;
368  }
369
370  const void* GetQuickImtConflictTrampoline() const {
371    return quick_imt_conflict_trampoline_;
372  }
373
374  const void* GetQuickToInterpreterBridgeTrampoline() const {
375    return quick_to_interpreter_bridge_trampoline_;
376  }
377
378  InternTable* GetInternTable() const {
379    return intern_table_;
380  }
381
382  // Attempts to insert a class into a class table.  Returns NULL if
383  // the class was inserted, otherwise returns an existing class with
384  // the same descriptor and ClassLoader.
385  mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash)
386      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
387      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
388
389  // Special code to allocate an art method, use this instead of class->AllocObject.
390  mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
391
392 private:
393  const OatFile::OatMethod GetOatMethodFor(mirror::ArtMethod* method)
394      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
395
396  OatFile& GetImageOatFile(gc::space::ImageSpace* space)
397      LOCKS_EXCLUDED(dex_lock_)
398      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
399
400  void FinishInit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
401
402  // For early bootstrapping by Init
403  mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size)
404      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
405
406  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
407  // values that are known to the ClassLinker such as
408  // kObjectArrayClass and kJavaLangString etc.
409  mirror::Class* AllocClass(Thread* self, uint32_t class_size)
410      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
411  mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
412      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
413  mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
414
415  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
416      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
417  mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
418      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
419
420
421  mirror::Class* CreateArrayClass(Thread* self, const char* descriptor,
422                                  const Handle<mirror::ClassLoader>& class_loader)
423      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
424
425  void AppendToBootClassPath(const DexFile& dex_file)
426      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
427  void AppendToBootClassPath(const DexFile& dex_file, const Handle<mirror::DexCache>& dex_cache)
428      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
429
430  void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
431                         mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map)
432      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
433
434  uint32_t SizeOfClass(const DexFile& dex_file,
435                     const DexFile::ClassDef& dex_class_def);
436
437  void LoadClass(const DexFile& dex_file,
438                 const DexFile::ClassDef& dex_class_def,
439                 const Handle<mirror::Class>& klass,
440                 mirror::ClassLoader* class_loader)
441      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
442  void LoadClassMembers(const DexFile& dex_file,
443                        const byte* class_data,
444                        const Handle<mirror::Class>& klass,
445                        mirror::ClassLoader* class_loader,
446                        const OatFile::OatClass* oat_class)
447      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
448
449  void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
450                 const Handle<mirror::Class>& klass, const Handle<mirror::ArtField>& dst)
451      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
452
453  mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file,
454                                const ClassDataItemIterator& dex_method,
455                                const Handle<mirror::Class>& klass)
456      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
457
458  void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
459
460  // Finds the associated oat class for a dex_file and descriptor
461  OatFile::OatClass GetOatClass(const DexFile& dex_file, uint16_t class_def_idx)
462      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
463
464  void RegisterDexFileLocked(const DexFile& dex_file, const Handle<mirror::DexCache>& dex_cache)
465      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
466      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
467  bool IsDexFileRegisteredLocked(const DexFile& dex_file) const
468      SHARED_LOCKS_REQUIRED(dex_lock_, Locks::mutator_lock_);
469
470  bool InitializeClass(const Handle<mirror::Class>& klass, bool can_run_clinit,
471                       bool can_init_parents)
472      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
473  bool WaitForInitializeClass(const Handle<mirror::Class>& klass, Thread* self,
474                              ObjectLock<mirror::Class>& lock);
475  bool ValidateSuperClassDescriptors(const Handle<mirror::Class>& klass)
476      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
477
478  bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor,
479                                                Handle<mirror::ClassLoader>& class_loader1,
480                                                Handle<mirror::ClassLoader>& class_loader2)
481      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
482
483  bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, mirror::ArtMethod* method,
484                                                     mirror::Class* klass1,
485                                                     mirror::Class* klass2)
486      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
487
488  bool LinkClass(Thread* self, const Handle<mirror::Class>& klass,
489                 const Handle<mirror::ObjectArray<mirror::Class> >& interfaces)
490      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
491
492  bool LinkSuperClass(const Handle<mirror::Class>& klass)
493      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
494
495  bool LoadSuperAndInterfaces(const Handle<mirror::Class>& klass, const DexFile& dex_file)
496      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
497
498  bool LinkMethods(const Handle<mirror::Class>& klass,
499                   const Handle<mirror::ObjectArray<mirror::Class> >& interfaces)
500      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
501
502  bool LinkVirtualMethods(const Handle<mirror::Class>& klass)
503      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
504
505  bool LinkInterfaceMethods(const Handle<mirror::Class>& klass,
506                            const Handle<mirror::ObjectArray<mirror::Class> >& interfaces)
507      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
508
509  bool LinkStaticFields(const Handle<mirror::Class>& klass)
510      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
511  bool LinkInstanceFields(const Handle<mirror::Class>& klass)
512      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
513  bool LinkFields(const Handle<mirror::Class>& klass, bool is_static)
514      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
515  void LinkCode(const Handle<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
516                const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index)
517      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
518
519
520  void CreateReferenceInstanceOffsets(const Handle<mirror::Class>& klass)
521      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
522  void CreateReferenceStaticOffsets(const Handle<mirror::Class>& klass)
523      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
524  void CreateReferenceOffsets(const Handle<mirror::Class>& klass, bool is_static,
525                              uint32_t reference_offsets)
526      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
527
528  // For use by ImageWriter to find DexCaches for its roots
529  const std::vector<mirror::DexCache*>& GetDexCaches() {
530    return dex_caches_;
531  }
532
533  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
534      LOCKS_EXCLUDED(dex_lock_)
535      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
536  const OatFile* FindOpenedOatFileFromDexLocation(const char* dex_location,
537                                                  const uint32_t* const dex_location_checksum)
538      LOCKS_EXCLUDED(dex_lock_);
539  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
540      LOCKS_EXCLUDED(dex_lock_);
541  const DexFile* FindDexFileInOatLocation(const char* dex_location,
542                                          uint32_t dex_location_checksum,
543                                          const char* oat_location,
544                                          std::string* error_msg)
545      LOCKS_EXCLUDED(dex_lock_);
546
547  const DexFile* VerifyAndOpenDexFileFromOatFile(const std::string& oat_file_location,
548                                                 const char* dex_location,
549                                                 std::string* error_msg,
550                                                 bool* open_failed)
551      LOCKS_EXCLUDED(dex_lock_);
552
553  mirror::ArtMethod* CreateProxyConstructor(Thread* self, const Handle<mirror::Class>& klass,
554                                            mirror::Class* proxy_class)
555      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
556  mirror::ArtMethod* CreateProxyMethod(Thread* self, const Handle<mirror::Class>& klass,
557                                       const Handle<mirror::ArtMethod>& prototype)
558      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
559
560  std::vector<const DexFile*> boot_class_path_;
561
562  mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
563  std::vector<size_t> new_dex_cache_roots_ GUARDED_BY(dex_lock_);;
564  std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
565  std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
566
567
568  // multimap from a string hash code of a class descriptor to
569  // mirror::Class* instances. Results should be compared for a matching
570  // Class::descriptor_ and Class::class_loader_.
571  typedef std::multimap<size_t, mirror::Class*> Table;
572  Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
573  std::vector<std::pair<size_t, mirror::Class*> > new_class_roots_;
574
575  // Do we need to search dex caches to find image classes?
576  bool dex_cache_image_class_lookup_required_;
577  // Number of times we've searched dex caches for a class. After a certain number of misses we move
578  // the classes into the class_table_ to avoid dex cache based searches.
579  AtomicInteger failed_dex_cache_class_lookups_;
580
581  mirror::Class* LookupClassFromTableLocked(const char* descriptor,
582                                            const mirror::ClassLoader* class_loader,
583                                            size_t hash)
584      SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
585
586  void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
587      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
588  mirror::Class* LookupClassFromImage(const char* descriptor)
589      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
590
591  // indexes into class_roots_.
592  // needs to be kept in sync with class_roots_descriptors_.
593  enum ClassRoot {
594    kJavaLangClass,
595    kJavaLangObject,
596    kClassArrayClass,
597    kObjectArrayClass,
598    kJavaLangString,
599    kJavaLangDexCache,
600    kJavaLangRefReference,
601    kJavaLangReflectArtField,
602    kJavaLangReflectArtMethod,
603    kJavaLangReflectProxy,
604    kJavaLangStringArrayClass,
605    kJavaLangReflectArtFieldArrayClass,
606    kJavaLangReflectArtMethodArrayClass,
607    kJavaLangClassLoader,
608    kJavaLangThrowable,
609    kJavaLangClassNotFoundException,
610    kJavaLangStackTraceElement,
611    kPrimitiveBoolean,
612    kPrimitiveByte,
613    kPrimitiveChar,
614    kPrimitiveDouble,
615    kPrimitiveFloat,
616    kPrimitiveInt,
617    kPrimitiveLong,
618    kPrimitiveShort,
619    kPrimitiveVoid,
620    kBooleanArrayClass,
621    kByteArrayClass,
622    kCharArrayClass,
623    kDoubleArrayClass,
624    kFloatArrayClass,
625    kIntArrayClass,
626    kLongArrayClass,
627    kShortArrayClass,
628    kJavaLangStackTraceElementArrayClass,
629    kClassRootsMax,
630  };
631  mirror::ObjectArray<mirror::Class>* class_roots_;
632
633  mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
634
635  void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
636      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
637
638  mirror::ObjectArray<mirror::Class>* GetClassRoots() {
639    DCHECK(class_roots_ != NULL);
640    return class_roots_;
641  }
642
643  static const char* class_roots_descriptors_[];
644
645  const char* GetClassRootDescriptor(ClassRoot class_root) {
646    const char* descriptor = class_roots_descriptors_[class_root];
647    CHECK(descriptor != NULL);
648    return descriptor;
649  }
650
651  // The interface table used by all arrays.
652  mirror::IfTable* array_iftable_;
653
654  // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
655  // descriptors for the sake of performing FindClass.
656  static constexpr size_t kFindArrayCacheSize = 16;
657  mirror::Class* find_array_class_cache_[kFindArrayCacheSize];
658  size_t find_array_class_cache_next_victim_;
659
660  bool init_done_;
661  bool log_new_dex_caches_roots_ GUARDED_BY(dex_lock_);
662  bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
663
664  InternTable* intern_table_;
665
666  const void* portable_resolution_trampoline_;
667  const void* quick_resolution_trampoline_;
668  const void* portable_imt_conflict_trampoline_;
669  const void* quick_imt_conflict_trampoline_;
670  const void* quick_generic_jni_trampoline_;
671  const void* quick_to_interpreter_bridge_trampoline_;
672
673  friend class ImageWriter;  // for GetClassRoots
674  FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
675  FRIEND_TEST(mirror::DexCacheTest, Open);
676  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
677  FRIEND_TEST(ObjectTest, AllocObjectArray);
678  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
679};
680
681}  // namespace art
682
683#endif  // ART_RUNTIME_CLASS_LINKER_H_
684