class_linker.h revision 56d947fbc9bc2992e2f93112fafb73e50d2aaa7a 
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_SRC_CLASS_LINKER_H_
18#define ART_SRC_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 private:
351  explicit ClassLinker(InternTable*);
352
353  const OatFile::OatMethod GetOatMethodFor(const mirror::AbstractMethod* method)
354      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
355
356  // Initialize class linker by bootstraping from dex files
357  void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path)
358      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
359
360  // Initialize class linker from one or more images.
361  void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
362  OatFile& GetImageOatFile(gc::space::ImageSpace* space)
363      LOCKS_EXCLUDED(dex_lock_)
364      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
365  static void InitFromImageCallback(mirror::Object* obj, void* arg)
366      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
367
368  void FinishInit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
369
370  // For early bootstrapping by Init
371  mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, size_t class_size)
372      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
373
374  // Alloc* convenience functions to avoid needing to pass in mirror::Class*
375  // values that are known to the ClassLinker such as
376  // kObjectArrayClass and kJavaLangString etc.
377  mirror::Class* AllocClass(Thread* self, size_t class_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
378  mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
379      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
380  mirror::Field* AllocField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
381  mirror::Method* AllocMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
382  mirror::Constructor* AllocConstructor(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
383
384  mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
385      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
386  mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
387      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
388
389
390  mirror::Class* CreateArrayClass(const std::string& descriptor, mirror::ClassLoader* class_loader)
391      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
392
393  void AppendToBootClassPath(const DexFile& dex_file)
394      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
395  void AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
396      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
397
398  void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
399                         mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map)
400      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
401
402  size_t SizeOfClass(const DexFile& dex_file,
403                     const DexFile::ClassDef& dex_class_def);
404
405  void LoadClass(const DexFile& dex_file,
406                 const DexFile::ClassDef& dex_class_def,
407                 SirtRef<mirror::Class>& klass,
408                 mirror::ClassLoader* class_loader)
409      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
410
411  void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
412                 SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst)
413      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
414
415  mirror::AbstractMethod* LoadMethod(Thread* self, const DexFile& dex_file,
416                                     const ClassDataItemIterator& dex_method,
417                                     SirtRef<mirror::Class>& klass)
418      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
419
420  void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
421
422  // Finds the associated oat class for a dex_file and descriptor
423  const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor)
424      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
425
426  // Attempts to insert a class into a class table.  Returns NULL if
427  // the class was inserted, otherwise returns an existing class with
428  // the same descriptor and ClassLoader.
429  mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
430      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
431      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
432
433  void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
434      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
435      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
436  bool IsDexFileRegisteredLocked(const DexFile& dex_file) const SHARED_LOCKS_REQUIRED(dex_lock_);
437  void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
438      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
439
440  bool InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics)
441      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
442  bool WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock);
443  bool ValidateSuperClassDescriptors(const mirror::Class* klass)
444      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
445  bool InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields)
446      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
447  // Initialize static fields, returns true if fields were initialized.
448  bool InitializeStaticFields(mirror::Class* klass)
449      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
450
451  bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
452                                                const mirror::Class* klass1,
453                                                const mirror::Class* klass2)
454      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
455
456  bool IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
457                                                     const mirror::Class* klass1,
458                                                     const mirror::Class* klass2)
459      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
460
461  bool LinkClass(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
462      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
463
464  bool LinkSuperClass(SirtRef<mirror::Class>& klass)
465      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
466
467  bool LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file)
468      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
469
470  bool LinkMethods(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
471      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
472
473  bool LinkVirtualMethods(SirtRef<mirror::Class>& klass)
474      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
475
476  bool LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
477                            mirror::ObjectArray<mirror::Class>* interfaces)
478      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
479
480  bool LinkStaticFields(SirtRef<mirror::Class>& klass)
481      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
482  bool LinkInstanceFields(SirtRef<mirror::Class>& klass)
483      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
484  bool LinkFields(SirtRef<mirror::Class>& klass, bool is_static)
485      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
486
487
488  void CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass)
489      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
490  void CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass)
491      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
492  void CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
493                              uint32_t reference_offsets)
494      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
495
496  // For use by ImageWriter to find DexCaches for its roots
497  const std::vector<mirror::DexCache*>& GetDexCaches() {
498    return dex_caches_;
499  }
500
501  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
502      LOCKS_EXCLUDED(dex_lock_)
503      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
504  const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location)
505      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_);
506  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
507      SHARED_LOCKS_REQUIRED(dex_lock_);
508  const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
509                                          uint32_t dex_location_checksum,
510                                          const std::string& oat_location)
511      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
512      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
513
514  const DexFile* VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
515                                                 const std::string& dex_location,
516                                                 uint32_t dex_location_checksum)
517      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
518      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
519
520  mirror::AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<mirror::Class>& klass,
521                                                 mirror::Class* proxy_class)
522      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
523  mirror::AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
524                                            SirtRef<mirror::AbstractMethod>& prototype)
525      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
526
527  std::vector<const DexFile*> boot_class_path_;
528
529  mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
530  std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
531  std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
532
533
534  // multimap from a string hash code of a class descriptor to
535  // mirror::Class* instances. Results should be compared for a matching
536  // Class::descriptor_ and Class::class_loader_.
537  typedef std::multimap<size_t, mirror::Class*> Table;
538  Table image_classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
539  Table classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
540
541  mirror::Class* LookupClassLocked(const char* descriptor, const mirror::ClassLoader* class_loader,
542                                   size_t hash, const Table& classes)
543      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::classlinker_classes_lock_);
544
545  // indexes into class_roots_.
546  // needs to be kept in sync with class_roots_descriptors_.
547  enum ClassRoot {
548    kJavaLangClass,
549    kJavaLangObject,
550    kClassArrayClass,
551    kObjectArrayClass,
552    kJavaLangString,
553    kJavaLangDexCache,
554    kJavaLangRefReference,
555    kJavaLangReflectConstructor,
556    kJavaLangReflectField,
557    kJavaLangReflectAbstractMethod,
558    kJavaLangReflectMethod,
559    kJavaLangReflectProxy,
560    kJavaLangStringArrayClass,
561    kJavaLangReflectAbstractMethodArrayClass,
562    kJavaLangReflectFieldArrayClass,
563    kJavaLangReflectMethodArrayClass,
564    kJavaLangClassLoader,
565    kJavaLangThrowable,
566    kJavaLangClassNotFoundException,
567    kJavaLangStackTraceElement,
568    kPrimitiveBoolean,
569    kPrimitiveByte,
570    kPrimitiveChar,
571    kPrimitiveDouble,
572    kPrimitiveFloat,
573    kPrimitiveInt,
574    kPrimitiveLong,
575    kPrimitiveShort,
576    kPrimitiveVoid,
577    kBooleanArrayClass,
578    kByteArrayClass,
579    kCharArrayClass,
580    kDoubleArrayClass,
581    kFloatArrayClass,
582    kIntArrayClass,
583    kLongArrayClass,
584    kShortArrayClass,
585    kJavaLangStackTraceElementArrayClass,
586    kClassRootsMax,
587  };
588  mirror::ObjectArray<mirror::Class>* class_roots_;
589
590  mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
591
592  void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
593      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
594
595  mirror::ObjectArray<mirror::Class>* GetClassRoots() {
596    DCHECK(class_roots_ != NULL);
597    return class_roots_;
598  }
599
600  static const char* class_roots_descriptors_[];
601
602  const char* GetClassRootDescriptor(ClassRoot class_root) {
603    const char* descriptor = class_roots_descriptors_[class_root];
604    CHECK(descriptor != NULL);
605    return descriptor;
606  }
607
608  mirror::IfTable* array_iftable_;
609
610  bool init_done_;
611  bool is_dirty_;
612
613  InternTable* intern_table_;
614
615  const void* portable_resolution_trampoline_;
616  const void* quick_resolution_trampoline_;
617
618  friend class CommonTest;
619  friend class ImageWriter;  // for GetClassRoots
620  friend class ObjectTest;
621  FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
622  FRIEND_TEST(mirror::DexCacheTest, Open);
623  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
624  FRIEND_TEST(ObjectTest, AllocObjectArray);
625  DISALLOW_COPY_AND_ASSIGN(ClassLinker);
626};
627
628}  // namespace art
629
630#endif  // ART_SRC_CLASS_LINKER_H_
631