blob: 7afa6a1d85e3fa59f582708e5910cedc44a810b2 [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
Fred Shih37f05ef2014-07-16 18:38:08 -070020#include <deque>
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080021#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070022#include <utility>
23#include <vector>
24
Mathieu Chartierbad02672014-08-25 13:08:22 -070025#include "base/allocator.h"
Elliott Hughes76160052012-12-12 16:31:20 -080026#include "base/macros.h"
Elliott Hughes76b61672012-12-12 17:47:30 -080027#include "base/mutex.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070028#include "dex_file.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070029#include "gc_root.h"
Elliott Hughese5448b52012-01-18 16:44:06 -080030#include "gtest/gtest.h"
Mathieu Chartier590fee92013-09-13 13:46:47 -070031#include "jni.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070032#include "oat_file.h"
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080033#include "object_callbacks.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070034
35namespace art {
Mingyao Yang98d1cc82014-05-15 17:02:16 -070036
Ian Rogers1d54e732013-05-02 21:10:01 -070037namespace gc {
38namespace space {
39 class ImageSpace;
40} // namespace space
41} // namespace gc
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080042namespace mirror {
Ian Rogers33e95662013-05-20 20:29:14 -070043 class ClassLoader;
44 class DexCache;
45 class DexCacheTest_Open_Test;
46 class IfTable;
47 template<class T> class ObjectArray;
48 class StackTraceElement;
49} // namespace mirror
Ian Rogers1d54e732013-05-02 21:10:01 -070050
Mathieu Chartierbf99f772014-08-23 16:37:27 -070051template<class T> class ConstHandle;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070052class InternTable;
Mathieu Chartierc528dba2013-11-26 12:00:11 -080053template<class T> class ObjectLock;
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070054class ScopedObjectAccessAlreadyRunnable;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070055template<class T> class Handle;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070056
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080057typedef bool (ClassVisitor)(mirror::Class* c, void* arg);
Elliott Hughesa2155262011-11-16 16:26:58 -080058
Mathieu Chartier893263b2014-03-04 11:07:42 -080059enum VisitRootFlags : uint8_t;
60
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070061class ClassLinker {
62 public:
Mathieu Chartier590fee92013-09-13 13:46:47 -070063 explicit ClassLinker(InternTable* intern_table);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070064 ~ClassLinker();
Carl Shapiro565f5072011-07-10 13:39:43 -070065
Alex Light64ad14d2014-08-19 14:23:13 -070066 // Initialize class linker by bootstraping from dex files.
67 void InitWithoutImage(const std::vector<const DexFile*>& boot_class_path)
Mathieu Chartier590fee92013-09-13 13:46:47 -070068 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
69
70 // Initialize class linker from one or more images.
71 void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
72
Elliott Hughes64bf5a32011-09-20 14:43:12 -070073 // Finds a class by its descriptor, loading it if necessary.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070074 // If class_loader is null, searches boot_class_path_.
Ian Rogers98379392014-02-24 16:53:16 -080075 mirror::Class* FindClass(Thread* self, const char* descriptor,
Mathieu Chartierbf99f772014-08-23 16:37:27 -070076 ConstHandle<mirror::ClassLoader> class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -070077 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -070078
Ian Rogers98379392014-02-24 16:53:16 -080079 // Finds a class by its descriptor using the "system" class loader, ie by searching the
80 // boot_class_path_.
81 mirror::Class* FindSystemClass(Thread* self, const char* descriptor)
82 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
83
84 // Finds the array class given for the element class.
Mathieu Chartierb74cd292014-05-29 14:31:33 -070085 mirror::Class* FindArrayClass(Thread* self, mirror::Class** element_class)
Ian Rogersb726dcb2012-09-05 08:57:23 -070086 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -070087
Ian Rogers63557452014-06-04 16:57:15 -070088 // Returns true if the class linker is initialized.
Mathieu Chartier590fee92013-09-13 13:46:47 -070089 bool IsInitialized() const;
90
Brian Carlstromaded5f72011-10-07 17:15:04 -070091 // Define a new a class based on a ClassDef from a DexFile
Mathieu Chartierc528dba2013-11-26 12:00:11 -080092 mirror::Class* DefineClass(const char* descriptor,
Mathieu Chartierbf99f772014-08-23 16:37:27 -070093 ConstHandle<mirror::ClassLoader> class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080094 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
Ian Rogersb726dcb2012-09-05 08:57:23 -070095 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes64bf5a32011-09-20 14:43:12 -070096
97 // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
98 // by the given 'class_loader'.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080099 mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700100 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
101 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700102
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800103 // Finds all the classes with the given descriptor, regardless of ClassLoader.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800104 void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700105 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
106 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800107
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800108 mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700109
Brian Carlstromae826982011-11-09 01:33:42 -0800110 // General class unloading is not supported, this is used to prune
111 // unwanted classes during image writing.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800112 bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700113 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
114 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -0800115
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700116 void DumpAllClasses(int flags)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700117 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
118 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700119
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700120 void DumpForSigQuit(std::ostream& os)
121 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
122 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -0700123
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700124 size_t NumLoadedClasses()
125 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
126 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughese27955c2011-08-26 15:21:24 -0700127
Brian Carlstromb63ec392011-08-27 17:38:27 -0700128 // Resolve a String with the given index from the DexFile, storing the
Brian Carlstromaded5f72011-10-07 17:15:04 -0700129 // result in the DexCache. The referrer is used to identify the
130 // target DexCache and ClassLoader to use for resolution.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800131 mirror::String* ResolveString(uint32_t string_idx, mirror::ArtMethod* referrer)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800132 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700133
134 // Resolve a String with the given index from the DexFile, storing the
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700135 // result in the DexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800136 mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700137 ConstHandle<mirror::DexCache> dex_cache)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700138 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700139
Brian Carlstromb63ec392011-08-27 17:38:27 -0700140 // Resolve a Type with the given index from the DexFile, storing the
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700141 // result in the DexCache. The referrer is used to identity the
142 // target DexCache and ClassLoader to use for resolution.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800143 mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, mirror::Class* referrer)
Mathieu Chartier590fee92013-09-13 13:46:47 -0700144 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700145
Brian Carlstromb63ec392011-08-27 17:38:27 -0700146 // Resolve a Type with the given index from the DexFile, storing the
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700147 // result in the DexCache. The referrer is used to identify the
Brian Carlstromb63ec392011-08-27 17:38:27 -0700148 // target DexCache and ClassLoader to use for resolution.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800149 mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtMethod* referrer)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800150 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700151
Ian Rogersef7d42f2014-01-06 12:55:46 -0800152 mirror::Class* ResolveType(uint16_t type_idx, mirror::ArtField* referrer)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800153 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromb63ec392011-08-27 17:38:27 -0700154
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700155 // Resolve a type with the given ID from the DexFile, storing the
156 // result in DexCache. The ClassLoader is used to search for the
157 // type, since it may be referenced from but not contained within
158 // the given DexFile.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700159 mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700160 ConstHandle<mirror::DexCache> dex_cache,
161 ConstHandle<mirror::ClassLoader> class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700162 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700163
164 // Resolve a method with a given ID from the DexFile, storing the
165 // result in DexCache. The ClassLinker and ClassLoader are used as
166 // in ResolveType. What is unique is the method type argument which
167 // is used to determine if this method is a direct, static, or
168 // virtual method.
Brian Carlstromea46f952013-07-30 01:26:50 -0700169 mirror::ArtMethod* ResolveMethod(const DexFile& dex_file,
170 uint32_t method_idx,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700171 ConstHandle<mirror::DexCache> dex_cache,
172 ConstHandle<mirror::ClassLoader> class_loader,
173 ConstHandle<mirror::ArtMethod> referrer,
Brian Carlstromea46f952013-07-30 01:26:50 -0700174 InvokeType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700175 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700176
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700177 mirror::ArtMethod* GetResolvedMethod(uint32_t method_idx, mirror::ArtMethod* referrer,
178 InvokeType type)
179 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
180 mirror::ArtMethod* ResolveMethod(Thread* self, uint32_t method_idx, mirror::ArtMethod** referrer,
Brian Carlstromea46f952013-07-30 01:26:50 -0700181 InvokeType type)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800182 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom16192862011-09-12 17:50:06 -0700183
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700184 mirror::ArtField* GetResolvedField(uint32_t field_idx, mirror::Class* field_declaring_class)
185 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800186 mirror::ArtField* ResolveField(uint32_t field_idx, mirror::ArtMethod* referrer,
Brian Carlstromea46f952013-07-30 01:26:50 -0700187 bool is_static)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800188 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700189
Brian Carlstrom16192862011-09-12 17:50:06 -0700190 // Resolve a field with a given ID from the DexFile, storing the
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700191 // result in DexCache. The ClassLinker and ClassLoader are used as
192 // in ResolveType. What is unique is the is_static argument which is
193 // used to determine if we are resolving a static or non-static
194 // field.
Brian Carlstromea46f952013-07-30 01:26:50 -0700195 mirror::ArtField* ResolveField(const DexFile& dex_file,
196 uint32_t field_idx,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700197 ConstHandle<mirror::DexCache> dex_cache,
198 ConstHandle<mirror::ClassLoader> class_loader,
Brian Carlstromea46f952013-07-30 01:26:50 -0700199 bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700200 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700201
Ian Rogersb067ac22011-12-13 18:05:09 -0800202 // Resolve a field with a given ID from the DexFile, storing the
203 // result in DexCache. The ClassLinker and ClassLoader are used as
204 // in ResolveType. No is_static argument is provided so that Java
205 // field resolution semantics are followed.
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700206 mirror::ArtField* ResolveFieldJLS(const DexFile& dex_file, uint32_t field_idx,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700207 ConstHandle<mirror::DexCache> dex_cache,
208 ConstHandle<mirror::ClassLoader> class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700209 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersb067ac22011-12-13 18:05:09 -0800210
Ian Rogersad25ac52011-10-04 19:13:33 -0700211 // Get shorty from method index without resolution. Used to do handlerization.
Brian Carlstromea46f952013-07-30 01:26:50 -0700212 const char* MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer, uint32_t* length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700213 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersad25ac52011-10-04 19:13:33 -0700214
Elliott Hughesf4c21c92011-08-19 17:31:31 -0700215 // Returns true on success, false if there's an exception pending.
Brian Carlstrom25c33252011-09-18 15:58:35 -0700216 // can_run_clinit=false allows the compiler to attempt to init a class,
217 // given the restriction that no <clinit> execution is possible.
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700218 bool EnsureInitialized(ConstHandle<mirror::Class> c, bool can_init_fields, bool can_init_parents)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700219 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700220
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700221 // Initializes classes that have instances in the image but that have
222 // <clinit> methods so they could not be initialized by the compiler.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700223 void RunRootClinits() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700224
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700225 void RegisterDexFile(const DexFile& dex_file)
226 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700227 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700228 void RegisterDexFile(const DexFile& dex_file, ConstHandle<mirror::DexCache> dex_cache)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700229 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700230 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700231
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700232 const OatFile* RegisterOatFile(const OatFile* oat_file)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700233 LOCKS_EXCLUDED(dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800234
Brian Carlstrom8a487412011-08-29 20:08:52 -0700235 const std::vector<const DexFile*>& GetBootClassPath() {
236 return boot_class_path_;
237 }
238
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700239 void VisitClasses(ClassVisitor* visitor, void* arg)
Ian Rogersdbf3be02014-08-29 15:40:08 -0700240 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700241 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersdbf3be02014-08-29 15:40:08 -0700242
243 // Less efficient variant of VisitClasses that copies the class_table_ into secondary storage
244 // so that it can visit individual classes without holding the doesn't hold the
245 // Locks::classlinker_classes_lock_. As the Locks::classlinker_classes_lock_ isn't held this code
246 // can race with insertion and deletion of classes while the visitor is being called.
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700247 void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg)
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700248 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -0800249
Mathieu Chartier52e4b432014-06-10 11:22:31 -0700250 void VisitClassRoots(RootCallback* callback, void* arg, VisitRootFlags flags)
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700251 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
252 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier893263b2014-03-04 11:07:42 -0800253 void VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags)
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700254 LOCKS_EXCLUDED(dex_lock_)
255 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700256
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700257 mirror::DexCache* FindDexCache(const DexFile& dex_file)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700258 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700259 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700260 bool IsDexFileRegistered(const DexFile& dex_file)
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700261 LOCKS_EXCLUDED(dex_lock_) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700262 void FixupDexCaches(mirror::ArtMethod* resolution_method)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700263 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700264 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1d9f52b2011-10-13 10:50:45 -0700265
jeffhao262bf462011-10-20 18:36:32 -0700266 // Generate an oat file from a dex file
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700267 bool GenerateOatFile(const char* dex_filename,
Brian Carlstromd601af82012-01-06 10:15:19 -0800268 int oat_fd,
Vladimir Marko60836d52014-01-16 15:53:38 +0000269 const char* oat_cache_filename,
Ian Rogers719d1a32014-03-06 12:13:39 -0800270 std::string* error_msg)
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700271 LOCKS_EXCLUDED(Locks::mutator_lock_);
jeffhao262bf462011-10-20 18:36:32 -0700272
Andreas Gampe833a4852014-05-21 18:46:59 -0700273 // Find or create the oat file holding dex_location. Then load all corresponding dex files
274 // (if multidex) into the given vector.
275 bool OpenDexFilesFromOat(const char* dex_location, const char* oat_location,
276 std::vector<std::string>* error_msgs,
277 std::vector<const DexFile*>* dex_files)
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700278 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
jeffhaof6174e82012-01-31 16:14:17 -0800279
Alex Light6e183f22014-07-18 14:57:04 -0700280 // Returns true if the given oat file has the same image checksum as the image it is paired with.
281 static bool VerifyOatImageChecksum(const OatFile* oat_file, const InstructionSet instruction_set);
282 // Returns true if the oat file checksums match with the image and the offsets are such that it
283 // could be loaded with it.
284 static bool VerifyOatChecksums(const OatFile* oat_file, const InstructionSet instruction_set,
285 std::string* error_msg);
Brian Carlstrom28db0122012-10-18 16:20:41 -0700286 // Returns true if oat file contains the dex file with the given location and checksum.
Alex Light6e183f22014-07-18 14:57:04 -0700287 static bool VerifyOatAndDexFileChecksums(const OatFile* oat_file,
288 const char* dex_location,
289 uint32_t dex_location_checksum,
290 InstructionSet instruction_set,
291 std::string* error_msg);
Brian Carlstromafe25512012-06-27 17:02:58 -0700292
Ian Rogersc0542af2014-09-03 16:16:56 -0700293 // Allocate an instance of a java.lang.Object.
294 mirror::Object* AllocObject(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
295
Elliott Hughes418d20f2011-09-22 14:00:39 -0700296 // TODO: replace this with multiple methods that allocate the correct managed type.
Shih-wei Liao44175362011-08-28 16:59:17 -0700297 template <class T>
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800298 mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700299 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700300
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800301 mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700302 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
jeffhao98eacac2011-09-14 16:11:53 -0700303
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800304 mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700305 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800306
Brian Carlstromea46f952013-07-30 01:26:50 -0700307 mirror::ObjectArray<mirror::ArtMethod>* AllocArtMethodArray(Thread* self, size_t length)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800308 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
309
310 mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
311 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
312
Brian Carlstromea46f952013-07-30 01:26:50 -0700313 mirror::ObjectArray<mirror::ArtField>* AllocArtFieldArray(Thread* self, size_t length)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800314 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
315
316 mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
317 size_t length)
318 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
319
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700320 void VerifyClass(ConstHandle<mirror::Class> klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800321 bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
322 mirror::Class::Status& oat_file_class_status)
323 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800324 void ResolveClassExceptionHandlerTypes(const DexFile& dex_file,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700325 ConstHandle<mirror::Class> klass)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800326 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromea46f952013-07-30 01:26:50 -0700327 void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::ArtMethod* klass)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800328 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
329
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700330 mirror::Class* CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name,
331 jobjectArray interfaces, jobject loader, jobjectArray methods,
332 jobjectArray throws)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800333 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800334 std::string GetDescriptorForProxy(mirror::Class* proxy_class)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800335 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800336 mirror::ArtMethod* FindMethodForProxy(mirror::Class* proxy_class,
337 mirror::ArtMethod* proxy_method)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700338 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700339 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jesse Wilson95caa792011-10-12 18:14:17 -0400340
Ian Rogers19846512012-02-24 11:42:47 -0800341 // Get the oat code for a method when its class isn't yet initialized
Ian Rogersef7d42f2014-01-06 12:55:46 -0800342 const void* GetQuickOatCodeFor(mirror::ArtMethod* method)
343 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
344 const void* GetPortableOatCodeFor(mirror::ArtMethod* method, bool* have_portable_code)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700345 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800346
Mathieu Chartiere35517a2012-10-30 18:49:55 -0700347 // Get the oat code for a method from a method index.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800348 const void* GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
349 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
350 const void* GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
Ian Rogers33e95662013-05-20 20:29:14 -0700351 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartiere35517a2012-10-30 18:49:55 -0700352
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700353 // Get compiled code for a method, return null if no code
354 // exists. This is unlike Get..OatCodeFor which will return a bridge
355 // or interpreter entrypoint.
356 const void* GetOatMethodQuickCodeFor(mirror::ArtMethod* method)
357 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
358 const void* GetOatMethodPortableCodeFor(mirror::ArtMethod* method)
359 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
360
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700361 pid_t GetClassesLockOwner(); // For SignalCatcher.
362 pid_t GetDexLockOwner(); // For SignalCatcher.
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700363
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700364 const void* GetPortableResolutionTrampoline() const {
365 return portable_resolution_trampoline_;
366 }
367
Andreas Gampe2da88232014-02-27 12:26:20 -0800368 const void* GetQuickGenericJniTrampoline() const {
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700369 return quick_generic_jni_trampoline_;
370 }
Andreas Gampe2da88232014-02-27 12:26:20 -0800371
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700372 const void* GetQuickResolutionTrampoline() const {
373 return quick_resolution_trampoline_;
374 }
375
Jeff Hao88474b42013-10-23 16:24:40 -0700376 const void* GetPortableImtConflictTrampoline() const {
377 return portable_imt_conflict_trampoline_;
378 }
379
380 const void* GetQuickImtConflictTrampoline() const {
381 return quick_imt_conflict_trampoline_;
382 }
383
Vladimir Marko8a630572014-04-09 18:45:35 +0100384 const void* GetQuickToInterpreterBridgeTrampoline() const {
385 return quick_to_interpreter_bridge_trampoline_;
386 }
387
Jeff Hao88474b42013-10-23 16:24:40 -0700388 InternTable* GetInternTable() const {
389 return intern_table_;
390 }
391
Ian Rogers848871b2013-08-05 10:56:33 -0700392 // Attempts to insert a class into a class table. Returns NULL if
393 // the class was inserted, otherwise returns an existing class with
394 // the same descriptor and ClassLoader.
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700395 mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash)
Ian Rogers848871b2013-08-05 10:56:33 -0700396 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
397 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
398
Mathieu Chartier590fee92013-09-13 13:46:47 -0700399 // Special code to allocate an art method, use this instead of class->AllocObject.
400 mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700401
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700402 mirror::ObjectArray<mirror::Class>* GetClassRoots() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700403 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700404 DCHECK(class_roots != NULL);
405 return class_roots;
406 }
407
Mathieu Chartier590fee92013-09-13 13:46:47 -0700408 private:
Ian Rogers97b52f82014-08-14 11:34:07 -0700409 const OatFile::OatMethod FindOatMethodFor(mirror::ArtMethod* method, bool* found)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700410 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
TDYa12785321912012-04-01 15:24:56 -0700411
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700412 OatFile& GetImageOatFile(gc::space::ImageSpace* space)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700413 LOCKS_EXCLUDED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700414 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700415
Ian Rogers98379392014-02-24 16:53:16 -0800416 void FinishInit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700417
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700418 // For early bootstrapping by Init
Ian Rogers6fac4472014-02-25 17:01:10 -0800419 mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, uint32_t class_size)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700420 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700421
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800422 // Alloc* convenience functions to avoid needing to pass in mirror::Class*
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700423 // values that are known to the ClassLinker such as
424 // kObjectArrayClass and kJavaLangString etc.
Ian Rogers6fac4472014-02-25 17:01:10 -0800425 mirror::Class* AllocClass(Thread* self, uint32_t class_size)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800426 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800427 mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700428 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromea46f952013-07-30 01:26:50 -0700429 mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersbdb03912011-09-14 00:55:44 -0700430
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800431 mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
432 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
433 mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700434 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700435
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700436
Ian Rogers98379392014-02-24 16:53:16 -0800437 mirror::Class* CreateArrayClass(Thread* self, const char* descriptor,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700438 ConstHandle<mirror::ClassLoader> class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700439 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700440
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700441 void AppendToBootClassPath(const DexFile& dex_file)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700442 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700443 void AppendToBootClassPath(const DexFile& dex_file, ConstHandle<mirror::DexCache> dex_cache)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700444 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700445
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700446 // Precomputes size needed for Class, in the case of a non-temporary class this size must be
447 // sufficient to hold all static fields.
448 uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
449 const DexFile::ClassDef& dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -0700450
Brian Carlstromf615a612011-07-23 12:50:34 -0700451 void LoadClass(const DexFile& dex_file,
452 const DexFile::ClassDef& dex_class_def,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700453 ConstHandle<mirror::Class> klass,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800454 mirror::ClassLoader* class_loader)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700455 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100456 void LoadClassMembers(const DexFile& dex_file,
457 const byte* class_data,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700458 ConstHandle<mirror::Class> klass,
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100459 mirror::ClassLoader* class_loader,
460 const OatFile::OatClass* oat_class)
461 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700462
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800463 void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700464 ConstHandle<mirror::Class> klass, ConstHandle<mirror::ArtField> dst)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800465 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700466
Brian Carlstromea46f952013-07-30 01:26:50 -0700467 mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file,
468 const ClassDataItemIterator& dex_method,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700469 ConstHandle<mirror::Class> klass)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800470 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700471
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800472 void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800473
Ian Rogers97b52f82014-08-14 11:34:07 -0700474 // Finds the associated oat class for a dex_file and descriptor. Returns an invalid OatClass on
475 // error and sets found to false.
476 OatFile::OatClass FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, bool* found)
Ian Rogers33e95662013-05-20 20:29:14 -0700477 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800478
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700479 void RegisterDexFileLocked(const DexFile& dex_file, ConstHandle<mirror::DexCache> dex_cache)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700480 EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700481 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700482 bool IsDexFileRegisteredLocked(const DexFile& dex_file)
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700483 SHARED_LOCKS_REQUIRED(dex_lock_, Locks::mutator_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700484
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700485 bool InitializeClass(ConstHandle<mirror::Class> klass, bool can_run_clinit,
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800486 bool can_init_parents)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700487 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700488 bool WaitForInitializeClass(ConstHandle<mirror::Class> klass, Thread* self,
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800489 ObjectLock<mirror::Class>& lock);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700490 bool ValidateSuperClassDescriptors(ConstHandle<mirror::Class> klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700491 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700492
Ian Rogers98379392014-02-24 16:53:16 -0800493 bool IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor,
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700494 ConstHandle<mirror::ClassLoader> class_loader1,
495 ConstHandle<mirror::ClassLoader> class_loader2)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700496 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700497
Ian Rogers98379392014-02-24 16:53:16 -0800498 bool IsSameMethodSignatureInDifferentClassContexts(Thread* self, mirror::ArtMethod* method,
Ian Rogersef7d42f2014-01-06 12:55:46 -0800499 mirror::Class* klass1,
500 mirror::Class* klass2)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700501 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700502
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700503 bool LinkClass(Thread* self, const char* descriptor, ConstHandle<mirror::Class> klass,
504 ConstHandle<mirror::ObjectArray<mirror::Class>> interfaces,
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700505 mirror::Class** new_class)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700506 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700507
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700508 bool LinkSuperClass(ConstHandle<mirror::Class> klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700509 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700510
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700511 bool LoadSuperAndInterfaces(ConstHandle<mirror::Class> klass, const DexFile& dex_file)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700512 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700513
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700514 bool LinkMethods(Thread* self, ConstHandle<mirror::Class> klass,
515 ConstHandle<mirror::ObjectArray<mirror::Class>> interfaces)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700516 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700517
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700518 bool LinkVirtualMethods(Thread* self, ConstHandle<mirror::Class> klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700519 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700520
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700521 bool LinkInterfaceMethods(ConstHandle<mirror::Class> klass,
522 ConstHandle<mirror::ObjectArray<mirror::Class>> interfaces)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700523 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700524
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700525 bool LinkStaticFields(ConstHandle<mirror::Class> klass, size_t* class_size)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700526 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700527 bool LinkInstanceFields(ConstHandle<mirror::Class> klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700528 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700529 bool LinkFields(ConstHandle<mirror::Class> klass, bool is_static, size_t* class_size)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700530 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700531 void LinkCode(ConstHandle<mirror::ArtMethod> method, const OatFile::OatClass* oat_class,
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700532 const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index)
533 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700534 void CreateReferenceInstanceOffsets(ConstHandle<mirror::Class> klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700535 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mingyao Yangfaff0f02014-09-10 12:03:22 -0700536 void CreateReferenceOffsets(ConstHandle<mirror::Class> klass, uint32_t reference_offsets)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700537 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700538
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700539 // For use by ImageWriter to find DexCaches for its roots
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700540 ReaderWriterMutex* DexLock()
541 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCK_RETURNED(dex_lock_) {
542 return &dex_lock_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700543 }
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700544 size_t GetDexCacheCount() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_) {
545 return dex_caches_.size();
546 }
547 mirror::DexCache* GetDexCache(size_t idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700548
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100549 const OatFile::OatDexFile* FindOpenedOatDexFileForDexFile(const DexFile& dex_file)
Ian Rogers33e95662013-05-20 20:29:14 -0700550 LOCKS_EXCLUDED(dex_lock_)
551 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Andreas Gampe833a4852014-05-21 18:46:59 -0700552
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100553 // Find an opened oat dex file that contains dex_location. If oat_location is not nullptr,
554 // the file must have that location, else any oat location is accepted.
555 const OatFile::OatDexFile* FindOpenedOatDexFile(const char* oat_location,
556 const char* dex_location,
557 const uint32_t* dex_location_checksum)
Ian Rogers719d1a32014-03-06 12:13:39 -0800558 LOCKS_EXCLUDED(dex_lock_);
Alex Lighta59dd802014-07-02 16:28:08 -0700559
560 // Will open the oat file directly without relocating, even if we could/should do relocation.
561 const OatFile* FindOatFileFromOatLocation(const std::string& oat_location,
562 std::string* error_msg)
563 LOCKS_EXCLUDED(dex_lock_);
564
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700565 const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700566 LOCKS_EXCLUDED(dex_lock_);
Andreas Gampe833a4852014-05-21 18:46:59 -0700567
Alex Lighta59dd802014-07-02 16:28:08 -0700568 const OatFile* OpenOatFileFromDexLocation(const std::string& dex_location,
569 InstructionSet isa,
570 bool* already_opened,
571 bool* obsolete_file_cleanup_failed,
572 std::vector<std::string>* error_msg)
573 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
574
Alex Light9dcc4572014-08-14 14:16:26 -0700575 const OatFile* GetInterpretedOnlyOat(const std::string& oat_path,
576 InstructionSet isa,
577 std::string* error_msg);
578
Alex Lighta59dd802014-07-02 16:28:08 -0700579 const OatFile* PatchAndRetrieveOat(const std::string& input, const std::string& output,
580 const std::string& image_location, InstructionSet isa,
581 std::string* error_msg)
582 LOCKS_EXCLUDED(Locks::mutator_lock_);
583
584 bool CheckOatFile(const OatFile* oat_file, InstructionSet isa,
585 bool* checksum_verified, std::string* error_msg);
586 int32_t GetRequiredDelta(const OatFile* oat_file, InstructionSet isa);
587
Andreas Gampe833a4852014-05-21 18:46:59 -0700588 // Note: will not register the oat file.
589 const OatFile* FindOatFileInOatLocationForDexFile(const char* dex_location,
590 uint32_t dex_location_checksum,
591 const char* oat_location,
592 std::string* error_msg)
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700593 LOCKS_EXCLUDED(dex_lock_);
Ian Rogerse3359f72013-06-11 15:14:11 -0700594
Andreas Gampe833a4852014-05-21 18:46:59 -0700595 // Creates the oat file from the dex_location to the oat_location. Needs a file descriptor for
596 // the file to be written, which is assumed to be under a lock.
597 const OatFile* CreateOatFileForDexLocation(const char* dex_location,
598 int fd, const char* oat_location,
599 std::vector<std::string>* error_msgs)
600 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
601
602 // Finds an OatFile that contains a DexFile for the given a DexFile location.
603 //
604 // Note 1: this will not check open oat files, which are assumed to be stale when this is run.
605 // Note 2: Does not register the oat file. It is the caller's job to register if the file is to
606 // be kept.
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100607 const OatFile* FindOatFileContainingDexFileFromDexLocation(const char* dex_location,
608 const uint32_t* dex_location_checksum,
Andreas Gampe833a4852014-05-21 18:46:59 -0700609 InstructionSet isa,
Calin Juravlec54aea72014-07-16 14:45:03 +0100610 std::vector<std::string>* error_msgs,
611 bool* obsolete_file_cleanup_failed)
Andreas Gampe833a4852014-05-21 18:46:59 -0700612 LOCKS_EXCLUDED(dex_lock_, Locks::mutator_lock_);
613
Calin Juravle621962a2014-09-02 15:53:55 +0100614 // Verifies:
615 // - that the oat file contains the dex file (with a matching checksum, which may be null if the
616 // file was pre-opted)
617 // - the checksums of the oat file (against the image space)
618 // - the checksum of the dex file against dex_location_checksum
619 // - that the dex file can be opened
620 // Returns true iff all verification succeed.
621 //
622 // The dex_location is the dex location as stored in the oat file header.
623 // (see DexFile::GetDexCanonicalLocation for a description of location conventions)
Alex Lighta59dd802014-07-02 16:28:08 -0700624 bool VerifyOatWithDexFile(const OatFile* oat_file, const char* dex_location,
Calin Juravle621962a2014-09-02 15:53:55 +0100625 const uint32_t* dex_location_checksum,
Alex Lighta59dd802014-07-02 16:28:08 -0700626 std::string* error_msg);
Brian Carlstromfad71432011-10-16 20:25:10 -0700627
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700628 mirror::ArtMethod* CreateProxyConstructor(Thread* self, ConstHandle<mirror::Class> klass,
Brian Carlstromea46f952013-07-30 01:26:50 -0700629 mirror::Class* proxy_class)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700630 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierbf99f772014-08-23 16:37:27 -0700631 mirror::ArtMethod* CreateProxyMethod(Thread* self, ConstHandle<mirror::Class> klass,
632 ConstHandle<mirror::ArtMethod> prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700633 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jesse Wilson95caa792011-10-12 18:14:17 -0400634
Andreas Gampe48498592014-09-10 19:48:05 -0700635 // Ensures that methods have the kAccPreverified bit set. We use the kAccPreverfied bit on the
636 // class access flags to determine whether this has been done before.
637 void EnsurePreverifiedMethods(ConstHandle<mirror::Class> c)
638 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
639
Ian Rogersdbf3be02014-08-29 15:40:08 -0700640 mirror::Class* LookupClassFromTableLocked(const char* descriptor,
641 const mirror::ClassLoader* class_loader,
642 size_t hash)
643 SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
644
645 mirror::Class* UpdateClass(const char* descriptor, mirror::Class* klass, size_t hash)
646 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
647 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
648
649 void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
650 LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
651 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
652 mirror::Class* LookupClassFromImage(const char* descriptor)
653 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
654
655 // EnsureResolved is called to make sure that a class in the class_table_ has been resolved
656 // before returning it to the caller. Its the responsibility of the thread that placed the class
657 // in the table to make it resolved. The thread doing resolution must notify on the class' lock
658 // when resolution has occurred. This happens in mirror::Class::SetStatus. As resolution may
659 // retire a class, the version of the class in the table is returned and this may differ from
660 // the class passed in.
661 mirror::Class* EnsureResolved(Thread* self, const char* descriptor, mirror::Class* klass)
662 WARN_UNUSED SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
663
664 void FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class)
665 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
666
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700667 std::vector<const DexFile*> boot_class_path_;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700668
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700669 mutable ReaderWriterMutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Mathieu Chartier893263b2014-03-04 11:07:42 -0800670 std::vector<size_t> new_dex_cache_roots_ GUARDED_BY(dex_lock_);;
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700671 std::vector<GcRoot<mirror::DexCache>> dex_caches_ GUARDED_BY(dex_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -0700672 std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700673
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700674
Brian Carlstromaded5f72011-10-07 17:15:04 -0700675 // multimap from a string hash code of a class descriptor to
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800676 // mirror::Class* instances. Results should be compared for a matching
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700677 // Class::descriptor_ and Class::class_loader_.
Mathieu Chartierbad02672014-08-25 13:08:22 -0700678 typedef AllocationTrackingMultiMap<size_t, GcRoot<mirror::Class>, kAllocatorTagClassTable> Table;
Hiroshi Yamauchia91a4bc2014-06-13 16:44:55 -0700679 // This contains strong roots. To enable concurrent root scanning of
680 // the class table, be careful to use a read barrier when accessing this.
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700681 Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700682 std::vector<std::pair<size_t, GcRoot<mirror::Class>>> new_class_roots_;
Elliott Hughesf8349362012-06-18 15:00:06 -0700683
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700684 // Do we need to search dex caches to find image classes?
685 bool dex_cache_image_class_lookup_required_;
686 // Number of times we've searched dex caches for a class. After a certain number of misses we move
687 // the classes into the class_table_ to avoid dex cache based searches.
Ian Rogers68b56852014-08-29 20:19:11 -0700688 Atomic<uint32_t> failed_dex_cache_class_lookups_;
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700689
Brian Carlstroma663ea52011-08-19 23:33:41 -0700690 // indexes into class_roots_.
691 // needs to be kept in sync with class_roots_descriptors_.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700692 enum ClassRoot {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700693 kJavaLangClass,
694 kJavaLangObject,
Elliott Hughes418d20f2011-09-22 14:00:39 -0700695 kClassArrayClass,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700696 kObjectArrayClass,
697 kJavaLangString,
Mathieu Chartier66f19252012-09-18 08:57:04 -0700698 kJavaLangDexCache,
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700699 kJavaLangRefReference,
Brian Carlstromea46f952013-07-30 01:26:50 -0700700 kJavaLangReflectArtField,
701 kJavaLangReflectArtMethod,
Ian Rogers466bb252011-10-14 03:29:56 -0700702 kJavaLangReflectProxy,
Mathieu Chartier66f19252012-09-18 08:57:04 -0700703 kJavaLangStringArrayClass,
Brian Carlstromea46f952013-07-30 01:26:50 -0700704 kJavaLangReflectArtFieldArrayClass,
705 kJavaLangReflectArtMethodArrayClass,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700706 kJavaLangClassLoader,
Ian Rogers5167c972012-02-03 10:41:20 -0800707 kJavaLangThrowable,
jeffhao8cd6dda2012-02-22 10:15:34 -0800708 kJavaLangClassNotFoundException,
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700709 kJavaLangStackTraceElement,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700710 kPrimitiveBoolean,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700711 kPrimitiveByte,
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700712 kPrimitiveChar,
713 kPrimitiveDouble,
714 kPrimitiveFloat,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700715 kPrimitiveInt,
716 kPrimitiveLong,
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700717 kPrimitiveShort,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700718 kPrimitiveVoid,
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700719 kBooleanArrayClass,
720 kByteArrayClass,
721 kCharArrayClass,
722 kDoubleArrayClass,
723 kFloatArrayClass,
724 kIntArrayClass,
725 kLongArrayClass,
726 kShortArrayClass,
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700727 kJavaLangStackTraceElementArrayClass,
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700728 kClassRootsMax,
729 };
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700730 GcRoot<mirror::ObjectArray<mirror::Class>> class_roots_;
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700731
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800732 mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700733
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800734 void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700735 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700736
Elliott Hughes418d20f2011-09-22 14:00:39 -0700737 static const char* class_roots_descriptors_[];
Brian Carlstroma663ea52011-08-19 23:33:41 -0700738
739 const char* GetClassRootDescriptor(ClassRoot class_root) {
740 const char* descriptor = class_roots_descriptors_[class_root];
741 CHECK(descriptor != NULL);
742 return descriptor;
743 }
744
Ian Rogers98379392014-02-24 16:53:16 -0800745 // The interface table used by all arrays.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700746 GcRoot<mirror::IfTable> array_iftable_;
Carl Shapiro565f5072011-07-10 13:39:43 -0700747
Ian Rogers98379392014-02-24 16:53:16 -0800748 // A cache of the last FindArrayClass results. The cache serves to avoid creating array class
749 // descriptors for the sake of performing FindClass.
750 static constexpr size_t kFindArrayCacheSize = 16;
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700751 GcRoot<mirror::Class> find_array_class_cache_[kFindArrayCacheSize];
Ian Rogers98379392014-02-24 16:53:16 -0800752 size_t find_array_class_cache_next_victim_;
753
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700754 bool init_done_;
Mathieu Chartier893263b2014-03-04 11:07:42 -0800755 bool log_new_dex_caches_roots_ GUARDED_BY(dex_lock_);
756 bool log_new_class_table_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700757
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700758 InternTable* intern_table_;
759
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700760 // Trampolines within the image the bounce to runtime entrypoints. Done so that there is a single
761 // patch point within the image. TODO: make these proper relocations.
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700762 const void* portable_resolution_trampoline_;
763 const void* quick_resolution_trampoline_;
Jeff Hao88474b42013-10-23 16:24:40 -0700764 const void* portable_imt_conflict_trampoline_;
765 const void* quick_imt_conflict_trampoline_;
Andreas Gampe2da88232014-02-27 12:26:20 -0800766 const void* quick_generic_jni_trampoline_;
Vladimir Marko8a630572014-04-09 18:45:35 +0100767 const void* quick_to_interpreter_bridge_trampoline_;
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700768
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700769 friend class ImageWriter; // for GetClassRoots
Alex Lighta59dd802014-07-02 16:28:08 -0700770 friend class ImageDumper; // for FindOpenedOatFileFromOatLocation
771 friend class ElfPatcher; // for FindOpenedOatFileForDexFile & FindOpenedOatFileFromOatLocation
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100772 friend class NoDex2OatTest; // for FindOpenedOatFileForDexFile
Alex Light9dcc4572014-08-14 14:16:26 -0700773 friend class NoPatchoatTest; // for FindOpenedOatFileForDexFile
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800774 FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800775 FRIEND_TEST(mirror::DexCacheTest, Open);
Brian Carlstromae826982011-11-09 01:33:42 -0800776 FRIEND_TEST(ExceptionTest, FindExceptionHandler);
777 FRIEND_TEST(ObjectTest, AllocObjectArray);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700778 DISALLOW_COPY_AND_ASSIGN(ClassLinker);
779};
780
781} // namespace art
782
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700783#endif // ART_RUNTIME_CLASS_LINKER_H_