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