class_linker.h revision f0972a410a0665dbe32bd96df09a572d69f9f3a3 
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                                                     std::vector<std::string>* error_msgs)
284      LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
285
286
287  // Returns true if oat file contains the dex file with the given location and checksum.
288  static bool VerifyOatFileChecksums(const OatFile* oat_file,
289                                     const char* dex_location,
290                                     uint32_t dex_location_checksum,
291                                     const InstructionSet instruction_set,
292                                     std::string* error_msg);
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(const Handle<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                                         const Handle<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(ScopedObjectAccess& soa, jstring name, jobjectArray interfaces,
329                                  jobject loader, jobjectArray methods, jobjectArray throws)
330      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
331  std::string GetDescriptorForProxy(mirror::Class* proxy_class)
332      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
333  mirror::ArtMethod* FindMethodForProxy(mirror::Class* proxy_class,
334                                        mirror::ArtMethod* proxy_method)
335      LOCKS_EXCLUDED(dex_lock_)
336      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
337
338  // Get the oat code for a method when its class isn't yet initialized
339  const void* GetQuickOatCodeFor(mirror::ArtMethod* method)
340      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
341  const void* GetPortableOatCodeFor(mirror::ArtMethod* method, bool* have_portable_code)
342      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
343
344  // Get the oat code for a method from a method index.
345  const void* GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
346      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
347  const void* GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
348      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
349
350  pid_t GetClassesLockOwner();  // For SignalCatcher.
351  pid_t GetDexLockOwner();  // For SignalCatcher.
352
353  const void* GetPortableResolutionTrampoline() const {
354    return portable_resolution_trampoline_;
355  }
356
357  const void* GetQuickGenericJniTrampoline() const {
358    return quick_generic_jni_trampoline_;
359  }
360
361  const void* GetQuickResolutionTrampoline() const {
362    return quick_resolution_trampoline_;
363  }
364
365  const void* GetPortableImtConflictTrampoline() const {
366    return portable_imt_conflict_trampoline_;
367  }
368
369  const void* GetQuickImtConflictTrampoline() const {
370    return quick_imt_conflict_trampoline_;
371  }
372
373  const void* GetQuickToInterpreterBridgeTrampoline() const {
374    return quick_to_interpreter_bridge_trampoline_;
375  }
376
377  InternTable* GetInternTable() const {
378    return intern_table_;
379  }
380
381  // Attempts to insert a class into a class table.  Returns NULL if
382  // the class was inserted, otherwise returns an existing class with
383  // the same descriptor and ClassLoader.
384  mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash)
385      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
386      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
387
388  // Special code to allocate an art method, use this instead of class->AllocObject.
389  mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
390
391 private:
392  const OatFile::OatMethod GetOatMethodFor(mirror::ArtMethod* method)
393      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
394
395  OatFile& GetImageOatFile(gc::space::ImageSpace* space)
396      LOCKS_EXCLUDED(dex_lock_)
397      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
398
399  void FinishInit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
400
401  // For early bootstrapping by Init
402  mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size)
403      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
404
405  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
406  // values that are known to the ClassLinker such as
407  // kObjectArrayClass and kJavaLangString etc.
408  mirror::Class* AllocClass(Thread* self, uint32_t class_size)
409      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
410  mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
411      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
412  mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
413
414  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
415      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
416  mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
417      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
418
419
420  mirror::Class* CreateArrayClass(Thread* self, const char* descriptor,
421                                  const Handle<mirror::ClassLoader>& class_loader)
422      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
423
424  void AppendToBootClassPath(const DexFile& dex_file)
425      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
426  void AppendToBootClassPath(const DexFile& dex_file, const Handle<mirror::DexCache>& dex_cache)
427      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
428
429  void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
430                         mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map)
431      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
432
433  uint32_t SizeOfClass(const DexFile& dex_file,
434                     const DexFile::ClassDef& dex_class_def);
435
436  void LoadClass(const DexFile& dex_file,
437                 const DexFile::ClassDef& dex_class_def,
438                 const Handle<mirror::Class>& klass,
439                 mirror::ClassLoader* class_loader)
440      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
441  void LoadClassMembers(const DexFile& dex_file,
442                        const byte* class_data,
443                        const Handle<mirror::Class>& klass,
444                        mirror::ClassLoader* class_loader,
445                        const OatFile::OatClass* oat_class)
446      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
447
448  void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
449                 const Handle<mirror::Class>& klass, const Handle<mirror::ArtField>& dst)
450      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
451
452  mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file,
453                                const ClassDataItemIterator& dex_method,
454                                const Handle<mirror::Class>& klass)
455      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
456
457  void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
458
459  // Finds the associated oat class for a dex_file and descriptor
460  OatFile::OatClass GetOatClass(const DexFile& dex_file, uint16_t class_def_idx)
461      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
462
463  void RegisterDexFileLocked(const DexFile& dex_file, const Handle<mirror::DexCache>& dex_cache)
464      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
465      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
466  bool IsDexFileRegisteredLocked(const DexFile& dex_file) const
467      SHARED_LOCKS_REQUIRED(dex_lock_, Locks::mutator_lock_);
468
469  bool InitializeClass(const Handle<mirror::Class>& klass, bool can_run_clinit,
470                       bool can_init_parents)
471      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
472  bool WaitForInitializeClass(const Handle<mirror::Class>& klass, Thread* self,
473                              ObjectLock<mirror::Class>& lock);
474  bool ValidateSuperClassDescriptors(const Handle<mirror::Class>& klass)
475      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
476
477  bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor,
478                                                Handle<mirror::ClassLoader>& class_loader1,
479                                                Handle<mirror::ClassLoader>& class_loader2)
480      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
481
482  bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, mirror::ArtMethod* method,
483                                                     mirror::Class* klass1,
484                                                     mirror::Class* klass2)
485      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
486
487  bool LinkClass(Thread* self, const Handle<mirror::Class>& klass,
488                 const Handle<mirror::ObjectArray<mirror::Class> >& interfaces)
489      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
490
491  bool LinkSuperClass(const Handle<mirror::Class>& klass)
492      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
493
494  bool LoadSuperAndInterfaces(const Handle<mirror::Class>& klass, const DexFile& dex_file)
495      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
496
497  bool LinkMethods(const Handle<mirror::Class>& klass,
498                   const Handle<mirror::ObjectArray<mirror::Class> >& interfaces)
499      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
500
501  bool LinkVirtualMethods(const Handle<mirror::Class>& klass)
502      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
503
504  bool LinkInterfaceMethods(const Handle<mirror::Class>& klass,
505                            const Handle<mirror::ObjectArray<mirror::Class> >& interfaces)
506      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
507
508  bool LinkStaticFields(const Handle<mirror::Class>& klass)
509      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
510  bool LinkInstanceFields(const Handle<mirror::Class>& klass)
511      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
512  bool LinkFields(const Handle<mirror::Class>& klass, bool is_static)
513      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
514  void LinkCode(const Handle<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
515                const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index)
516      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
517
518
519  void CreateReferenceInstanceOffsets(const Handle<mirror::Class>& klass)
520      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
521  void CreateReferenceStaticOffsets(const Handle<mirror::Class>& klass)
522      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
523  void CreateReferenceOffsets(const Handle<mirror::Class>& klass, bool is_static,
524                              uint32_t reference_offsets)
525      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
526
527  // For use by ImageWriter to find DexCaches for its roots
528  const std::vector<mirror::DexCache*>& GetDexCaches() {
529    return dex_caches_;
530  }
531
532  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
533      LOCKS_EXCLUDED(dex_lock_)
534      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
535  const OatFile* FindOpenedOatFileFromDexLocation(const char* dex_location,
536                                                  const uint32_t* const dex_location_checksum)
537      LOCKS_EXCLUDED(dex_lock_);
538  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
539      LOCKS_EXCLUDED(dex_lock_);
540  const DexFile* FindDexFileInOatLocation(const char* dex_location,
541                                          uint32_t dex_location_checksum,
542                                          const char* oat_location,
543                                          std::string* error_msg)
544      LOCKS_EXCLUDED(dex_lock_);
545
546  const DexFile* VerifyAndOpenDexFileFromOatFile(const std::string& oat_file_location,
547                                                 const char* dex_location,
548                                                 std::string* error_msg,
549                                                 bool* open_failed)
550      LOCKS_EXCLUDED(dex_lock_);
551
552  mirror::ArtMethod* CreateProxyConstructor(Thread* self, const Handle<mirror::Class>& klass,
553                                            mirror::Class* proxy_class)
554      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
555  mirror::ArtMethod* CreateProxyMethod(Thread* self, const Handle<mirror::Class>& klass,
556                                       const Handle<mirror::ArtMethod>& prototype)
557      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
558
559  std::vector<const DexFile*> boot_class_path_;
560
561  mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
562  std::vector<size_t> new_dex_cache_roots_ GUARDED_BY(dex_lock_);;
563  std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
564  std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
565
566
567  // multimap from a string hash code of a class descriptor to
568  // mirror::Class* instances. Results should be compared for a matching
569  // Class::descriptor_ and Class::class_loader_.
570  typedef std::multimap<size_t, mirror::Class*> Table;
571  Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
572  std::vector<std::pair<size_t, mirror::Class*> > new_class_roots_;
573
574  // Do we need to search dex caches to find image classes?
575  bool dex_cache_image_class_lookup_required_;
576  // Number of times we've searched dex caches for a class. After a certain number of misses we move
577  // the classes into the class_table_ to avoid dex cache based searches.
578  AtomicInteger failed_dex_cache_class_lookups_;
579
580  mirror::Class* LookupClassFromTableLocked(const char* descriptor,
581                                            const mirror::ClassLoader* class_loader,
582                                            size_t hash)
583      SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
584
585  void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
586      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
587  mirror::Class* LookupClassFromImage(const char* descriptor)
588      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
589
590  // indexes into class_roots_.
591  // needs to be kept in sync with class_roots_descriptors_.
592  enum ClassRoot {
593    kJavaLangClass,
594    kJavaLangObject,
595    kClassArrayClass,
596    kObjectArrayClass,
597    kJavaLangString,
598    kJavaLangDexCache,
599    kJavaLangRefReference,
600    kJavaLangReflectArtField,
601    kJavaLangReflectArtMethod,
602    kJavaLangReflectProxy,
603    kJavaLangStringArrayClass,
604    kJavaLangReflectArtFieldArrayClass,
605    kJavaLangReflectArtMethodArrayClass,
606    kJavaLangClassLoader,
607    kJavaLangThrowable,
608    kJavaLangClassNotFoundException,
609    kJavaLangStackTraceElement,
610    kPrimitiveBoolean,
611    kPrimitiveByte,
612    kPrimitiveChar,
613    kPrimitiveDouble,
614    kPrimitiveFloat,
615    kPrimitiveInt,
616    kPrimitiveLong,
617    kPrimitiveShort,
618    kPrimitiveVoid,
619    kBooleanArrayClass,
620    kByteArrayClass,
621    kCharArrayClass,
622    kDoubleArrayClass,
623    kFloatArrayClass,
624    kIntArrayClass,
625    kLongArrayClass,
626    kShortArrayClass,
627    kJavaLangStackTraceElementArrayClass,
628    kClassRootsMax,
629  };
630  mirror::ObjectArray<mirror::Class>* class_roots_;
631
632  mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
633
634  void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
635      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
636
637  mirror::ObjectArray<mirror::Class>* GetClassRoots() {
638    DCHECK(class_roots_ != NULL);
639    return class_roots_;
640  }
641
642  static const char* class_roots_descriptors_[];
643
644  const char* GetClassRootDescriptor(ClassRoot class_root) {
645    const char* descriptor = class_roots_descriptors_[class_root];
646    CHECK(descriptor != NULL);
647    return descriptor;
648  }
649
650  // The interface table used by all arrays.
651  mirror::IfTable* array_iftable_;
652
653  // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
654  // descriptors for the sake of performing FindClass.
655  static constexpr size_t kFindArrayCacheSize = 16;
656  mirror::Class* find_array_class_cache_[kFindArrayCacheSize];
657  size_t find_array_class_cache_next_victim_;
658
659  bool init_done_;
660  bool log_new_dex_caches_roots_ GUARDED_BY(dex_lock_);
661  bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
662
663  InternTable* intern_table_;
664
665  const void* portable_resolution_trampoline_;
666  const void* quick_resolution_trampoline_;
667  const void* portable_imt_conflict_trampoline_;
668  const void* quick_imt_conflict_trampoline_;
669  const void* quick_generic_jni_trampoline_;
670  const void* quick_to_interpreter_bridge_trampoline_;
671
672  friend class ImageWriter;  // for GetClassRoots
673  FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
674  FRIEND_TEST(mirror::DexCacheTest, Open);
675  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
676  FRIEND_TEST(ObjectTest, AllocObjectArray);
677  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
678};
679
680}  // namespace art
681
682#endif  // ART_RUNTIME_CLASS_LINKER_H_
683