class_linker.h revision 848871b4d8481229c32e0d048a9856e5a9a17ef9 
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 "root_visitor.h"
29#include "oat_file.h"
30
31namespace art {
32namespace gc {
33namespace space {
34  class ImageSpace;
35}  // namespace space
36}  // namespace gc
37namespace mirror {
38  class ClassLoader;
39  class DexCache;
40  class DexCacheTest_Open_Test;
41  class IfTable;
42  template<class T> class ObjectArray;
43  class StackTraceElement;
44}  // namespace mirror
45
46class InternTable;
47class ObjectLock;
48template<class T> class SirtRef;
49
50typedef bool (ClassVisitor)(mirror::Class* c, void* arg);
51
52class ClassLinker {
53 public:
54  // Creates the class linker by bootstrapping from dex files.
55  static ClassLinker* CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
56                                         InternTable* intern_table)
57      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
58
59  // Creates the class linker from an image.
60  static ClassLinker* CreateFromImage(InternTable* intern_table)
61      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
62
63  ~ClassLinker();
64
65  // Finds a class by its descriptor, loading it if necessary.
66  // If class_loader is null, searches boot_class_path_.
67  mirror::Class* FindClass(const char* descriptor, mirror::ClassLoader* class_loader)
68      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
69
70  mirror::Class* FindSystemClass(const char* descriptor)
71      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
72
73  // Define a new a class based on a ClassDef from a DexFile
74  mirror::Class* DefineClass(const StringPiece& descriptor, mirror::ClassLoader* class_loader,
75                             const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
76      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
77
78  // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
79  // by the given 'class_loader'.
80  mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader)
81      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
82      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
83
84  // Finds all the classes with the given descriptor, regardless of ClassLoader.
85  void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes)
86      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
87      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
88
89  mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
90
91  // General class unloading is not supported, this is used to prune
92  // unwanted classes during image writing.
93  bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader)
94      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
95      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
96
97  void DumpAllClasses(int flags) const
98      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
99      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
100
101  void DumpForSigQuit(std::ostream& os) const
102      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
103
104  size_t NumLoadedClasses() const LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
105
106  // Resolve a String with the given index from the DexFile, storing the
107  // result in the DexCache. The referrer is used to identify the
108  // target DexCache and ClassLoader to use for resolution.
109  mirror::String* ResolveString(uint32_t string_idx, const mirror::AbstractMethod* referrer)
110      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
111
112  // Resolve a String with the given index from the DexFile, storing the
113  // result in the DexCache.
114  mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx,
115                                mirror::DexCache* dex_cache)
116      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
117
118  // Resolve a Type with the given index from the DexFile, storing the
119  // result in the DexCache. The referrer is used to identity the
120  // target DexCache and ClassLoader to use for resolution.
121  mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx,
122                             const mirror::Class* referrer)
123      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
124    return ResolveType(dex_file,
125                       type_idx,
126                       referrer->GetDexCache(),
127                       referrer->GetClassLoader());
128  }
129
130  // Resolve a Type 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::Class* ResolveType(uint16_t type_idx, const mirror::AbstractMethod* referrer)
134      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
135
136  mirror::Class* ResolveType(uint16_t type_idx, const mirror::Field* referrer)
137      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
138
139  // Resolve a type with the given ID from the DexFile, storing the
140  // result in DexCache. The ClassLoader is used to search for the
141  // type, since it may be referenced from but not contained within
142  // the given DexFile.
143  mirror::Class* ResolveType(const DexFile& dex_file,
144                             uint16_t type_idx,
145                             mirror::DexCache* dex_cache,
146                             mirror::ClassLoader* class_loader)
147      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
148
149  // Resolve a method with a given ID from the DexFile, storing the
150  // result in DexCache. The ClassLinker and ClassLoader are used as
151  // in ResolveType. What is unique is the method type argument which
152  // is used to determine if this method is a direct, static, or
153  // virtual method.
154  mirror::AbstractMethod* ResolveMethod(const DexFile& dex_file,
155                                        uint32_t method_idx,
156                                        mirror::DexCache* dex_cache,
157                                        mirror::ClassLoader* class_loader,
158                                        const mirror::AbstractMethod* referrer,
159                                        InvokeType type)
160      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
161
162  mirror::AbstractMethod* ResolveMethod(uint32_t method_idx, const mirror::AbstractMethod* referrer,
163                                        InvokeType type)
164      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
165
166  mirror::Field* ResolveField(uint32_t field_idx, const mirror::AbstractMethod* referrer,
167                              bool is_static)
168      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
169
170  // Resolve a field with a given ID from the DexFile, storing the
171  // result in DexCache. The ClassLinker and ClassLoader are used as
172  // in ResolveType. What is unique is the is_static argument which is
173  // used to determine if we are resolving a static or non-static
174  // field.
175  mirror::Field* ResolveField(const DexFile& dex_file,
176                      uint32_t field_idx,
177                      mirror::DexCache* dex_cache,
178                      mirror::ClassLoader* class_loader,
179                      bool is_static)
180      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
181
182  // Resolve a field with a given ID from the DexFile, storing the
183  // result in DexCache. The ClassLinker and ClassLoader are used as
184  // in ResolveType. No is_static argument is provided so that Java
185  // field resolution semantics are followed.
186  mirror::Field* ResolveFieldJLS(const DexFile& dex_file,
187                                 uint32_t field_idx,
188                                 mirror::DexCache* dex_cache,
189                                 mirror::ClassLoader* class_loader)
190      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
191
192  // Get shorty from method index without resolution. Used to do handlerization.
193  const char* MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer, uint32_t* length)
194      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
195
196  // Returns true on success, false if there's an exception pending.
197  // can_run_clinit=false allows the compiler to attempt to init a class,
198  // given the restriction that no <clinit> execution is possible.
199  bool EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields)
200      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
201
202  // Initializes classes that have instances in the image but that have
203  // <clinit> methods so they could not be initialized by the compiler.
204  void RunRootClinits() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
205
206  void RegisterDexFile(const DexFile& dex_file)
207      LOCKS_EXCLUDED(dex_lock_)
208      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
209  void RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
210      LOCKS_EXCLUDED(dex_lock_)
211      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
212
213  void RegisterOatFile(const OatFile& oat_file)
214      LOCKS_EXCLUDED(dex_lock_);
215
216  const std::vector<const DexFile*>& GetBootClassPath() {
217    return boot_class_path_;
218  }
219
220  void VisitClasses(ClassVisitor* visitor, void* arg) const
221      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
222  // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_
223  // when calling the visitor.
224  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const
225      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
226
227  void VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
228      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_, dex_lock_);
229
230  mirror::DexCache* FindDexCache(const DexFile& dex_file) const
231      LOCKS_EXCLUDED(dex_lock_)
232      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
233  bool IsDexFileRegistered(const DexFile& dex_file) const
234      LOCKS_EXCLUDED(dex_lock_);
235  void FixupDexCaches(mirror::AbstractMethod* resolution_method) const
236      LOCKS_EXCLUDED(dex_lock_)
237      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
238
239  // Generate an oat file from a dex file
240  bool GenerateOatFile(const std::string& dex_filename,
241                       int oat_fd,
242                       const std::string& oat_cache_filename);
243
244  const OatFile* FindOatFileFromOatLocation(const std::string& location)
245      LOCKS_EXCLUDED(dex_lock_);
246
247  const OatFile* FindOatFileFromOatLocationLocked(const std::string& location)
248      SHARED_LOCKS_REQUIRED(dex_lock_);
249
250  // Finds the oat file for a dex location, generating the oat file if
251  // it is missing or out of date. Returns the DexFile from within the
252  // created oat file.
253  const DexFile* FindOrCreateOatFileForDexLocation(const std::string& dex_location,
254                                                   const std::string& oat_location)
255      LOCKS_EXCLUDED(dex_lock_)
256      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
257  const DexFile* FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
258                                                         const std::string& oat_location)
259      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
260      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
261  // Find a DexFile within an OatFile given a DexFile location. Note
262  // that this returns null if the location checksum of the DexFile
263  // does not match the OatFile.
264  const DexFile* FindDexFileInOatFileFromDexLocation(const std::string& location)
265      LOCKS_EXCLUDED(dex_lock_)
266      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
267
268
269  // Returns true if oat file contains the dex file with the given location and checksum.
270  static bool VerifyOatFileChecksums(const OatFile* oat_file,
271                                     const std::string& dex_location,
272                                     uint32_t dex_location_checksum)
273      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
274
275  // TODO: replace this with multiple methods that allocate the correct managed type.
276  template <class T>
277  mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
278      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
279
280  mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length)
281      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
282
283  mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
284      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
285
286  mirror::ObjectArray<mirror::AbstractMethod>* AllocAbstractMethodArray(Thread* self, size_t length)
287      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
288
289  mirror::ObjectArray<mirror::AbstractMethod>* AllocMethodArray(Thread* self, size_t length)
290      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
291
292  mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
293      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
294
295  mirror::ObjectArray<mirror::Field>* AllocFieldArray(Thread* self, size_t length)
296      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
297
298  mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
299                                                                              size_t length)
300      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
301
302  void VerifyClass(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
303  bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
304                               mirror::Class::Status& oat_file_class_status)
305      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
306  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass)
307      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
308  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::AbstractMethod* klass)
309      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
310
311  mirror::Class* CreateProxyClass(mirror::String* name, mirror::ObjectArray<mirror::Class>* interfaces,
312                                  mirror::ClassLoader* loader,
313                                  mirror::ObjectArray<mirror::AbstractMethod>* methods,
314                                  mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws)
315      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
316  std::string GetDescriptorForProxy(const mirror::Class* proxy_class)
317      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
318  mirror::AbstractMethod* FindMethodForProxy(const mirror::Class* proxy_class,
319                                             const mirror::AbstractMethod* proxy_method)
320      LOCKS_EXCLUDED(dex_lock_)
321      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
322
323  // Get the oat code for a method when its class isn't yet initialized
324  const void* GetOatCodeFor(const mirror::AbstractMethod* method)
325      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
326
327  // Get the oat code for a method from a method index.
328  const void* GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx)
329      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
330
331  pid_t GetClassesLockOwner();  // For SignalCatcher.
332  pid_t GetDexLockOwner();  // For SignalCatcher.
333
334  bool IsDirty() const {
335    return is_dirty_;
336  }
337
338  void Dirty() {
339    is_dirty_ = true;
340  }
341
342  const void* GetPortableResolutionTrampoline() const {
343    return portable_resolution_trampoline_;
344  }
345
346  const void* GetQuickResolutionTrampoline() const {
347    return quick_resolution_trampoline_;
348  }
349
350  InternTable* GetInternTable() const {
351    return intern_table_;
352  }
353
354  // Attempts to insert a class into a class table.  Returns NULL if
355  // the class was inserted, otherwise returns an existing class with
356  // the same descriptor and ClassLoader.
357  mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
358      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
359      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
360
361 private:
362  explicit ClassLinker(InternTable*);
363
364  const OatFile::OatMethod GetOatMethodFor(const mirror::AbstractMethod* method)
365      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
366
367  // Initialize class linker by bootstraping from dex files
368  void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path)
369      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
370
371  // Initialize class linker from one or more images.
372  void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
373  OatFile& GetImageOatFile(gc::space::ImageSpace* space)
374      LOCKS_EXCLUDED(dex_lock_)
375      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
376
377  void FinishInit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
378
379  // For early bootstrapping by Init
380  mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, size_t class_size)
381      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
382
383  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
384  // values that are known to the ClassLinker such as
385  // kObjectArrayClass and kJavaLangString etc.
386  mirror::Class* AllocClass(Thread* self, size_t class_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
387  mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
388      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
389  mirror::Field* AllocField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
390  mirror::Method* AllocMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
391  mirror::Constructor* AllocConstructor(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
392
393  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
394      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
395  mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
396      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
397
398
399  mirror::Class* CreateArrayClass(const std::string& descriptor, mirror::ClassLoader* class_loader)
400      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
401
402  void AppendToBootClassPath(const DexFile& dex_file)
403      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
404  void AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
405      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
406
407  void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
408                         mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map)
409      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
410
411  size_t SizeOfClass(const DexFile& dex_file,
412                     const DexFile::ClassDef& dex_class_def);
413
414  void LoadClass(const DexFile& dex_file,
415                 const DexFile::ClassDef& dex_class_def,
416                 SirtRef<mirror::Class>& klass,
417                 mirror::ClassLoader* class_loader)
418      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
419
420  void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
421                 SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst)
422      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
423
424  mirror::AbstractMethod* LoadMethod(Thread* self, const DexFile& dex_file,
425                                     const ClassDataItemIterator& dex_method,
426                                     SirtRef<mirror::Class>& klass)
427      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
428
429  void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
430
431  // Finds the associated oat class for a dex_file and descriptor
432  const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor)
433      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
434
435  void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
436      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
437      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
438  bool IsDexFileRegisteredLocked(const DexFile& dex_file) const SHARED_LOCKS_REQUIRED(dex_lock_);
439  void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
440      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
441
442  bool InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics)
443      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
444  bool WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock);
445  bool ValidateSuperClassDescriptors(const mirror::Class* klass)
446      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
447  bool InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields)
448      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
449  // Initialize static fields, returns true if fields were initialized.
450  bool InitializeStaticFields(mirror::Class* klass)
451      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
452
453  bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
454                                                const mirror::Class* klass1,
455                                                const mirror::Class* klass2)
456      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
457
458  bool IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
459                                                     const mirror::Class* klass1,
460                                                     const mirror::Class* klass2)
461      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
462
463  bool LinkClass(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
464      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
465
466  bool LinkSuperClass(SirtRef<mirror::Class>& klass)
467      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
468
469  bool LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file)
470      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
471
472  bool LinkMethods(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
473      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
474
475  bool LinkVirtualMethods(SirtRef<mirror::Class>& klass)
476      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
477
478  bool LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
479                            mirror::ObjectArray<mirror::Class>* interfaces)
480      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
481
482  bool LinkStaticFields(SirtRef<mirror::Class>& klass)
483      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
484  bool LinkInstanceFields(SirtRef<mirror::Class>& klass)
485      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
486  bool LinkFields(SirtRef<mirror::Class>& klass, bool is_static)
487      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
488
489
490  void CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass)
491      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
492  void CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass)
493      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
494  void CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
495                              uint32_t reference_offsets)
496      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
497
498  // For use by ImageWriter to find DexCaches for its roots
499  const std::vector<mirror::DexCache*>& GetDexCaches() {
500    return dex_caches_;
501  }
502
503  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
504      LOCKS_EXCLUDED(dex_lock_)
505      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
506  const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location)
507      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_);
508  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
509      SHARED_LOCKS_REQUIRED(dex_lock_);
510  const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
511                                          uint32_t dex_location_checksum,
512                                          const std::string& oat_location)
513      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
514      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
515
516  const DexFile* VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
517                                                 const std::string& dex_location,
518                                                 uint32_t dex_location_checksum)
519      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
520      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
521
522  mirror::AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<mirror::Class>& klass,
523                                                 mirror::Class* proxy_class)
524      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
525  mirror::AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
526                                            SirtRef<mirror::AbstractMethod>& prototype)
527      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
528
529  std::vector<const DexFile*> boot_class_path_;
530
531  mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
532  std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
533  std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
534
535
536  // multimap from a string hash code of a class descriptor to
537  // mirror::Class* instances. Results should be compared for a matching
538  // Class::descriptor_ and Class::class_loader_.
539  typedef std::multimap<size_t, mirror::Class*> Table;
540  Table image_classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
541  Table classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
542
543  mirror::Class* LookupClassLocked(const char* descriptor, const mirror::ClassLoader* class_loader,
544                                   size_t hash, const Table& classes)
545      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::classlinker_classes_lock_);
546
547  // indexes into class_roots_.
548  // needs to be kept in sync with class_roots_descriptors_.
549  enum ClassRoot {
550    kJavaLangClass,
551    kJavaLangObject,
552    kClassArrayClass,
553    kObjectArrayClass,
554    kJavaLangString,
555    kJavaLangDexCache,
556    kJavaLangRefReference,
557    kJavaLangReflectConstructor,
558    kJavaLangReflectField,
559    kJavaLangReflectAbstractMethod,
560    kJavaLangReflectMethod,
561    kJavaLangReflectProxy,
562    kJavaLangStringArrayClass,
563    kJavaLangReflectAbstractMethodArrayClass,
564    kJavaLangReflectFieldArrayClass,
565    kJavaLangReflectMethodArrayClass,
566    kJavaLangClassLoader,
567    kJavaLangThrowable,
568    kJavaLangClassNotFoundException,
569    kJavaLangStackTraceElement,
570    kPrimitiveBoolean,
571    kPrimitiveByte,
572    kPrimitiveChar,
573    kPrimitiveDouble,
574    kPrimitiveFloat,
575    kPrimitiveInt,
576    kPrimitiveLong,
577    kPrimitiveShort,
578    kPrimitiveVoid,
579    kBooleanArrayClass,
580    kByteArrayClass,
581    kCharArrayClass,
582    kDoubleArrayClass,
583    kFloatArrayClass,
584    kIntArrayClass,
585    kLongArrayClass,
586    kShortArrayClass,
587    kJavaLangStackTraceElementArrayClass,
588    kClassRootsMax,
589  };
590  mirror::ObjectArray<mirror::Class>* class_roots_;
591
592  mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
593
594  void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
595      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
596
597  mirror::ObjectArray<mirror::Class>* GetClassRoots() {
598    DCHECK(class_roots_ != NULL);
599    return class_roots_;
600  }
601
602  static const char* class_roots_descriptors_[];
603
604  const char* GetClassRootDescriptor(ClassRoot class_root) {
605    const char* descriptor = class_roots_descriptors_[class_root];
606    CHECK(descriptor != NULL);
607    return descriptor;
608  }
609
610  mirror::IfTable* array_iftable_;
611
612  bool init_done_;
613  bool is_dirty_;
614
615  InternTable* intern_table_;
616
617  const void* portable_resolution_trampoline_;
618  const void* quick_resolution_trampoline_;
619
620  friend class CommonTest;
621  friend class ImageWriter;  // for GetClassRoots
622  friend class ObjectTest;
623  FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
624  FRIEND_TEST(mirror::DexCacheTest, Open);
625  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
626  FRIEND_TEST(ObjectTest, AllocObjectArray);
627  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
628};
629
630}  // namespace art
631
632#endif  // ART_RUNTIME_CLASS_LINKER_H_
633