blob: df1ecc6207b6d2080191d3bd7c25ddff850f1777 [file] [log] [blame]
Elliott Hughes418d20f2011-09-22 14:00:39 -07001/*
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 */
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070016
17#ifndef ART_SRC_CLASS_LINKER_H_
18#define ART_SRC_CLASS_LINKER_H_
19
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080020#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070021#include <utility>
22#include <vector>
23
Elliott Hughes76160052012-12-12 16:31:20 -080024#include "base/macros.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080025#include "base/mutex.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070026#include "dex_file.h"
Elliott Hughese5448b52012-01-18 16:44:06 -080027#include "gtest/gtest.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080028#include "root_visitor.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070029#include "oat_file.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070030
31namespace art {
Ian Rogers1d54e732013-05-02 21:10:01 -070032namespace gc {
33namespace space {
34 class ImageSpace;
35} // namespace space
36} // namespace gc
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080037namespace mirror {
Ian Rogers33e95662013-05-20 20:29:14 -070038 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
Ian Rogers1d54e732013-05-02 21:10:01 -070045
Elliott Hughescf4c6c42011-09-01 15:16:42 -070046class InternTable;
Brian Carlstromd1422f82011-09-28 11:37:09 -070047class ObjectLock;
Ian Rogers1f539342012-10-03 21:09:42 -070048template<class T> class SirtRef;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070049
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080050typedef bool (ClassVisitor)(mirror::Class* c, void* arg);
Elliott Hughesa2155262011-11-16 16:26:58 -080051
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070052class ClassLinker {
53 public:
Ian Rogers1f539342012-10-03 21:09:42 -070054 // Creates the class linker by bootstrapping from dex files.
Brian Carlstroma004aa92012-02-08 18:05:09 -080055 static ClassLinker* CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
Ian Rogers00f7d0e2012-07-19 15:28:27 -070056 InternTable* intern_table)
Ian Rogersb726dcb2012-09-05 08:57:23 -070057 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -070058
Brian Carlstroma004aa92012-02-08 18:05:09 -080059 // Creates the class linker from an image.
Ian Rogers00f7d0e2012-07-19 15:28:27 -070060 static ClassLinker* CreateFromImage(InternTable* intern_table)
Ian Rogersb726dcb2012-09-05 08:57:23 -070061 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -070062
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070063 ~ClassLinker();
Carl Shapiro565f5072011-07-10 13:39:43 -070064
Elliott Hughes64bf5a32011-09-20 14:43:12 -070065 // Finds a class by its descriptor, loading it if necessary.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070066 // If class_loader is null, searches boot_class_path_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080067 mirror::Class* FindClass(const char* descriptor, mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -070068 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -070069
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080070 mirror::Class* FindSystemClass(const char* descriptor)
Ian Rogersb726dcb2012-09-05 08:57:23 -070071 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -070072
73 // Define a new a class based on a ClassDef from a DexFile
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080074 mirror::Class* DefineClass(const StringPiece& descriptor, mirror::ClassLoader* class_loader,
75 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
Ian Rogersb726dcb2012-09-05 08:57:23 -070076 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes64bf5a32011-09-20 14:43:12 -070077
78 // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
79 // by the given 'class_loader'.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080080 mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -070081 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
82 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070083
Elliott Hughes6fa602d2011-12-02 17:54:25 -080084 // Finds all the classes with the given descriptor, regardless of ClassLoader.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080085 void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes)
Ian Rogersb726dcb2012-09-05 08:57:23 -070086 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
87 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -080088
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080089 mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -070090
Brian Carlstromae826982011-11-09 01:33:42 -080091 // General class unloading is not supported, this is used to prune
92 // unwanted classes during image writing.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080093 bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -070094 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
95 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -080096
Ian Rogers00f7d0e2012-07-19 15:28:27 -070097 void DumpAllClasses(int flags) const
Ian Rogersb726dcb2012-09-05 08:57:23 -070098 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
99 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700100
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700101 void DumpForSigQuit(std::ostream& os) const
Ian Rogersb726dcb2012-09-05 08:57:23 -0700102 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -0700103
Ian Rogersb726dcb2012-09-05 08:57:23 -0700104 size_t NumLoadedClasses() const LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
Elliott Hughese27955c2011-08-26 15:21:24 -0700105
Brian Carlstromb63ec392011-08-27 17:38:27 -0700106 // Resolve a String with the given index from the DexFile, storing the
Brian Carlstromaded5f72011-10-07 17:15:04 -0700107 // result in the DexCache. The referrer is used to identify the
108 // target DexCache and ClassLoader to use for resolution.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800109 mirror::String* ResolveString(uint32_t string_idx, const mirror::AbstractMethod* referrer)
110 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700111
112 // Resolve a String with the given index from the DexFile, storing the
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700113 // result in the DexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800114 mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx,
115 mirror::DexCache* dex_cache)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700116 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700117
Brian Carlstromb63ec392011-08-27 17:38:27 -0700118 // Resolve a Type with the given index from the DexFile, storing the
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700119 // result in the DexCache. The referrer is used to identity the
120 // target DexCache and ClassLoader to use for resolution.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800121 mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx,
122 const mirror::Class* referrer)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700123 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700124 return ResolveType(dex_file,
125 type_idx,
126 referrer->GetDexCache(),
127 referrer->GetClassLoader());
128 }
129
Brian Carlstromb63ec392011-08-27 17:38:27 -0700130 // Resolve a Type with the given index from the DexFile, storing the
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700131 // result in the DexCache. The referrer is used to identify the
Brian Carlstromb63ec392011-08-27 17:38:27 -0700132 // target DexCache and ClassLoader to use for resolution.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800133 mirror::Class* ResolveType(uint16_t type_idx, const mirror::AbstractMethod* referrer)
134 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700135
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800136 mirror::Class* ResolveType(uint16_t type_idx, const mirror::Field* referrer)
137 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromb63ec392011-08-27 17:38:27 -0700138
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700139 // 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.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800143 mirror::Class* ResolveType(const DexFile& dex_file,
144 uint16_t type_idx,
145 mirror::DexCache* dex_cache,
146 mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700147 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700148
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.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800154 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)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700160 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700161
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800162 mirror::AbstractMethod* ResolveMethod(uint32_t method_idx, const mirror::AbstractMethod* referrer,
163 InvokeType type)
164 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom16192862011-09-12 17:50:06 -0700165
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800166 mirror::Field* ResolveField(uint32_t field_idx, const mirror::AbstractMethod* referrer,
167 bool is_static)
168 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700169
Brian Carlstrom16192862011-09-12 17:50:06 -0700170 // Resolve a field with a given ID from the DexFile, storing the
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700171 // 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.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800175 mirror::Field* ResolveField(const DexFile& dex_file,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700176 uint32_t field_idx,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800177 mirror::DexCache* dex_cache,
178 mirror::ClassLoader* class_loader,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700179 bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700180 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700181
Ian Rogersb067ac22011-12-13 18:05:09 -0800182 // 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.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800186 mirror::Field* ResolveFieldJLS(const DexFile& dex_file,
187 uint32_t field_idx,
188 mirror::DexCache* dex_cache,
189 mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700190 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersb067ac22011-12-13 18:05:09 -0800191
Ian Rogersad25ac52011-10-04 19:13:33 -0700192 // Get shorty from method index without resolution. Used to do handlerization.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800193 const char* MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer, uint32_t* length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700194 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersad25ac52011-10-04 19:13:33 -0700195
Elliott Hughesf4c21c92011-08-19 17:31:31 -0700196 // Returns true on success, false if there's an exception pending.
Brian Carlstrom25c33252011-09-18 15:58:35 -0700197 // can_run_clinit=false allows the compiler to attempt to init a class,
198 // given the restriction that no <clinit> execution is possible.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800199 bool EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700200 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700201
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700202 // Initializes classes that have instances in the image but that have
203 // <clinit> methods so they could not be initialized by the compiler.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700204 void RunRootClinits() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700205
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700206 void RegisterDexFile(const DexFile& dex_file)
207 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700208 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800209 void RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700210 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700211 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700212
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700213 void RegisterOatFile(const OatFile& oat_file)
214 LOCKS_EXCLUDED(dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800215
Brian Carlstrom8a487412011-08-29 20:08:52 -0700216 const std::vector<const DexFile*>& GetBootClassPath() {
217 return boot_class_path_;
218 }
219
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700220 void VisitClasses(ClassVisitor* visitor, void* arg) const
Ian Rogersb726dcb2012-09-05 08:57:23 -0700221 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700222 // 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
Ian Rogersb726dcb2012-09-05 08:57:23 -0700225 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -0800226
Ian Rogers1d54e732013-05-02 21:10:01 -0700227 void VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700228 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_, dex_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700229
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800230 mirror::DexCache* FindDexCache(const DexFile& dex_file) const
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700231 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700232 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700233 bool IsDexFileRegistered(const DexFile& dex_file) const
234 LOCKS_EXCLUDED(dex_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800235 void FixupDexCaches(mirror::AbstractMethod* resolution_method) const
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700236 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700237 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1d9f52b2011-10-13 10:50:45 -0700238
jeffhao262bf462011-10-20 18:36:32 -0700239 // Generate an oat file from a dex file
Brian Carlstromd601af82012-01-06 10:15:19 -0800240 bool GenerateOatFile(const std::string& dex_filename,
241 int oat_fd,
242 const std::string& oat_cache_filename);
jeffhao262bf462011-10-20 18:36:32 -0700243
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700244 const OatFile* FindOatFileFromOatLocation(const std::string& location)
245 LOCKS_EXCLUDED(dex_lock_);
246
247 const OatFile* FindOatFileFromOatLocationLocked(const std::string& location)
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700248 SHARED_LOCKS_REQUIRED(dex_lock_);
buzbeec143c552011-08-20 17:38:58 -0700249
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800250 // 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,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700254 const std::string& oat_location)
Ian Rogers33e95662013-05-20 20:29:14 -0700255 LOCKS_EXCLUDED(dex_lock_)
256 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700257 const DexFile* FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
258 const std::string& oat_location)
Ian Rogers33e95662013-05-20 20:29:14 -0700259 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
260 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800261 // 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.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700264 const DexFile* FindDexFileInOatFileFromDexLocation(const std::string& location)
265 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700266 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800267
jeffhaof6174e82012-01-31 16:14:17 -0800268
Brian Carlstrom28db0122012-10-18 16:20:41 -0700269 // Returns true if oat file contains the dex file with the given location and checksum.
Brian Carlstromafe25512012-06-27 17:02:58 -0700270 static bool VerifyOatFileChecksums(const OatFile* oat_file,
271 const std::string& dex_location,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700272 uint32_t dex_location_checksum)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700273 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromafe25512012-06-27 17:02:58 -0700274
Elliott Hughes418d20f2011-09-22 14:00:39 -0700275 // TODO: replace this with multiple methods that allocate the correct managed type.
Shih-wei Liao44175362011-08-28 16:59:17 -0700276 template <class T>
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800277 mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700278 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700279
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800280 mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700281 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
jeffhao98eacac2011-09-14 16:11:53 -0700282
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800283 mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700284 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800285
286 mirror::ObjectArray<mirror::AbstractMethod>* AllocAbstractMethodArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700287 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800288
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)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700320 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700321 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jesse Wilson95caa792011-10-12 18:14:17 -0400322
Ian Rogers19846512012-02-24 11:42:47 -0800323 // Get the oat code for a method when its class isn't yet initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800324 const void* GetOatCodeFor(const mirror::AbstractMethod* method)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800326
Mathieu Chartiere35517a2012-10-30 18:49:55 -0700327 // Get the oat code for a method from a method index.
Ian Rogers33e95662013-05-20 20:29:14 -0700328 const void* GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx)
329 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartiere35517a2012-10-30 18:49:55 -0700330
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700331 pid_t GetClassesLockOwner(); // For SignalCatcher.
332 pid_t GetDexLockOwner(); // For SignalCatcher.
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700333
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700334 bool IsDirty() const {
335 return is_dirty_;
336 }
337
338 void Dirty() {
339 is_dirty_ = true;
340 }
341
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700342 const void* GetPortableResolutionTrampoline() const {
343 return portable_resolution_trampoline_;
344 }
345
346 const void* GetQuickResolutionTrampoline() const {
347 return quick_resolution_trampoline_;
348 }
349
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700350 private:
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800351 explicit ClassLinker(InternTable*);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700352
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800353 const OatFile::OatMethod GetOatMethodFor(const mirror::AbstractMethod* method)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700354 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
TDYa12785321912012-04-01 15:24:56 -0700355
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700356 // Initialize class linker by bootstraping from dex files
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700357 void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700358 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700359
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700360 // Initialize class linker from one or more images.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700361 void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700362 OatFile& GetImageOatFile(gc::space::ImageSpace* space)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700363 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700364 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800365 static void InitFromImageCallback(mirror::Object* obj, void* arg)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700366 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700367
Ian Rogersb726dcb2012-09-05 08:57:23 -0700368 void FinishInit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700369
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700370 // For early bootstrapping by Init
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800371 mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, size_t class_size)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700372 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700373
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800374 // Alloc* convenience functions to avoid needing to pass in mirror::Class*
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700375 // values that are known to the ClassLinker such as
376 // kObjectArrayClass and kJavaLangString etc.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800377 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)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700379 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800380 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_);
Ian Rogersbdb03912011-09-14 00:55:44 -0700383
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800384 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)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700387 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700388
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700389
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800390 mirror::Class* CreateArrayClass(const std::string& descriptor, mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700391 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700392
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700393 void AppendToBootClassPath(const DexFile& dex_file)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700394 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800395 void AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700396 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700397
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700398 void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800399 mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700400 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700401
Brian Carlstrom4873d462011-08-21 15:23:39 -0700402 size_t SizeOfClass(const DexFile& dex_file,
403 const DexFile::ClassDef& dex_class_def);
404
Brian Carlstromf615a612011-07-23 12:50:34 -0700405 void LoadClass(const DexFile& dex_file,
406 const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800407 SirtRef<mirror::Class>& klass,
408 mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700409 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700410
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800411 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_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700414
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800415 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_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700419
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800420 void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800421
422 // Finds the associated oat class for a dex_file and descriptor
Ian Rogers33e95662013-05-20 20:29:14 -0700423 const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor)
424 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800425
Brian Carlstrom07bb8552012-01-18 22:10:50 -0800426 // 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.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800429 mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700430 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
431 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700432
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800433 void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700434 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700435 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700436 bool IsDexFileRegisteredLocked(const DexFile& dex_file) const SHARED_LOCKS_REQUIRED(dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700437 void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
438 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700439
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800440 bool InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700441 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800442 bool WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock);
443 bool ValidateSuperClassDescriptors(const mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700444 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800445 bool InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700446 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0045a292012-03-31 21:08:41 -0700447 // Initialize static fields, returns true if fields were initialized.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800448 bool InitializeStaticFields(mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700449 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700450
Ian Rogers595799e2012-01-11 17:32:51 -0800451 bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800452 const mirror::Class* klass1,
453 const mirror::Class* klass2)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700454 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700455
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800456 bool IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
457 const mirror::Class* klass1,
458 const mirror::Class* klass2)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700459 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700460
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800461 bool LinkClass(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700462 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700463
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800464 bool LinkSuperClass(SirtRef<mirror::Class>& klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700465 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700466
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800467 bool LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700468 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700469
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800470 bool LinkMethods(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700471 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700472
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800473 bool LinkVirtualMethods(SirtRef<mirror::Class>& klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700474 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700475
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800476 bool LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
477 mirror::ObjectArray<mirror::Class>* interfaces)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700478 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700479
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800480 bool LinkStaticFields(SirtRef<mirror::Class>& klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700481 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800482 bool LinkInstanceFields(SirtRef<mirror::Class>& klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700483 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800484 bool LinkFields(SirtRef<mirror::Class>& klass, bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700485 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700486
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700487
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800488 void CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700489 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800490 void CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700491 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800492 void CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700493 uint32_t reference_offsets)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700494 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700495
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700496 // For use by ImageWriter to find DexCaches for its roots
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800497 const std::vector<mirror::DexCache*>& GetDexCaches() {
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700498 return dex_caches_;
499 }
500
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700501 const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
Ian Rogers33e95662013-05-20 20:29:14 -0700502 LOCKS_EXCLUDED(dex_lock_)
503 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700504 const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location)
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700505 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700506 const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700507 SHARED_LOCKS_REQUIRED(dex_lock_);
Ian Rogerse3359f72013-06-11 15:14:11 -0700508 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
Brian Carlstromafe25512012-06-27 17:02:58 -0700514 const DexFile* VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
515 const std::string& dex_location,
516 uint32_t dex_location_checksum)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700517 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700518 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromfad71432011-10-16 20:25:10 -0700519
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800520 mirror::AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<mirror::Class>& klass,
521 mirror::Class* proxy_class)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700522 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800523 mirror::AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
524 SirtRef<mirror::AbstractMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700525 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jesse Wilson95caa792011-10-12 18:14:17 -0400526
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700527 std::vector<const DexFile*> boot_class_path_;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700528
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700529 mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800530 std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -0700531 std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700532
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700533
Brian Carlstromaded5f72011-10-07 17:15:04 -0700534 // multimap from a string hash code of a class descriptor to
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800535 // mirror::Class* instances. Results should be compared for a matching
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700536 // Class::descriptor_ and Class::class_loader_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800537 typedef std::multimap<size_t, mirror::Class*> Table;
538 Table image_classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
Ian Rogersb726dcb2012-09-05 08:57:23 -0700539 Table classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -0700540
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800541 mirror::Class* LookupClassLocked(const char* descriptor, const mirror::ClassLoader* class_loader,
542 size_t hash, const Table& classes)
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700543 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::classlinker_classes_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700544
Brian Carlstroma663ea52011-08-19 23:33:41 -0700545 // indexes into class_roots_.
546 // needs to be kept in sync with class_roots_descriptors_.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700547 enum ClassRoot {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700548 kJavaLangClass,
549 kJavaLangObject,
Elliott Hughes418d20f2011-09-22 14:00:39 -0700550 kClassArrayClass,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700551 kObjectArrayClass,
552 kJavaLangString,
Mathieu Chartier66f19252012-09-18 08:57:04 -0700553 kJavaLangDexCache,
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700554 kJavaLangRefReference,
Elliott Hughes80609252011-09-23 17:24:51 -0700555 kJavaLangReflectConstructor,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700556 kJavaLangReflectField,
Mathieu Chartier66f19252012-09-18 08:57:04 -0700557 kJavaLangReflectAbstractMethod,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700558 kJavaLangReflectMethod,
Ian Rogers466bb252011-10-14 03:29:56 -0700559 kJavaLangReflectProxy,
Mathieu Chartier66f19252012-09-18 08:57:04 -0700560 kJavaLangStringArrayClass,
Mathieu Chartier66f19252012-09-18 08:57:04 -0700561 kJavaLangReflectAbstractMethodArrayClass,
Ian Rogers4445a7e2012-10-05 17:19:13 -0700562 kJavaLangReflectFieldArrayClass,
563 kJavaLangReflectMethodArrayClass,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700564 kJavaLangClassLoader,
Ian Rogers5167c972012-02-03 10:41:20 -0800565 kJavaLangThrowable,
jeffhao8cd6dda2012-02-22 10:15:34 -0800566 kJavaLangClassNotFoundException,
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700567 kJavaLangStackTraceElement,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700568 kPrimitiveBoolean,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700569 kPrimitiveByte,
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700570 kPrimitiveChar,
571 kPrimitiveDouble,
572 kPrimitiveFloat,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700573 kPrimitiveInt,
574 kPrimitiveLong,
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700575 kPrimitiveShort,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700576 kPrimitiveVoid,
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700577 kBooleanArrayClass,
578 kByteArrayClass,
579 kCharArrayClass,
580 kDoubleArrayClass,
581 kFloatArrayClass,
582 kIntArrayClass,
583 kLongArrayClass,
584 kShortArrayClass,
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700585 kJavaLangStackTraceElementArrayClass,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700586 kClassRootsMax,
587 };
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800588 mirror::ObjectArray<mirror::Class>* class_roots_;
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700589
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800590 mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700591
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800592 void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700593 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700594
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800595 mirror::ObjectArray<mirror::Class>* GetClassRoots() {
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700596 DCHECK(class_roots_ != NULL);
597 return class_roots_;
598 }
599
Elliott Hughes418d20f2011-09-22 14:00:39 -0700600 static const char* class_roots_descriptors_[];
Brian Carlstroma663ea52011-08-19 23:33:41 -0700601
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
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800608 mirror::IfTable* array_iftable_;
Carl Shapiro565f5072011-07-10 13:39:43 -0700609
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700610 bool init_done_;
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700611 bool is_dirty_;
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700612
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700613 InternTable* intern_table_;
614
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700615 const void* portable_resolution_trampoline_;
616 const void* quick_resolution_trampoline_;
617
Brian Carlstromf734cf52011-08-17 16:28:14 -0700618 friend class CommonTest;
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700619 friend class ImageWriter; // for GetClassRoots
Brian Carlstromae826982011-11-09 01:33:42 -0800620 friend class ObjectTest;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800621 FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800622 FRIEND_TEST(mirror::DexCacheTest, Open);
Brian Carlstromae826982011-11-09 01:33:42 -0800623 FRIEND_TEST(ExceptionTest, FindExceptionHandler);
624 FRIEND_TEST(ObjectTest, AllocObjectArray);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700625 DISALLOW_COPY_AND_ASSIGN(ClassLinker);
626};
627
628} // namespace art
629
630#endif // ART_SRC_CLASS_LINKER_H_