blob: e4d9c96696ee6374e090814d69d8348afd15bf16 [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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_CLASS_LINKER_H_
18#define ART_RUNTIME_CLASS_LINKER_H_
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070019
Mathieu Chartierc5dd3192015-12-09 16:38:30 -080020#include <set>
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080021#include <string>
Alex Lighteb7c1442015-08-31 13:17:42 -070022#include <unordered_map>
Mathieu Chartierc5dd3192015-12-09 16:38:30 -080023#include <unordered_set>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070024#include <utility>
25#include <vector>
26
Andreas Gampe542451c2016-07-26 09:02:02 -070027#include "base/enums.h"
Elliott Hughes76160052012-12-12 16:31:20 -080028#include "base/macros.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080029#include "base/mutex.h"
Mathieu Chartier1f1cb9f2018-06-04 09:22:46 -070030#include "dex/class_accessor.h"
David Sehr999646d2018-02-16 10:22:33 -080031#include "dex/dex_cache_resolved_classes.h"
David Sehr9e734c72018-01-04 17:56:19 -080032#include "dex/dex_file.h"
33#include "dex/dex_file_types.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070034#include "gc_root.h"
Andreas Gampe0f01b582017-01-18 15:22:37 -080035#include "handle.h"
Mathieu Chartier590fee92013-09-13 13:46:47 -070036#include "jni.h"
Vladimir Marko97d7e1c2016-10-04 14:44:28 +010037#include "mirror/class.h"
Andreas Gampe6d7abbd2017-04-24 13:19:09 -070038#include "verifier/verifier_enums.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070039
40namespace art {
Mingyao Yang98d1cc82014-05-15 17:02:16 -070041
Ian Rogers1d54e732013-05-02 21:10:01 -070042namespace gc {
43namespace space {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080044class ImageSpace;
Ian Rogers1d54e732013-05-02 21:10:01 -070045} // namespace space
46} // namespace gc
Vladimir Marko74527972016-11-29 15:57:32 +000047
48namespace linker {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080049struct CompilationHelper;
50class ImageWriter;
51class OatWriter;
Vladimir Marko74527972016-11-29 15:57:32 +000052} // namespace linker
53
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080054namespace mirror {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080055class ClassLoader;
56class DexCache;
57class DexCachePointerArray;
58class DexCacheMethodHandlesTest_Open_Test;
59class DexCacheTest_Open_Test;
60class IfTable;
61class MethodHandle;
62class MethodHandlesLookup;
63class MethodType;
64template<class T> class ObjectArray;
65class StackTraceElement;
66template <typename T> struct NativeDexCachePair;
67using MethodDexCachePair = NativeDexCachePair<ArtMethod>;
68using MethodDexCacheType = std::atomic<MethodDexCachePair>;
Ian Rogers33e95662013-05-20 20:29:14 -070069} // namespace mirror
Ian Rogers1d54e732013-05-02 21:10:01 -070070
Vladimir Marko09c5ca42018-05-31 15:15:31 +010071class ArtField;
72class ArtMethod;
Andreas Gampec1ac9ee2017-07-24 22:35:49 -070073class ClassHierarchyAnalysis;
Vladimir Markob4eb1b12018-05-24 11:09:38 +010074enum class ClassRoot : uint32_t;
Andreas Gampe2af99022017-04-25 08:32:59 -070075class ClassTable;
Andreas Gampe5a4b8a22014-09-11 08:30:08 -070076template<class T> class Handle;
Vladimir Marko97d7e1c2016-10-04 14:44:28 +010077class ImtConflictTable;
78template<typename T> class LengthPrefixedArray;
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -070079template<class T> class MutableHandle;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070080class InternTable;
Andreas Gamped482e732017-04-24 17:59:09 -070081class LinearAlloc;
Vladimir Marko1998cd02017-01-13 13:02:58 +000082class OatFile;
Mathieu Chartierc528dba2013-11-26 12:00:11 -080083template<class T> class ObjectLock;
Andreas Gampe7ba64962014-10-23 11:37:40 -070084class Runtime;
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070085class ScopedObjectAccessAlreadyRunnable;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -070086template<size_t kNumReferences> class PACKED(4) StackHandleScope;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070087
Mathieu Chartier893263b2014-03-04 11:07:42 -080088enum VisitRootFlags : uint8_t;
89
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -080090class ClassVisitor {
91 public:
92 virtual ~ClassVisitor() {}
93 // Return true to continue visiting.
Mathieu Chartier28357fa2016-10-18 16:27:40 -070094 virtual bool operator()(ObjPtr<mirror::Class> klass) = 0;
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -080095};
96
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -070097class ClassLoaderVisitor {
98 public:
99 virtual ~ClassLoaderVisitor() {}
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700100 virtual void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700101 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) = 0;
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -0700102};
103
Alexey Grebenkin252a4e42018-04-02 18:18:01 +0300104class AllocatorVisitor {
105 public:
106 virtual ~AllocatorVisitor() {}
107 // Return true to continue visiting.
108 virtual bool Visit(LinearAlloc* alloc)
109 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) = 0;
110};
111
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700112class ClassLinker {
113 public:
Mathieu Chartier0933cc52018-03-23 14:25:08 -0700114 static constexpr bool kAppImageMayContainStrings = false;
115
Mathieu Chartier590fee92013-09-13 13:46:47 -0700116 explicit ClassLinker(InternTable* intern_table);
Chang Xing605fe242017-07-20 15:57:21 -0700117 virtual ~ClassLinker();
Carl Shapiro565f5072011-07-10 13:39:43 -0700118
Alex Light64ad14d2014-08-19 14:23:13 -0700119 // Initialize class linker by bootstraping from dex files.
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800120 bool InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path,
121 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700122 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800123 REQUIRES(!Locks::dex_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700124
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800125 // Initialize class linker from one or more boot images.
126 bool InitFromBootImage(std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700127 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800128 REQUIRES(!Locks::dex_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700129
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800130 // Add an image space to the class linker, may fix up classloader fields and dex cache fields.
131 // The dex files that were newly opened for the space are placed in the out argument
132 // out_dex_files. Returns true if the operation succeeded.
133 // The space must be already added to the heap before calling AddImageSpace since we need to
134 // properly handle read barriers and object marking.
135 bool AddImageSpace(gc::space::ImageSpace* space,
136 Handle<mirror::ClassLoader> class_loader,
137 jobjectArray dex_elements,
138 const char* dex_location,
139 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
140 std::string* error_msg)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800141 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700142 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800143
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800144 bool OpenImageDexFiles(gc::space::ImageSpace* space,
145 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
146 std::string* error_msg)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800147 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700148 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800149
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700150 // Finds a class by its descriptor, loading it if necessary.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700151 // If class_loader is null, searches boot_class_path_.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100152 ObjPtr<mirror::Class> FindClass(Thread* self,
153 const char* descriptor,
154 Handle<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700155 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800156 REQUIRES(!Locks::dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700157
Ian Rogers98379392014-02-24 16:53:16 -0800158 // Finds a class by its descriptor using the "system" class loader, ie by searching the
159 // boot_class_path_.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100160 ObjPtr<mirror::Class> FindSystemClass(Thread* self, const char* descriptor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700161 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampec6ea7d02017-02-01 16:46:28 -0800162 REQUIRES(!Locks::dex_lock_) {
163 return FindClass(self, descriptor, ScopedNullHandle<mirror::ClassLoader>());
164 }
Ian Rogers98379392014-02-24 16:53:16 -0800165
166 // Finds the array class given for the element class.
Vladimir Markobcf17522018-06-01 13:14:32 +0100167 ObjPtr<mirror::Class> FindArrayClass(Thread* self, ObjPtr<mirror::Class> element_class)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700168 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800169 REQUIRES(!Locks::dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700170
Ian Rogers63557452014-06-04 16:57:15 -0700171 // Returns true if the class linker is initialized.
Ian Rogers7b078e82014-09-10 14:44:24 -0700172 bool IsInitialized() const {
173 return init_done_;
174 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700175
Brian Carlstromaded5f72011-10-07 17:15:04 -0700176 // Define a new a class based on a ClassDef from a DexFile
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100177 ObjPtr<mirror::Class> DefineClass(Thread* self,
178 const char* descriptor,
179 size_t hash,
180 Handle<mirror::ClassLoader> class_loader,
181 const DexFile& dex_file,
182 const DexFile::ClassDef& dex_class_def)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700183 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800184 REQUIRES(!Locks::dex_lock_);
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700185
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700186 // Finds a class by its descriptor, returning null if it isn't wasn't loaded
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700187 // by the given 'class_loader'.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100188 ObjPtr<mirror::Class> LookupClass(Thread* self,
189 const char* descriptor,
190 ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier90443472015-07-16 20:32:27 -0700191 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampe2ff3b972017-06-05 18:14:53 -0700192 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700193
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800194 // Finds all the classes with the given descriptor, regardless of ClassLoader.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700195 void LookupClasses(const char* descriptor, std::vector<ObjPtr<mirror::Class>>& classes)
Mathieu Chartier90443472015-07-16 20:32:27 -0700196 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700197 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800198
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100199 ObjPtr<mirror::Class> FindPrimitiveClass(char type) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700200
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700201 void DumpForSigQuit(std::ostream& os) REQUIRES(!Locks::classlinker_classes_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -0700202
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700203 size_t NumLoadedClasses()
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700204 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700205 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughese27955c2011-08-26 15:21:24 -0700206
Vladimir Marko18090d12018-06-01 16:53:12 +0100207 // Resolve a String with the given index from the DexFile associated with the given `referrer`,
208 // storing the result in the DexCache. The `referrer` is used to identify the target DexCache
209 // to use for resolution.
210 ObjPtr<mirror::String> ResolveString(dex::StringIndex string_idx,
211 ArtField* referrer)
212 REQUIRES_SHARED(Locks::mutator_lock_);
213 ObjPtr<mirror::String> ResolveString(dex::StringIndex string_idx,
214 ArtMethod* referrer)
215 REQUIRES_SHARED(Locks::mutator_lock_);
216
Vladimir Markoa64b52d2017-12-08 16:27:49 +0000217 // Resolve a String with the given index from the DexFile associated with the given DexCache,
218 // storing the result in the DexCache.
219 ObjPtr<mirror::String> ResolveString(dex::StringIndex string_idx,
Vladimir Marko28e012a2017-12-07 11:22:59 +0000220 Handle<mirror::DexCache> dex_cache)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700221 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700222
Vladimir Markoa64b52d2017-12-08 16:27:49 +0000223 // Find a String with the given index from the DexFile associated with the given DexCache,
224 // storing the result in the DexCache if found. Return null if not found.
225 ObjPtr<mirror::String> LookupString(dex::StringIndex string_idx,
Vladimir Marko28e012a2017-12-07 11:22:59 +0000226 ObjPtr<mirror::DexCache> dex_cache)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700227 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Markocac5a7e2016-02-22 10:39:50 +0000228
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000229 // Resolve a Type with the given index from the DexFile associated with the given `referrer`,
230 // storing the result in the DexCache. The `referrer` is used to identify the target DexCache
231 // and ClassLoader to use for resolution.
232 ObjPtr<mirror::Class> ResolveType(dex::TypeIndex type_idx, ObjPtr<mirror::Class> referrer)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700233 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800234 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Vladimir Marko09c5ca42018-05-31 15:15:31 +0100235 ObjPtr<mirror::Class> ResolveType(dex::TypeIndex type_idx, ArtField* referrer)
236 REQUIRES_SHARED(Locks::mutator_lock_)
237 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Vladimir Marko28e012a2017-12-07 11:22:59 +0000238 ObjPtr<mirror::Class> ResolveType(dex::TypeIndex type_idx, ArtMethod* referrer)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700239 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800240 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700241
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000242 // Resolve a type with the given index from the DexFile associated with the given DexCache
243 // and ClassLoader, storing the result in DexCache. The ClassLoader is used to search for
244 // the type, since it may be referenced from but not contained within the DexFile.
245 ObjPtr<mirror::Class> ResolveType(dex::TypeIndex type_idx,
Vladimir Marko28e012a2017-12-07 11:22:59 +0000246 Handle<mirror::DexCache> dex_cache,
247 Handle<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700248 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800249 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700250
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000251 // Look up a resolved type with the given index from the DexFile associated with the given
252 // `referrer`, storing the result in the DexCache. The `referrer` is used to identify the
253 // target DexCache and ClassLoader to use for lookup.
254 ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_idx,
255 ObjPtr<mirror::Class> referrer)
256 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Marko09c5ca42018-05-31 15:15:31 +0100257 ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_idx, ArtField* referrer)
258 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000259 ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_idx, ArtMethod* referrer)
260 REQUIRES_SHARED(Locks::mutator_lock_);
261
262 // Look up a resolved type with the given index from the DexFile associated with the given
263 // DexCache and ClassLoader. The ClassLoader is used to search for the type, since it may
264 // be referenced from but not contained within the DexFile.
265 ObjPtr<mirror::Class> LookupResolvedType(dex::TypeIndex type_idx,
266 ObjPtr<mirror::DexCache> dex_cache,
267 ObjPtr<mirror::ClassLoader> class_loader)
268 REQUIRES_SHARED(Locks::mutator_lock_);
269
Andreas Gampe42ef8ab2015-12-03 17:27:32 -0800270 // Determine whether a dex cache result should be trusted, or an IncompatibleClassChangeError
Vladimir Markoba118822017-06-12 15:41:56 +0100271 // check and IllegalAccessError check should be performed even after a hit.
272 enum class ResolveMode { // private.
273 kNoChecks,
274 kCheckICCEAndIAE
Andreas Gampe42ef8ab2015-12-03 17:27:32 -0800275 };
276
Vladimir Marko07bfbac2017-07-06 14:55:02 +0100277 // Look up a previously resolved method with the given index.
278 ArtMethod* LookupResolvedMethod(uint32_t method_idx,
279 ObjPtr<mirror::DexCache> dex_cache,
280 ObjPtr<mirror::ClassLoader> class_loader)
281 REQUIRES_SHARED(Locks::mutator_lock_);
282
Nicolas Geoffrayea179f42018-02-08 22:30:18 +0000283 // Find a method with the given index from class `klass`, and update the dex cache.
284 ArtMethod* FindResolvedMethod(ObjPtr<mirror::Class> klass,
285 ObjPtr<mirror::DexCache> dex_cache,
286 ObjPtr<mirror::ClassLoader> class_loader,
287 uint32_t method_idx)
288 REQUIRES_SHARED(Locks::mutator_lock_);
289
David Brazdil4525e0b2018-04-05 16:57:32 +0100290 // Find a method using the wrong lookup mechanism. If `klass` is an interface,
291 // search for a class method. If it is a class, search for an interface method.
292 // This is useful when throwing IncompatibleClassChangeError.
293 ArtMethod* FindIncompatibleMethod(ObjPtr<mirror::Class> klass,
294 ObjPtr<mirror::DexCache> dex_cache,
295 ObjPtr<mirror::ClassLoader> class_loader,
296 uint32_t method_idx)
297 REQUIRES_SHARED(Locks::mutator_lock_);
298
Vladimir Marko89011192017-12-11 13:45:05 +0000299 // Resolve a method with a given ID from the DexFile associated with the given DexCache
300 // and ClassLoader, storing the result in DexCache. The ClassLinker and ClassLoader are
301 // used as in ResolveType. What is unique is the method type argument which is used to
302 // determine if this method is a direct, static, or virtual method.
Andreas Gampe42ef8ab2015-12-03 17:27:32 -0800303 template <ResolveMode kResolveMode>
Vladimir Marko89011192017-12-11 13:45:05 +0000304 ArtMethod* ResolveMethod(uint32_t method_idx,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700305 Handle<mirror::DexCache> dex_cache,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700306 Handle<mirror::ClassLoader> class_loader,
307 ArtMethod* referrer,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700308 InvokeType type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700309 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800310 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700311
Vladimir Markoba118822017-06-12 15:41:56 +0100312 template <InvokeType type, ResolveMode kResolveMode>
Mathieu Chartiere401d142015-04-22 13:56:20 -0700313 ArtMethod* GetResolvedMethod(uint32_t method_idx, ArtMethod* referrer)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700314 REQUIRES_SHARED(Locks::mutator_lock_);
Alex Lightfedd91d2016-01-07 14:49:16 -0800315
Andreas Gampe42ef8ab2015-12-03 17:27:32 -0800316 template <ResolveMode kResolveMode>
Mathieu Chartiere401d142015-04-22 13:56:20 -0700317 ArtMethod* ResolveMethod(Thread* self, uint32_t method_idx, ArtMethod* referrer, InvokeType type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700318 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800319 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Vladimir Marko89011192017-12-11 13:45:05 +0000320 ArtMethod* ResolveMethodWithoutInvokeType(uint32_t method_idx,
Jeff Hao0042c6d2015-07-29 20:14:10 -0700321 Handle<mirror::DexCache> dex_cache,
322 Handle<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700323 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800324 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstrom16192862011-09-12 17:50:06 -0700325
Vladimir Markof44d36c2017-03-14 14:18:46 +0000326 ArtField* LookupResolvedField(uint32_t field_idx, ArtMethod* referrer, bool is_static)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700327 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700328 ArtField* ResolveField(uint32_t field_idx, ArtMethod* referrer, bool is_static)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700329 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800330 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700331
Vladimir Markoe11dd502017-12-08 14:09:45 +0000332 // Resolve a field with a given ID from the DexFile associated with the given DexCache
333 // and ClassLoader, storing the result in DexCache. The ClassLinker and ClassLoader
334 // are used as in ResolveType. What is unique is the is_static argument which is used
335 // to determine if we are resolving a static or non-static field.
336 ArtField* ResolveField(uint32_t field_idx,
Mathieu Chartier90443472015-07-16 20:32:27 -0700337 Handle<mirror::DexCache> dex_cache,
Vladimir Markoe11dd502017-12-08 14:09:45 +0000338 Handle<mirror::ClassLoader> class_loader,
339 bool is_static)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700340 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800341 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700342
Vladimir Markoe11dd502017-12-08 14:09:45 +0000343 // Resolve a field with a given ID from the DexFile associated with the given DexCache
344 // and ClassLoader, storing the result in DexCache. The ClassLinker and ClassLoader
345 // are used as in ResolveType. No is_static argument is provided so that Java
Ian Rogersb067ac22011-12-13 18:05:09 -0800346 // field resolution semantics are followed.
Vladimir Markoe11dd502017-12-08 14:09:45 +0000347 ArtField* ResolveFieldJLS(uint32_t field_idx,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700348 Handle<mirror::DexCache> dex_cache,
349 Handle<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700350 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800351 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Ian Rogersb067ac22011-12-13 18:05:09 -0800352
David Brazdil1ab0fa82018-05-04 11:28:03 +0100353 // Find a field with a given ID from the DexFile associated with the given DexCache
354 // and ClassLoader, storing the result in DexCache. The declaring class is assumed
355 // to have been already resolved into `klass`. The `is_static` argument is used to
356 // determine if we are resolving a static or non-static field.
357 ArtField* FindResolvedField(ObjPtr<mirror::Class> klass,
358 ObjPtr<mirror::DexCache> dex_cache,
359 ObjPtr<mirror::ClassLoader> class_loader,
360 uint32_t field_idx,
361 bool is_static)
362 REQUIRES_SHARED(Locks::mutator_lock_);
363
364 // Find a field with a given ID from the DexFile associated with the given DexCache
365 // and ClassLoader, storing the result in DexCache. The declaring class is assumed
366 // to have been already resolved into `klass`. No is_static argument is provided
367 // so that Java field resolution semantics are followed.
368 ArtField* FindResolvedFieldJLS(ObjPtr<mirror::Class> klass,
369 ObjPtr<mirror::DexCache> dex_cache,
370 ObjPtr<mirror::ClassLoader> class_loader,
371 uint32_t field_idx)
372 REQUIRES_SHARED(Locks::mutator_lock_);
373
Vladimir Markoaf940202017-12-08 15:01:18 +0000374 // Resolve a method type with a given ID from the DexFile associated with a given DexCache
375 // and ClassLoader, storing the result in the DexCache.
376 ObjPtr<mirror::MethodType> ResolveMethodType(Thread* self,
Orion Hodson06d10a72018-05-14 08:53:38 +0100377 dex::ProtoIndex proto_idx,
Vladimir Markoaf940202017-12-08 15:01:18 +0000378 Handle<mirror::DexCache> dex_cache,
379 Handle<mirror::ClassLoader> class_loader)
Narayan Kamath25352fc2016-08-03 12:46:58 +0100380 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800381 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Ian Rogersad25ac52011-10-04 19:13:33 -0700382
Vladimir Markoaf940202017-12-08 15:01:18 +0000383 ObjPtr<mirror::MethodType> ResolveMethodType(Thread* self,
Orion Hodson06d10a72018-05-14 08:53:38 +0100384 dex::ProtoIndex proto_idx,
Vladimir Markoaf940202017-12-08 15:01:18 +0000385 ArtMethod* referrer)
Orion Hodson2e599942017-09-22 16:17:41 +0100386 REQUIRES_SHARED(Locks::mutator_lock_);
387
Orion Hodsonc069a302017-01-18 09:23:12 +0000388 // Resolve a method handle with a given ID from the DexFile. The
389 // result is not cached in the DexCache as the instance will only be
390 // used once in most circumstances.
Vladimir Markoaf940202017-12-08 15:01:18 +0000391 ObjPtr<mirror::MethodHandle> ResolveMethodHandle(Thread* self,
392 uint32_t method_handle_idx,
393 ArtMethod* referrer)
Orion Hodsonc069a302017-01-18 09:23:12 +0000394 REQUIRES_SHARED(Locks::mutator_lock_);
395
Elliott Hughesf4c21c92011-08-19 17:31:31 -0700396 // Returns true on success, false if there's an exception pending.
Brian Carlstrom25c33252011-09-18 15:58:35 -0700397 // can_run_clinit=false allows the compiler to attempt to init a class,
398 // given the restriction that no <clinit> execution is possible.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700399 bool EnsureInitialized(Thread* self,
400 Handle<mirror::Class> c,
401 bool can_init_fields,
Ian Rogers7b078e82014-09-10 14:44:24 -0700402 bool can_init_parents)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700403 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800404 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700405
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700406 // Initializes classes that have instances in the image but that have
407 // <clinit> methods so they could not be initialized by the compiler.
Vladimir Markodcfcce42018-06-27 10:00:28 +0000408 void RunRootClinits(Thread* self)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700409 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800410 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700411
Alex Light07f06212017-06-01 14:01:43 -0700412 // Directly register an already existing dex cache. RegisterDexFile should be preferred since that
413 // reduplicates DexCaches when possible. The DexCache given to this function must already be fully
414 // initialized and not already registered.
415 void RegisterExistingDexCache(ObjPtr<mirror::DexCache> cache,
416 ObjPtr<mirror::ClassLoader> class_loader)
417 REQUIRES(!Locks::dex_lock_)
418 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +0000419 ObjPtr<mirror::DexCache> RegisterDexFile(const DexFile& dex_file,
420 ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800421 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700422 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700423
Brian Carlstrom8a487412011-08-29 20:08:52 -0700424 const std::vector<const DexFile*>& GetBootClassPath() {
425 return boot_class_path_;
426 }
427
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700428 void VisitClasses(ClassVisitor* visitor)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700429 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700430 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersdbf3be02014-08-29 15:40:08 -0700431
432 // Less efficient variant of VisitClasses that copies the class_table_ into secondary storage
433 // so that it can visit individual classes without holding the doesn't hold the
434 // Locks::classlinker_classes_lock_. As the Locks::classlinker_classes_lock_ isn't held this code
435 // can race with insertion and deletion of classes while the visitor is being called.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700436 void VisitClassesWithoutClassesLock(ClassVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700437 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800438 REQUIRES(!Locks::dex_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -0800439
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700440 void VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags)
Andreas Gamped98b4ed2016-11-04 20:27:24 -0700441 REQUIRES(!Locks::classlinker_classes_lock_, !Locks::trace_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700442 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700443 void VisitRoots(RootVisitor* visitor, VisitRootFlags flags)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800444 REQUIRES(!Locks::dex_lock_, !Locks::classlinker_classes_lock_, !Locks::trace_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700445 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700446
Vladimir Markocd556b02017-02-03 11:47:34 +0000447 bool IsDexFileRegistered(Thread* self, const DexFile& dex_file)
448 REQUIRES(!Locks::dex_lock_)
449 REQUIRES_SHARED(Locks::mutator_lock_);
450 ObjPtr<mirror::DexCache> FindDexCache(Thread* self, const DexFile& dex_file)
451 REQUIRES(!Locks::dex_lock_)
452 REQUIRES_SHARED(Locks::mutator_lock_);
453 ClassTable* FindClassTable(Thread* self, ObjPtr<mirror::DexCache> dex_cache)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800454 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700455 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom1d9f52b2011-10-13 10:50:45 -0700456
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700457 LengthPrefixedArray<ArtField>* AllocArtFieldArray(Thread* self,
458 LinearAlloc* allocator,
459 size_t length);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800460
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700461 LengthPrefixedArray<ArtMethod>* AllocArtMethodArray(Thread* self,
462 LinearAlloc* allocator,
463 size_t length);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700464
Vladimir Markobcf17522018-06-01 13:14:32 +0100465 ObjPtr<mirror::PointerArray> AllocPointerArray(Thread* self, size_t length)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700466 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700467 REQUIRES(!Roles::uninterruptible_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800468
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100469 ObjPtr<mirror::IfTable> AllocIfTable(Thread* self, size_t ifcount)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700470 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700471 REQUIRES(!Roles::uninterruptible_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800472
Vladimir Markobcf17522018-06-01 13:14:32 +0100473 ObjPtr<mirror::ObjectArray<mirror::StackTraceElement>> AllocStackTraceElementArray(Thread* self,
474 size_t length)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700475 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700476 REQUIRES(!Roles::uninterruptible_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800477
Andreas Gampe6d7abbd2017-04-24 13:19:09 -0700478 verifier::FailureKind VerifyClass(
Nicolas Geoffray08025182016-10-25 17:20:18 +0100479 Thread* self,
480 Handle<mirror::Class> klass,
481 verifier::HardFailLogMode log_level = verifier::HardFailLogMode::kLogNone)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700482 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800483 REQUIRES(!Locks::dex_lock_);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700484 bool VerifyClassUsingOatFile(const DexFile& dex_file,
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700485 ObjPtr<mirror::Class> klass,
Vladimir Marko2c64a832018-01-04 11:31:56 +0000486 ClassStatus& oat_file_class_status)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700487 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800488 REQUIRES(!Locks::dex_lock_);
Alex Light5a559862016-01-29 12:24:48 -0800489 void ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700490 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800491 REQUIRES(!Locks::dex_lock_);
Alex Light5a559862016-01-29 12:24:48 -0800492 void ResolveMethodExceptionHandlerTypes(ArtMethod* klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700493 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800494 REQUIRES(!Locks::dex_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800495
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100496 ObjPtr<mirror::Class> CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa,
497 jstring name,
498 jobjectArray interfaces,
499 jobject loader,
500 jobjectArray methods,
501 jobjectArray throws)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700502 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700503 std::string GetDescriptorForProxy(ObjPtr<mirror::Class> proxy_class)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700504 REQUIRES_SHARED(Locks::mutator_lock_);
Jesse Wilson95caa792011-10-12 18:14:17 -0400505
Alex Lightfc49fec2018-01-16 22:28:36 +0000506 // Get the oat code for a method when its class isn't yet initialized.
507 const void* GetQuickOatCodeFor(ArtMethod* method)
508 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800509
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700510 pid_t GetClassesLockOwner(); // For SignalCatcher.
511 pid_t GetDexLockOwner(); // For SignalCatcher.
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700512
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700513 // Is the given entry point quick code to run the resolution stub?
514 bool IsQuickResolutionStub(const void* entry_point) const;
Jeff Hao88474b42013-10-23 16:24:40 -0700515
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700516 // Is the given entry point quick code to bridge into the interpreter?
517 bool IsQuickToInterpreterBridge(const void* entry_point) const;
518
519 // Is the given entry point quick code to run the generic JNI stub?
520 bool IsQuickGenericJniStub(const void* entry_point) const;
Vladimir Marko8a630572014-04-09 18:45:35 +0100521
David Sehra49e0532017-08-25 08:05:29 -0700522 // Is the given entry point the JNI dlsym lookup stub?
523 bool IsJniDlsymLookupStub(const void* entry_point) const;
524
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100525 const void* GetQuickToInterpreterBridgeTrampoline() const {
526 return quick_to_interpreter_bridge_trampoline_;
527 }
528
Jeff Hao88474b42013-10-23 16:24:40 -0700529 InternTable* GetInternTable() const {
530 return intern_table_;
531 }
532
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700533 // Set the entrypoints up for method to the enter the interpreter.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700534 void SetEntryPointsToInterpreter(ArtMethod* method) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700535 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700536
Alex Lightdb01a092017-04-03 15:39:55 -0700537 // Set the entrypoints up for an obsolete method.
538 void SetEntryPointsForObsoleteMethod(ArtMethod* method) const
539 REQUIRES_SHARED(Locks::mutator_lock_);
540
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700541 // Attempts to insert a class into a class table. Returns null if
Ian Rogers848871b2013-08-05 10:56:33 -0700542 // the class was inserted, otherwise returns an existing class with
543 // the same descriptor and ClassLoader.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100544 ObjPtr<mirror::Class> InsertClass(const char* descriptor,
545 ObjPtr<mirror::Class> klass,
546 size_t hash)
Mathieu Chartier90443472015-07-16 20:32:27 -0700547 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700548 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers848871b2013-08-05 10:56:33 -0700549
Vladimir Marko1998cd02017-01-13 13:02:58 +0000550 // Add an oat file with .bss GC roots to be visited again at the end of GC
551 // for collector types that need it.
552 void WriteBarrierForBootOatFileBssRoots(const OatFile* oat_file)
553 REQUIRES(!Locks::classlinker_classes_lock_)
554 REQUIRES_SHARED(Locks::mutator_lock_);
555
Vladimir Markob4eb1b12018-05-24 11:09:38 +0100556 template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Vladimir Markobcf17522018-06-01 13:14:32 +0100557 ObjPtr<mirror::ObjectArray<mirror::Class>> GetClassRoots() REQUIRES_SHARED(Locks::mutator_lock_) {
558 ObjPtr<mirror::ObjectArray<mirror::Class>> class_roots =
559 class_roots_.Read<kReadBarrierOption>();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700560 DCHECK(class_roots != nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700561 return class_roots;
562 }
563
Mathieu Chartierc2e20622014-11-03 11:41:47 -0800564 // Move the class table to the pre-zygote table to reduce memory usage. This works by ensuring
565 // that no more classes are ever added to the pre zygote table which makes it that the pages
566 // always remain shared dirty instead of private dirty.
567 void MoveClassTableToPreZygote()
Mathieu Chartier90443472015-07-16 20:32:27 -0700568 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700569 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierc2e20622014-11-03 11:41:47 -0800570
Calin Juravle7865ac72017-06-28 11:03:12 -0700571 // Creates a GlobalRef PathClassLoader or DelegateLastClassLoader (specified by loader_class)
572 // that can be used to load classes from the given dex files. The parent of the class loader
573 // will be set to `parent_loader`. If `parent_loader` is null the parent will be
574 // the boot class loader.
575 // If class_loader points to a different class than PathClassLoader or DelegateLastClassLoader
576 // this method will abort.
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700577 // Note: the objects are not completely set up. Do not use this outside of tests and the compiler.
Calin Juravle7865ac72017-06-28 11:03:12 -0700578 jobject CreateWellKnownClassLoader(Thread* self,
579 const std::vector<const DexFile*>& dex_files,
580 jclass loader_class,
581 jobject parent_loader)
582 REQUIRES_SHARED(Locks::mutator_lock_)
583 REQUIRES(!Locks::dex_lock_);
584
585 // Calls CreateWellKnownClassLoader(self,
586 // dex_files,
587 // WellKnownClasses::dalvik_system_PathClassLoader,
588 // nullptr)
Jeff Haof0192c82016-03-28 20:39:50 -0700589 jobject CreatePathClassLoader(Thread* self, const std::vector<const DexFile*>& dex_files)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700590 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800591 REQUIRES(!Locks::dex_lock_);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700592
Andreas Gampe542451c2016-07-26 09:02:02 -0700593 PointerSize GetImagePointerSize() const {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700594 return image_pointer_size_;
595 }
596
597 // Used by image writer for checking.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700598 bool ClassInClassTable(ObjPtr<mirror::Class> klass)
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700599 REQUIRES(Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700600 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiera89d7ed2014-12-05 10:57:13 -0800601
Andreas Gampe8ac75952015-06-02 21:01:45 -0700602 // Clear the ArrayClass cache. This is necessary when cleaning up for the image, as the cache
603 // entries are roots, but potentially not image classes.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700604 void DropFindArrayClassCache() REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe8ac75952015-06-02 21:01:45 -0700605
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700606 // Clean up class loaders, this needs to happen after JNI weak globals are cleared.
607 void CleanupClassLoaders()
Mathieu Chartier00310e02015-10-17 12:46:42 -0700608 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700609 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700610
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700611 // Unlike GetOrCreateAllocatorForClassLoader, GetAllocatorForClassLoader asserts that the
612 // allocator for this class loader is already created.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700613 LinearAlloc* GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700614 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700615
Mathieu Chartierd57d4542015-10-14 10:55:30 -0700616 // Return the linear alloc for a class loader if it is already allocated, otherwise allocate and
617 // set it. TODO: Consider using a lock other than classlinker_classes_lock_.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700618 LinearAlloc* GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier00310e02015-10-17 12:46:42 -0700619 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700620 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier00310e02015-10-17 12:46:42 -0700621
Mathieu Chartier6d25cf62016-04-12 16:54:48 -0700622 // May be called with null class_loader due to legacy code. b/27954959
Mathieu Chartierbc5a7952016-10-17 15:46:31 -0700623 void InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file,
624 ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier00310e02015-10-17 12:46:42 -0700625 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700626 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierd57d4542015-10-14 10:55:30 -0700627
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +0000628 static bool ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700629 REQUIRES_SHARED(Locks::mutator_lock_);
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +0000630
Mathieu Chartierc5dd3192015-12-09 16:38:30 -0800631 std::set<DexCacheResolvedClasses> GetResolvedClasses(bool ignore_boot_classes)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800632 REQUIRES(!Locks::dex_lock_);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -0800633
Jeff Haof0192c82016-03-28 20:39:50 -0700634 static bool IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700635 ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700636 REQUIRES_SHARED(Locks::mutator_lock_);
Jeff Haof0192c82016-03-28 20:39:50 -0700637
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700638 ArtMethod* AddMethodToConflictTable(ObjPtr<mirror::Class> klass,
Mathieu Chartier7f98c9a2016-04-14 10:49:19 -0700639 ArtMethod* conflict_method,
640 ArtMethod* interface_method,
641 ArtMethod* method,
642 bool force_new_conflict_method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700643 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier7f98c9a2016-04-14 10:49:19 -0700644
Mathieu Chartiere42888f2016-04-14 10:49:19 -0700645 // Create a conflict table with a specified capacity.
646 ImtConflictTable* CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc);
647
648 // Static version for when the class linker is not yet created.
649 static ImtConflictTable* CreateImtConflictTable(size_t count,
650 LinearAlloc* linear_alloc,
Andreas Gampe542451c2016-07-26 09:02:02 -0700651 PointerSize pointer_size);
Mathieu Chartiere42888f2016-04-14 10:49:19 -0700652
653
654 // Create the IMT and conflict tables for a class.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700655 void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere42888f2016-04-14 10:49:19 -0700656
Mathieu Chartier72041a02017-07-14 18:23:25 -0700657 // Visit all of the class tables. This is used by dex2oat to allow pruning dex caches.
658 template <class Visitor>
659 void VisitClassTables(const Visitor& visitor)
Mathieu Chartier696632e2016-06-03 17:47:32 -0700660 REQUIRES(!Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700661 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere42888f2016-04-14 10:49:19 -0700662
Alexey Grebenkin252a4e42018-04-02 18:18:01 +0300663 // Visit all of the allocators that belong to classloaders except boot classloader.
664 // This is used by 616-cha-unloading test to confirm memory reuse.
665 void VisitAllocators(AllocatorVisitor* visitor) const
666 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
667
Jeff Haoc92a7a12016-06-06 11:09:20 -0700668 // Throw the class initialization failure recorded when first trying to initialize the given
669 // class.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700670 void ThrowEarlierClassFailure(ObjPtr<mirror::Class> c, bool wrap_in_no_class_def = false)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700671 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800672 REQUIRES(!Locks::dex_lock_);
Jeff Haoc92a7a12016-06-06 11:09:20 -0700673
Mathieu Chartier65975772016-08-05 10:46:36 -0700674 // Get the actual holding class for a copied method. Pretty slow, don't call often.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100675 ObjPtr<mirror::Class> GetHoldingClassOfCopiedMethod(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700676 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier65975772016-08-05 10:46:36 -0700677
Andreas Gampe70f16392017-01-16 14:20:10 -0800678 // Returns null if not found.
Andreas Gampe2af99022017-04-25 08:32:59 -0700679 // This returns a pointer to the class-table, without requiring any locking - including the
680 // boot class-table. It is the caller's responsibility to access this under lock, if required.
Andreas Gampe70f16392017-01-16 14:20:10 -0800681 ClassTable* ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampe2af99022017-04-25 08:32:59 -0700682 REQUIRES_SHARED(Locks::mutator_lock_)
683 NO_THREAD_SAFETY_ANALYSIS;
Andreas Gampe70f16392017-01-16 14:20:10 -0800684
Andreas Gampece7732b2017-01-17 15:50:26 -0800685 void AppendToBootClassPath(Thread* self, const DexFile& dex_file)
686 REQUIRES_SHARED(Locks::mutator_lock_)
687 REQUIRES(!Locks::dex_lock_);
688
Mathieu Chartier06bed302017-07-13 13:23:18 -0700689 // Visit all of the class loaders in the class linker.
690 void VisitClassLoaders(ClassLoaderVisitor* visitor) const
691 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
692
Jeff Hao0cb17282017-07-12 14:51:49 -0700693 // Checks that a class and its superclass from another class loader have the same virtual methods.
694 bool ValidateSuperClassDescriptors(Handle<mirror::Class> klass)
695 REQUIRES_SHARED(Locks::mutator_lock_);
696
Andreas Gampec1ac9ee2017-07-24 22:35:49 -0700697 ClassHierarchyAnalysis* GetClassHierarchyAnalysis() {
698 return cha_.get();
699 }
700
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800701 struct DexCacheData {
Vladimir Markocd556b02017-02-03 11:47:34 +0000702 // Construct an invalid data object.
703 DexCacheData()
704 : weak_root(nullptr),
705 dex_file(nullptr),
Vladimir Markocd556b02017-02-03 11:47:34 +0000706 class_table(nullptr) { }
707
708 // Check if the data is valid.
709 bool IsValid() const {
710 return dex_file != nullptr;
711 }
712
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800713 // Weak root to the DexCache. Note: Do not decode this unnecessarily or else class unloading may
714 // not work properly.
715 jweak weak_root;
Vladimir Markod1ee20f2017-08-17 09:21:16 +0000716 // The following field caches the DexCache's field here to avoid unnecessary jweak decode that
717 // triggers read barriers (and marks them alive unnecessarily and messes with class unloading.)
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800718 const DexFile* dex_file;
Vladimir Markocd556b02017-02-03 11:47:34 +0000719 // Identify the associated class loader's class table. This is used to make sure that
720 // the Java call to native DexCache.setResolvedType() inserts the resolved type in that
721 // class table. It is also used to make sure we don't register the same dex cache with
722 // multiple class loaders.
723 ClassTable* class_table;
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800724 };
725
Chang Xing605fe242017-07-20 15:57:21 -0700726 protected:
727 virtual bool InitializeClass(Thread* self,
728 Handle<mirror::Class> klass,
729 bool can_run_clinit,
730 bool can_init_parents)
731 REQUIRES_SHARED(Locks::mutator_lock_)
732 REQUIRES(!Locks::dex_lock_);
733
Mathieu Chartier9e050df2017-08-09 10:05:47 -0700734 virtual verifier::FailureKind PerformClassVerification(Thread* self,
735 Handle<mirror::Class> klass,
736 verifier::HardFailLogMode log_level,
737 std::string* error_msg)
738 REQUIRES_SHARED(Locks::mutator_lock_);
739
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700740 private:
Vladimir Marko921094a2017-01-12 18:37:06 +0000741 class LinkInterfaceMethodsHelper;
742
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700743 struct ClassLoaderData {
Mathieu Chartierc3fcd412015-09-25 16:54:59 -0700744 jweak weak_root; // Weak root to enable class unloading.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700745 ClassTable* class_table;
746 LinearAlloc* allocator;
747 };
748
Alex Lightf1f10492015-10-07 16:08:36 -0700749 // Ensures that the supertype of 'klass' ('supertype') is verified. Returns false and throws
750 // appropriate exceptions if verification failed hard. Returns true for successful verification or
751 // soft-failures.
752 bool AttemptSupertypeVerification(Thread* self,
753 Handle<mirror::Class> klass,
754 Handle<mirror::Class> supertype)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800755 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700756 REQUIRES_SHARED(Locks::mutator_lock_);
Alex Lightf1f10492015-10-07 16:08:36 -0700757
Alexey Grebenkinbe4c2bd2018-02-01 19:09:59 +0300758 void DeleteClassLoader(Thread* self, const ClassLoaderData& data, bool cleanup_cha)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700759 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100760
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700761 void VisitClassesInternal(ClassVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700762 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -0700763
764 // Returns the number of zygote and image classes.
Mathieu Chartier6b069532015-08-05 15:08:12 -0700765 size_t NumZygoteClasses() const
766 REQUIRES(Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700767 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -0700768
769 // Returns the number of non zygote nor image classes.
Mathieu Chartier6b069532015-08-05 15:08:12 -0700770 size_t NumNonZygoteClasses() const
771 REQUIRES(Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700772 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -0700773
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700774 void FinishInit(Thread* self)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700775 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800776 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700777
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700778 // For early bootstrapping by Init
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100779 ObjPtr<mirror::Class> AllocClass(Thread* self,
780 ObjPtr<mirror::Class> java_lang_Class,
781 uint32_t class_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700782 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700783 REQUIRES(!Roles::uninterruptible_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700784
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100785 // Alloc* convenience functions to avoid needing to pass in ObjPtr<mirror::Class>
786 // values that are known to the ClassLinker such as classes corresponding to
787 // ClassRoot::kObjectArrayClass and ClassRoot::kJavaLangString etc.
788 ObjPtr<mirror::Class> AllocClass(Thread* self, uint32_t class_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700789 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700790 REQUIRES(!Roles::uninterruptible_);
Mathieu Chartier6c60d842016-09-15 10:24:43 -0700791
Vladimir Markobcf17522018-06-01 13:14:32 +0100792 ObjPtr<mirror::DexCache> AllocDexCache(/*out*/ ObjPtr<mirror::String>* out_location,
793 Thread* self,
794 const DexFile& dex_file)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700795 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700796 REQUIRES(!Roles::uninterruptible_);
Ian Rogersbdb03912011-09-14 00:55:44 -0700797
Mathieu Chartier6c60d842016-09-15 10:24:43 -0700798 // Used for tests and AppendToBootClassPath.
Vladimir Markobcf17522018-06-01 13:14:32 +0100799 ObjPtr<mirror::DexCache> AllocAndInitializeDexCache(Thread* self,
800 const DexFile& dex_file,
801 LinearAlloc* linear_alloc)
Mathieu Chartier6c60d842016-09-15 10:24:43 -0700802 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800803 REQUIRES(!Locks::dex_lock_)
Mathieu Chartier6c60d842016-09-15 10:24:43 -0700804 REQUIRES(!Roles::uninterruptible_);
805
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100806 ObjPtr<mirror::Class> CreatePrimitiveClass(Thread* self, Primitive::Type type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700807 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700808 REQUIRES(!Roles::uninterruptible_);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700809
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100810 ObjPtr<mirror::Class> CreateArrayClass(Thread* self,
811 const char* descriptor,
812 size_t hash,
813 Handle<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700814 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800815 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700816
Vladimir Markocd556b02017-02-03 11:47:34 +0000817 void AppendToBootClassPath(const DexFile& dex_file, ObjPtr<mirror::DexCache> dex_cache)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700818 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800819 REQUIRES(!Locks::dex_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700820
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700821 // Precomputes size needed for Class, in the case of a non-temporary class this size must be
822 // sufficient to hold all static fields.
823 uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
824 const DexFile::ClassDef& dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -0700825
Mathieu Chartierc7853442015-03-27 14:35:38 -0700826 // Setup the classloader, class def index, type idx so that we can insert this class in the class
827 // table.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700828 void SetupClass(const DexFile& dex_file,
829 const DexFile::ClassDef& dex_class_def,
830 Handle<mirror::Class> klass,
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700831 ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700832 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierc7853442015-03-27 14:35:38 -0700833
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700834 void LoadClass(Thread* self,
835 const DexFile& dex_file,
836 const DexFile::ClassDef& dex_class_def,
Mathieu Chartierc7853442015-03-27 14:35:38 -0700837 Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700838 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700839
Mathieu Chartier1f1cb9f2018-06-04 09:22:46 -0700840 void LoadField(const ClassAccessor::Field& field, Handle<mirror::Class> klass, ArtField* dst)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700841 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700842
Mathieu Chartier268764d2016-09-13 12:09:38 -0700843 void LoadMethod(const DexFile& dex_file,
Mathieu Chartier1f1cb9f2018-06-04 09:22:46 -0700844 const ClassAccessor::Method& method,
845 Handle<mirror::Class> klass,
846 ArtMethod* dst)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700847 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700848
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700849 void FixupStaticTrampolines(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800850
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +0000851 // Finds a class in a Path- or DexClassLoader, loading it if necessary without using JNI. Hash
Andreas Gampe34ee6842014-12-02 15:43:52 -0800852 // function is supposed to be ComputeModifiedUtf8Hash(descriptor). Returns true if the
853 // class-loader chain could be handled, false otherwise, i.e., a non-supported class-loader
854 // was encountered while walking the parent chain (currently only BootClassLoader and
855 // PathClassLoader are supported).
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +0000856 bool FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
857 Thread* self,
858 const char* descriptor,
859 size_t hash,
860 Handle<mirror::ClassLoader> class_loader,
Vladimir Markobcf17522018-06-01 13:14:32 +0100861 /*out*/ ObjPtr<mirror::Class>* result)
Andreas Gampe34ee6842014-12-02 15:43:52 -0800862 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800863 REQUIRES(!Locks::dex_lock_);
Andreas Gampe34ee6842014-12-02 15:43:52 -0800864
Calin Juravle415dc3d2017-06-28 11:03:12 -0700865 // Finds the class in the classpath of the given class loader. It only searches the class loader
866 // dex files and does not recurse into its parent.
867 // The method checks that the provided class loader is either a PathClassLoader or a
868 // DexClassLoader.
869 // If the class is found the method returns the resolved class. Otherwise it returns null.
870 ObjPtr<mirror::Class> FindClassInBaseDexClassLoaderClassPath(
871 ScopedObjectAccessAlreadyRunnable& soa,
872 const char* descriptor,
873 size_t hash,
874 Handle<mirror::ClassLoader> class_loader)
875 REQUIRES_SHARED(Locks::mutator_lock_)
876 REQUIRES(!Locks::dex_lock_);
877
878 // Finds the class in the boot class loader.
879 // If the class is found the method returns the resolved class. Otherwise it returns null.
880 ObjPtr<mirror::Class> FindClassInBootClassLoaderClassPath(Thread* self,
881 const char* descriptor,
882 size_t hash)
883 REQUIRES_SHARED(Locks::mutator_lock_)
884 REQUIRES(!Locks::dex_lock_);
885
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000886 // Implementation of LookupResolvedType() called when the type was not found in the dex cache.
887 ObjPtr<mirror::Class> DoLookupResolvedType(dex::TypeIndex type_idx,
Vladimir Marko09c5ca42018-05-31 15:15:31 +0100888 ObjPtr<mirror::Class> referrer)
889 REQUIRES_SHARED(Locks::mutator_lock_);
890 ObjPtr<mirror::Class> DoLookupResolvedType(dex::TypeIndex type_idx,
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000891 ObjPtr<mirror::DexCache> dex_cache,
892 ObjPtr<mirror::ClassLoader> class_loader)
893 REQUIRES_SHARED(Locks::mutator_lock_);
894
Vladimir Marko18090d12018-06-01 16:53:12 +0100895 // Implementation of ResolveString() called when the string was not found in the dex cache.
896 ObjPtr<mirror::String> DoResolveString(dex::StringIndex string_idx,
897 ObjPtr<mirror::DexCache> dex_cache)
898 REQUIRES_SHARED(Locks::mutator_lock_);
899 ObjPtr<mirror::String> DoResolveString(dex::StringIndex string_idx,
900 Handle<mirror::DexCache> dex_cache)
901 REQUIRES_SHARED(Locks::mutator_lock_);
902
903 // Implementation of LookupString() called when the string was not found in the dex cache.
904 ObjPtr<mirror::String> DoLookupString(dex::StringIndex string_idx,
905 ObjPtr<mirror::DexCache> dex_cache)
906 REQUIRES_SHARED(Locks::mutator_lock_);
907
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000908 // Implementation of ResolveType() called when the type was not found in the dex cache.
909 ObjPtr<mirror::Class> DoResolveType(dex::TypeIndex type_idx,
Vladimir Marko09c5ca42018-05-31 15:15:31 +0100910 ObjPtr<mirror::Class> referrer)
911 REQUIRES_SHARED(Locks::mutator_lock_)
912 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
913 ObjPtr<mirror::Class> DoResolveType(dex::TypeIndex type_idx,
Vladimir Marko666ee3d2017-12-11 18:37:36 +0000914 Handle<mirror::DexCache> dex_cache,
915 Handle<mirror::ClassLoader> class_loader)
916 REQUIRES_SHARED(Locks::mutator_lock_)
917 REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
918
Andreas Gampe34ee6842014-12-02 15:43:52 -0800919 // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
920 // by the given 'class_loader'. Uses the provided hash for the descriptor.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +0100921 ObjPtr<mirror::Class> LookupClass(Thread* self,
922 const char* descriptor,
923 size_t hash,
924 ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampe34ee6842014-12-02 15:43:52 -0800925 REQUIRES(!Locks::classlinker_classes_lock_)
926 REQUIRES_SHARED(Locks::mutator_lock_);
927
Vladimir Markof44d36c2017-03-14 14:18:46 +0000928 // Find a field by its field index.
929 ArtField* LookupResolvedField(uint32_t field_idx,
930 ObjPtr<mirror::DexCache> dex_cache,
931 ObjPtr<mirror::ClassLoader> class_loader,
932 bool is_static)
933 REQUIRES_SHARED(Locks::mutator_lock_);
934
Vladimir Markocd556b02017-02-03 11:47:34 +0000935 void RegisterDexFileLocked(const DexFile& dex_file,
936 ObjPtr<mirror::DexCache> dex_cache,
937 ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800938 REQUIRES(Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700939 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +0000940 DexCacheData FindDexCacheDataLocked(const DexFile& dex_file)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800941 REQUIRES(Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700942 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +0000943 static ObjPtr<mirror::DexCache> DecodeDexCache(Thread* self, const DexCacheData& data)
944 REQUIRES_SHARED(Locks::mutator_lock_);
945 // Called to ensure that the dex cache has been registered with the same class loader.
946 // If yes, returns the dex cache, otherwise throws InternalError and returns null.
947 ObjPtr<mirror::DexCache> EnsureSameClassLoader(Thread* self,
948 ObjPtr<mirror::DexCache> dex_cache,
949 const DexCacheData& data,
950 ObjPtr<mirror::ClassLoader> class_loader)
951 REQUIRES(!Locks::dex_lock_)
952 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700953
Alex Lighteb7c1442015-08-31 13:17:42 -0700954 bool InitializeDefaultInterfaceRecursive(Thread* self,
955 Handle<mirror::Class> klass,
956 bool can_run_clinit,
957 bool can_init_parents)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800958 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700959 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700960 bool WaitForInitializeClass(Handle<mirror::Class> klass,
961 Thread* self,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700962 ObjectLock<mirror::Class>& lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700963
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700964 bool IsSameDescriptorInDifferentClassContexts(Thread* self,
965 const char* descriptor,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700966 Handle<mirror::ClassLoader> class_loader1,
967 Handle<mirror::ClassLoader> class_loader2)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700968 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700969
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700970 bool IsSameMethodSignatureInDifferentClassContexts(Thread* self,
971 ArtMethod* method,
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700972 ObjPtr<mirror::Class> klass1,
973 ObjPtr<mirror::Class> klass2)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700974 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700975
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700976 bool LinkClass(Thread* self,
977 const char* descriptor,
978 Handle<mirror::Class> klass,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700979 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700980 MutableHandle<mirror::Class>* h_new_class_out)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700981 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700982 REQUIRES(!Locks::classlinker_classes_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700983
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700984 bool LinkSuperClass(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700985 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700986
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700987 bool LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700988 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800989 REQUIRES(!Locks::dex_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700990
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -0700991 bool LinkMethods(Thread* self,
992 Handle<mirror::Class> klass,
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700993 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +0000994 bool* out_new_conflict,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700995 ArtMethod** out_imt)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700996 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700997
Orion Hodsonf8db2c32017-07-07 20:07:12 +0100998 mirror::MethodHandle* ResolveMethodHandleForField(Thread* self,
999 const DexFile::MethodHandleItem& method_handle,
1000 ArtMethod* referrer)
1001 REQUIRES_SHARED(Locks::mutator_lock_);
1002
1003 mirror::MethodHandle* ResolveMethodHandleForMethod(Thread* self,
Orion Hodsonf8db2c32017-07-07 20:07:12 +01001004 const DexFile::MethodHandleItem& method_handle,
1005 ArtMethod* referrer)
1006 REQUIRES_SHARED(Locks::mutator_lock_);
1007
Alex Light9139e002015-10-09 15:59:48 -07001008 // A wrapper class representing the result of a method translation used for linking methods and
1009 // updating superclass default methods. For each method in a classes vtable there are 4 states it
1010 // could be in:
1011 // 1) No translation is necessary. In this case there is no MethodTranslation object for it. This
1012 // is the standard case and is true when the method is not overridable by a default method,
1013 // the class defines a concrete implementation of the method, the default method implementation
1014 // remains the same, or an abstract method stayed abstract.
1015 // 2) The method must be translated to a different default method. We note this with
1016 // CreateTranslatedMethod.
1017 // 3) The method must be replaced with a conflict method. This happens when a superclass
1018 // implements an interface with a default method and this class implements an unrelated
1019 // interface that also defines that default method. We note this with CreateConflictingMethod.
1020 // 4) The method must be replaced with an abstract miranda method. This happens when a superclass
1021 // implements an interface with a default method and this class implements a subinterface of
1022 // the superclass's interface which declares the default method abstract. We note this with
1023 // CreateAbstractMethod.
1024 //
1025 // When a method translation is unnecessary (case #1), we don't put it into the
1026 // default_translation maps. So an instance of MethodTranslation must be in one of #2-#4.
1027 class MethodTranslation {
1028 public:
1029 // This slot must become a default conflict method.
1030 static MethodTranslation CreateConflictingMethod() {
1031 return MethodTranslation(Type::kConflict, /*translation*/nullptr);
1032 }
1033
1034 // This slot must become an abstract method.
1035 static MethodTranslation CreateAbstractMethod() {
1036 return MethodTranslation(Type::kAbstract, /*translation*/nullptr);
1037 }
1038
1039 // Use the given method as the current value for this vtable slot during translation.
1040 static MethodTranslation CreateTranslatedMethod(ArtMethod* new_method) {
1041 return MethodTranslation(Type::kTranslation, new_method);
1042 }
1043
1044 // Returns true if this is a method that must become a conflict method.
1045 bool IsInConflict() const {
1046 return type_ == Type::kConflict;
1047 }
1048
1049 // Returns true if this is a method that must become an abstract method.
1050 bool IsAbstract() const {
1051 return type_ == Type::kAbstract;
1052 }
1053
1054 // Returns true if this is a method that must become a different method.
1055 bool IsTranslation() const {
1056 return type_ == Type::kTranslation;
1057 }
1058
1059 // Get the translated version of this method.
1060 ArtMethod* GetTranslation() const {
1061 DCHECK(IsTranslation());
1062 DCHECK(translation_ != nullptr);
1063 return translation_;
1064 }
1065
1066 private:
1067 enum class Type {
1068 kTranslation,
1069 kConflict,
1070 kAbstract,
1071 };
1072
1073 MethodTranslation(Type type, ArtMethod* translation)
1074 : translation_(translation), type_(type) {}
1075
1076 ArtMethod* const translation_;
1077 const Type type_;
1078 };
1079
Alex Lighteb7c1442015-08-31 13:17:42 -07001080 // Links the virtual methods for the given class and records any default methods that will need to
1081 // be updated later.
1082 //
1083 // Arguments:
1084 // * self - The current thread.
1085 // * klass - class, whose vtable will be filled in.
1086 // * default_translations - Vtable index to new method map.
1087 // Any vtable entries that need to be updated with new default methods
1088 // are stored into the default_translations map. The default_translations
1089 // map is keyed on the vtable index that needs to be updated. We use this
1090 // map because if we override a default method with another default
1091 // method we need to update the vtable to point to the new method.
1092 // Unfortunately since we copy the ArtMethod* we cannot just do a simple
1093 // scan, we therefore store the vtable index's that might need to be
1094 // updated with the method they will turn into.
1095 // TODO This whole default_translations thing is very dirty. There should be a better way.
Alex Light9139e002015-10-09 15:59:48 -07001096 bool LinkVirtualMethods(
1097 Thread* self,
1098 Handle<mirror::Class> klass,
1099 /*out*/std::unordered_map<size_t, MethodTranslation>* default_translations)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001100 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001101
Alex Lighteb7c1442015-08-31 13:17:42 -07001102 // Sets up the interface lookup table (IFTable) in the correct order to allow searching for
1103 // default methods.
1104 bool SetupInterfaceLookupTable(Thread* self,
1105 Handle<mirror::Class> klass,
1106 Handle<mirror::ObjectArray<mirror::Class>> interfaces)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001107 REQUIRES_SHARED(Locks::mutator_lock_);
Alex Lighteb7c1442015-08-31 13:17:42 -07001108
Alex Light9139e002015-10-09 15:59:48 -07001109
1110 enum class DefaultMethodSearchResult {
1111 kDefaultFound,
1112 kAbstractFound,
1113 kDefaultConflict
1114 };
1115
Alex Lighteb7c1442015-08-31 13:17:42 -07001116 // Find the default method implementation for 'interface_method' in 'klass', if one exists.
1117 //
1118 // Arguments:
1119 // * self - The current thread.
1120 // * target_method - The method we are trying to find a default implementation for.
1121 // * klass - The class we are searching for a definition of target_method.
1122 // * out_default_method - The pointer we will store the found default method to on success.
Alex Lighteb7c1442015-08-31 13:17:42 -07001123 //
1124 // Return value:
Alex Light9139e002015-10-09 15:59:48 -07001125 // * kDefaultFound - There were no conflicting method implementations found in the class while
1126 // searching for target_method. The default method implementation is stored into
1127 // out_default_method.
1128 // * kAbstractFound - There were no conflicting method implementations found in the class while
1129 // searching for target_method but no default implementation was found either.
1130 // out_default_method is set to null and the method should be considered not
1131 // implemented.
1132 // * kDefaultConflict - Conflicting method implementations were found when searching for
1133 // target_method. The value of *out_default_method is null.
1134 DefaultMethodSearchResult FindDefaultMethodImplementation(
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00001135 Thread* self,
1136 ArtMethod* target_method,
1137 Handle<mirror::Class> klass,
1138 /*out*/ArtMethod** out_default_method) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001139 REQUIRES_SHARED(Locks::mutator_lock_);
Alex Lighteb7c1442015-08-31 13:17:42 -07001140
1141 // Sets the imt entries and fixes up the vtable for the given class by linking all the interface
1142 // methods. See LinkVirtualMethods for an explanation of what default_translations is.
Alex Light9139e002015-10-09 15:59:48 -07001143 bool LinkInterfaceMethods(
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00001144 Thread* self,
1145 Handle<mirror::Class> klass,
1146 const std::unordered_map<size_t, MethodTranslation>& default_translations,
1147 bool* out_new_conflict,
1148 ArtMethod** out_imt)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001149 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001150
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001151 bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001152 REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07001153 bool LinkInstanceFields(Thread* self, Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001154 REQUIRES_SHARED(Locks::mutator_lock_);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001155 bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001156 REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07001157 void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001158 REQUIRES_SHARED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001159
Mathieu Chartiere401d142015-04-22 13:56:20 -07001160 void CheckProxyConstructor(ArtMethod* constructor) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001161 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001162 void CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001163 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001164
Andreas Gampecc1b5352016-12-01 16:58:38 -08001165 size_t GetDexCacheCount() REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07001166 return dex_caches_.size();
1167 }
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001168 const std::list<DexCacheData>& GetDexCachesData()
Andreas Gampecc1b5352016-12-01 16:58:38 -08001169 REQUIRES_SHARED(Locks::mutator_lock_, Locks::dex_lock_) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001170 return dex_caches_;
1171 }
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001172
Mathieu Chartiere401d142015-04-22 13:56:20 -07001173 void CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001174 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001175 void CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, ArtMethod* out)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001176 REQUIRES_SHARED(Locks::mutator_lock_);
Jesse Wilson95caa792011-10-12 18:14:17 -04001177
Mathieu Chartier5b830502016-03-02 10:30:23 -08001178 // Register a class loader and create its class table and allocator. Should not be called if
1179 // these are already created.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001180 void RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001181 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartier5b830502016-03-02 10:30:23 -08001182 REQUIRES(Locks::classlinker_classes_lock_);
1183
Nicolas Geoffray3a090922015-11-24 09:17:30 +00001184 // Insert a new class table if not found.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001185 ClassTable* InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001186 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07001187 REQUIRES(Locks::classlinker_classes_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001188
Ian Rogersdbf3be02014-08-29 15:40:08 -07001189 // EnsureResolved is called to make sure that a class in the class_table_ has been resolved
1190 // before returning it to the caller. Its the responsibility of the thread that placed the class
1191 // in the table to make it resolved. The thread doing resolution must notify on the class' lock
1192 // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may
1193 // retire a class, the version of the class in the table is returned and this may differ from
1194 // the class passed in.
Vladimir Markoa8bba7d2018-05-30 15:18:48 +01001195 ObjPtr<mirror::Class> EnsureResolved(Thread* self,
1196 const char* descriptor,
1197 ObjPtr<mirror::Class> klass)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07001198 WARN_UNUSED
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001199 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampecc1b5352016-12-01 16:58:38 -08001200 REQUIRES(!Locks::dex_lock_);
Ian Rogersdbf3be02014-08-29 15:40:08 -07001201
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001202 void FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class,
1203 ObjPtr<mirror::Class> new_class)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001204 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersdbf3be02014-08-29 15:40:08 -07001205
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001206 void SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001207 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001208
1209 // Return the quick generic JNI stub for testing.
1210 const void* GetRuntimeQuickGenericJniStub() const;
1211
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001212 bool CanWeInitializeClass(ObjPtr<mirror::Class> klass,
1213 bool can_init_statics,
1214 bool can_init_parents)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001215 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001216
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001217 void UpdateClassMethods(ObjPtr<mirror::Class> klass,
Alex Lighte64300b2015-12-15 15:02:47 -08001218 LengthPrefixedArray<ArtMethod>* new_methods)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001219 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001220 REQUIRES(!Locks::classlinker_classes_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001221
Andreas Gampe7ba5a672016-02-04 21:45:01 -08001222 // Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise.
1223 void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor)
Andreas Gampecc1b5352016-12-01 16:58:38 -08001224 REQUIRES(!Locks::dex_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001225 REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe7ba5a672016-02-04 21:45:01 -08001226
Vladimir Marko921094a2017-01-12 18:37:06 +00001227 // Allocate method arrays for interfaces.
1228 bool AllocateIfTableMethodArrays(Thread* self,
1229 Handle<mirror::Class> klass,
1230 Handle<mirror::IfTable> iftable)
1231 REQUIRES_SHARED(Locks::mutator_lock_);
1232
Mathieu Chartier7f98c9a2016-04-14 10:49:19 -07001233 // Sets imt_ref appropriately for LinkInterfaceMethods.
1234 // If there is no method in the imt location of imt_ref it will store the given method there.
1235 // Otherwise it will set the conflict method which will figure out which method to use during
1236 // runtime.
1237 void SetIMTRef(ArtMethod* unimplemented_method,
1238 ArtMethod* imt_conflict_method,
1239 ArtMethod* current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00001240 /*out*/bool* new_conflict,
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001241 /*out*/ArtMethod** imt_ref) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier7f98c9a2016-04-14 10:49:19 -07001242
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001243 void FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table,
Mathieu Chartiere42888f2016-04-14 10:49:19 -07001244 ArtMethod* unimplemented_method,
1245 ArtMethod* imt_conflict_method,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001246 ObjPtr<mirror::Class> klass,
Mathieu Chartiere42888f2016-04-14 10:49:19 -07001247 bool create_conflict_tables,
1248 bool ignore_copied_methods,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00001249 /*out*/bool* new_conflict,
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001250 /*out*/ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier7f98c9a2016-04-14 10:49:19 -07001251
1252 void FillImtFromSuperClass(Handle<mirror::Class> klass,
1253 ArtMethod* unimplemented_method,
1254 ArtMethod* imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00001255 bool* new_conflict,
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001256 ArtMethod** imt) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier7f98c9a2016-04-14 10:49:19 -07001257
Vladimir Markoba118822017-06-12 15:41:56 +01001258 // Check invoke type against the referenced class. Throws IncompatibleClassChangeError
1259 // (if `kThrowOnError`) and returns true on mismatch (kInterface on a non-interface class,
1260 // kVirtual on interface, kDefault on interface for dex files not supporting default methods),
1261 // otherwise returns false.
1262 template <bool kThrowOnError, typename ClassGetter>
1263 static bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache,
1264 InvokeType type,
1265 ClassGetter class_getter)
1266 REQUIRES_SHARED(Locks::mutator_lock_);
1267 // Helper that feeds the above function with `ClassGetter` doing `LookupResolvedType()`.
1268 template <bool kThrow>
1269 bool CheckInvokeClassMismatch(ObjPtr<mirror::DexCache> dex_cache,
1270 InvokeType type,
1271 uint32_t method_idx,
1272 ObjPtr<mirror::ClassLoader> class_loader)
1273 REQUIRES_SHARED(Locks::mutator_lock_);
1274
Vladimir Marko02610552018-06-04 14:38:00 +01001275 ObjPtr<mirror::IfTable> GetArrayIfTable() REQUIRES_SHARED(Locks::mutator_lock_);
1276
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001277 std::vector<const DexFile*> boot_class_path_;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001278 std::vector<std::unique_ptr<const DexFile>> boot_dex_files_;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001279
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001280 // JNI weak globals and side data to allow dex caches to get unloaded. We lazily delete weak
1281 // globals when we register new dex files.
Andreas Gampecc1b5352016-12-01 16:58:38 -08001282 std::list<DexCacheData> dex_caches_ GUARDED_BY(Locks::dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001283
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001284 // This contains the class loaders which have class tables. It is populated by
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07001285 // InsertClassTableForClassLoader.
1286 std::list<ClassLoaderData> class_loaders_
Mathieu Chartier6b069532015-08-05 15:08:12 -07001287 GUARDED_BY(Locks::classlinker_classes_lock_);
1288
1289 // Boot class path table. Since the class loader for this is null.
Andreas Gampe2af99022017-04-25 08:32:59 -07001290 std::unique_ptr<ClassTable> boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001291
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001292 // New class roots, only used by CMS since the GC needs to mark these in the pause.
1293 std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001294
Vladimir Marko1998cd02017-01-13 13:02:58 +00001295 // Boot image oat files with new .bss GC roots to be visited in the pause by CMS.
1296 std::vector<const OatFile*> new_bss_roots_boot_oat_files_
1297 GUARDED_BY(Locks::classlinker_classes_lock_);
1298
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001299 // Number of times we've searched dex caches for a class. After a certain number of misses we move
1300 // the classes into the class_table_ to avoid dex cache based searches.
Ian Rogers68b56852014-08-29 20:19:11 -07001301 Atomic<uint32_t> failed_dex_cache_class_lookups_;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001302
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001303 // Well known mirror::Class roots.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001304 GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001305
Ian Rogers98379392014-02-24 16:53:16 -08001306 // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
1307 // descriptors for the sake of performing FindClass.
1308 static constexpr size_t kFindArrayCacheSize = 16;
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001309 GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize];
Ian Rogers98379392014-02-24 16:53:16 -08001310 size_t find_array_class_cache_next_victim_;
1311
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001312 bool init_done_;
Vladimir Marko1998cd02017-01-13 13:02:58 +00001313 bool log_new_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001314
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001315 InternTable* intern_table_;
1316
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001317 // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single
1318 // patch point within the image. TODO: make these proper relocations.
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001319 const void* quick_resolution_trampoline_;
Jeff Hao88474b42013-10-23 16:24:40 -07001320 const void* quick_imt_conflict_trampoline_;
Andreas Gampe2da88232014-02-27 12:26:20 -08001321 const void* quick_generic_jni_trampoline_;
Vladimir Marko8a630572014-04-09 18:45:35 +01001322 const void* quick_to_interpreter_bridge_trampoline_;
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001323
Mathieu Chartier2d721012014-11-10 11:08:06 -08001324 // Image pointer size.
Andreas Gampe542451c2016-07-26 09:02:02 -07001325 PointerSize image_pointer_size_;
Mathieu Chartier2d721012014-11-10 11:08:06 -08001326
Andreas Gampec1ac9ee2017-07-24 22:35:49 -07001327 std::unique_ptr<ClassHierarchyAnalysis> cha_;
1328
Mathieu Chartier65975772016-08-05 10:46:36 -07001329 class FindVirtualMethodHolderVisitor;
Andreas Gampe2af99022017-04-25 08:32:59 -07001330
1331 friend class AppImageClassLoadersAndDexCachesHelper;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001332 friend class ImageDumper; // for DexLock
Vladimir Marko74527972016-11-29 15:57:32 +00001333 friend struct linker::CompilationHelper; // For Compile in ImageTest.
1334 friend class linker::ImageWriter; // for GetClassRoots
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001335 friend class JniCompilerTest; // for GetRuntimeQuickGenericJniStub
Andreas Gampe5f4a09a2015-09-28 13:16:33 -07001336 friend class JniInternalTest; // for GetRuntimeQuickGenericJniStub
Andreas Gampe2af99022017-04-25 08:32:59 -07001337 friend class VMClassLoader; // for LookupClass and FindClassInBaseDexClassLoader.
Mathieu Chartier76172162016-01-26 14:54:06 -08001338 ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName); // for DexLock, and RegisterDexFileLocked
Narayan Kamath25352fc2016-08-03 12:46:58 +01001339 ART_FRIEND_TEST(mirror::DexCacheMethodHandlesTest, Open); // for AllocDexCache
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001340 ART_FRIEND_TEST(mirror::DexCacheTest, Open); // for AllocDexCache
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001341 DISALLOW_COPY_AND_ASSIGN(ClassLinker);
1342};
1343
Andreas Gampe0f01b582017-01-18 15:22:37 -08001344class ClassLoadCallback {
1345 public:
1346 virtual ~ClassLoadCallback() {}
1347
Alex Lightb0f11922017-01-23 14:25:17 -08001348 // If set we will replace initial_class_def & initial_dex_file with the final versions. The
1349 // callback author is responsible for ensuring these are allocated in such a way they can be
1350 // cleaned up if another transformation occurs. Note that both must be set or null/unchanged on
1351 // return.
1352 // Note: the class may be temporary, in which case a following ClassPrepare event will be a
1353 // different object. It is the listener's responsibility to handle this.
1354 // Note: This callback is rarely useful so a default implementation has been given that does
1355 // nothing.
1356 virtual void ClassPreDefine(const char* descriptor ATTRIBUTE_UNUSED,
1357 Handle<mirror::Class> klass ATTRIBUTE_UNUSED,
1358 Handle<mirror::ClassLoader> class_loader ATTRIBUTE_UNUSED,
1359 const DexFile& initial_dex_file ATTRIBUTE_UNUSED,
1360 const DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
1361 /*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED,
Alex Light4b0cedf2017-01-24 11:15:20 -08001362 /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED)
Alex Lightb0f11922017-01-23 14:25:17 -08001363 REQUIRES_SHARED(Locks::mutator_lock_) {}
1364
Andreas Gampe0f01b582017-01-18 15:22:37 -08001365 // A class has been loaded.
1366 // Note: the class may be temporary, in which case a following ClassPrepare event will be a
1367 // different object. It is the listener's responsibility to handle this.
1368 virtual void ClassLoad(Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1369
1370 // A class has been prepared, i.e., resolved. As the ClassLoad event might have been for a
1371 // temporary class, provide both the former and the current class.
1372 virtual void ClassPrepare(Handle<mirror::Class> temp_klass,
1373 Handle<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1374};
1375
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001376} // namespace art
1377
Brian Carlstromfc0e3212013-07-17 14:40:12 -07001378#endif // ART_RUNTIME_CLASS_LINKER_H_