blob: e23f1b1dfe609c2eb1545089e09f36ba798c2d82 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
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 Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "class_linker.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070018
Brian Carlstromd601af82012-01-06 10:15:19 -080019#include <fcntl.h>
20#include <sys/file.h>
21#include <sys/stat.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080022#include <sys/types.h>
23#include <sys/wait.h>
24
Brian Carlstromdbc05252011-09-09 01:59:59 -070025#include <deque>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070026#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070027#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070028#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070029
Elliott Hughes1aa246d2012-12-13 09:29:36 -080030#include "base/casts.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080031#include "base/logging.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080032#include "base/stl_util.h"
Elliott Hughes76160052012-12-12 16:31:20 -080033#include "base/unix_file/fd_file.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034#include "class_linker-inl.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080035#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070036#include "dex_file-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070037#include "gc/accounting/card_table-inl.h"
38#include "gc/accounting/heap_bitmap.h"
39#include "gc/heap.h"
40#include "gc/space/image_space.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070041#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070042#include "interpreter/interpreter.h"
Ian Rogers0571d352011-11-03 19:51:38 -070043#include "leb128.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080044#include "oat.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070045#include "oat_file.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070046#include "mirror/art_field-inl.h"
47#include "mirror/art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080048#include "mirror/class.h"
49#include "mirror/class-inl.h"
50#include "mirror/class_loader.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070051#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080052#include "mirror/iftable-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080053#include "mirror/object-inl.h"
54#include "mirror/object_array-inl.h"
55#include "mirror/proxy.h"
56#include "mirror/stack_trace_element.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080057#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080058#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070059#include "runtime.h"
Ian Rogers7655f292013-07-29 11:07:13 -070060#include "entrypoints/entrypoint_utils.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -070061#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070062#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070063#include "sirt_ref.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070064#include "stack_indirect_reference_table.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070065#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070066#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070067#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080068#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070069#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070070
71namespace art {
72
Ian Rogers00f7d0e2012-07-19 15:28:27 -070073static void ThrowNoClassDefFoundError(const char* fmt, ...)
74 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070075 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070076static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070077 va_list args;
78 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -080079 Thread* self = Thread::Current();
80 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
81 self->ThrowNewExceptionV(throw_location, "Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -080082 va_end(args);
83}
84
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080085static void ThrowEarlierClassFailure(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -070086 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -070087 // The class failed to initialize on a previous attempt, so we want to throw
88 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
89 // failed in verification, in which case v2 5.4.1 says we need to re-throw
90 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -070091 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
92 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
93 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -070094
Elliott Hughes5c599942012-06-13 16:45:05 -070095 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -080096 Thread* self = Thread::Current();
97 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
Elliott Hughes4a2b4172011-09-20 17:08:25 -070098 if (c->GetVerifyErrorClass() != NULL) {
99 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800100 ClassHelper ve_ch(c->GetVerifyErrorClass());
Ian Rogers62d6c772013-02-27 08:32:07 -0800101 self->ThrowNewException(throw_location, ve_ch.GetDescriptor(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700102 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -0800103 self->ThrowNewException(throw_location, "Ljava/lang/NoClassDefFoundError;",
104 PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700105 }
106}
107
Ian Rogers62d6c772013-02-27 08:32:07 -0800108static void WrapExceptionInInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700109 Thread* self = Thread::Current();
110 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700111
112 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
113 CHECK(cause.get() != NULL);
114
115 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700116 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
117 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700118
Elliott Hughesa4f94742012-05-29 16:28:38 -0700119 // We only wrap non-Error exceptions; an Error can just be used as-is.
120 if (!is_error) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800121 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
122 self->ThrowNewWrappedException(throw_location, "Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700123 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700124}
125
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800126static size_t Hash(const char* s) {
127 // This is the java.lang.String hashcode for convenience, not interoperability.
128 size_t hash = 0;
129 for (; *s != '\0'; ++s) {
130 hash = hash * 31 + *s;
131 }
132 return hash;
133}
134
Elliott Hughes418d20f2011-09-22 14:00:39 -0700135const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700136 "Ljava/lang/Class;",
137 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700138 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700139 "[Ljava/lang/Object;",
140 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700141 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700142 "Ljava/lang/ref/Reference;",
Brian Carlstromea46f952013-07-30 01:26:50 -0700143 "Ljava/lang/reflect/ArtField;",
144 "Ljava/lang/reflect/ArtMethod;",
Ian Rogers466bb252011-10-14 03:29:56 -0700145 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700146 "[Ljava/lang/String;",
Brian Carlstromea46f952013-07-30 01:26:50 -0700147 "[Ljava/lang/reflect/ArtField;",
148 "[Ljava/lang/reflect/ArtMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700149 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800150 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800151 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700152 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700153 "Z",
154 "B",
155 "C",
156 "D",
157 "F",
158 "I",
159 "J",
160 "S",
161 "V",
162 "[Z",
163 "[B",
164 "[C",
165 "[D",
166 "[F",
167 "[I",
168 "[J",
169 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700170 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700171};
172
Brian Carlstroma004aa92012-02-08 18:05:09 -0800173ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
174 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700175 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800176 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800177 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700178 return class_linker.release();
179}
180
Brian Carlstroma004aa92012-02-08 18:05:09 -0800181ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800182 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700183 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700184 return class_linker.release();
185}
186
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800187ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700188 // dex_lock_ is recursive as it may be used in stack dumping.
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700189 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700190 dex_cache_image_class_lookup_required_(false),
191 failed_dex_cache_class_lookups_(0),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700192 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700193 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700194 init_done_(false),
Mathieu Chartierc4621982013-09-16 19:43:47 -0700195 dex_caches_dirty_(false),
196 class_table_dirty_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700197 intern_table_(intern_table),
198 portable_resolution_trampoline_(NULL),
199 quick_resolution_trampoline_(NULL) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700200 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700201}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700202
Brian Carlstroma004aa92012-02-08 18:05:09 -0800203void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
204 VLOG(startup) << "ClassLinker::Init";
205 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700206
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700207 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700208
Elliott Hughes30646832011-10-13 16:59:46 -0700209 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700210 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700211 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800212 SirtRef<mirror::Class>
213 java_lang_Class(self,
214 down_cast<mirror::Class*>(heap->AllocObject(self, NULL,
215 sizeof(mirror::ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700216 CHECK(java_lang_Class.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800217 mirror::Class::SetClassClass(java_lang_Class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700218 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800219 java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
220 // AllocClass(mirror::Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700221
Elliott Hughes418d20f2011-09-22 14:00:39 -0700222 // Class[] is used for reflection support.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800223 SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700224 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700225
Ian Rogers23435d02012-09-24 11:23:12 -0700226 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800227 SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700228 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700229 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700230 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700231 java_lang_Object->SetStatus(mirror::Class::kStatusLoaded, self);
Brian Carlstroma0808032011-07-18 00:39:23 -0700232
Ian Rogers23435d02012-09-24 11:23:12 -0700233 // Object[] next to hold class roots.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800234 SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700235 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700236
Ian Rogers23435d02012-09-24 11:23:12 -0700237 // Setup the char class to be used for char[].
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800238 SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700239
Ian Rogers23435d02012-09-24 11:23:12 -0700240 // Setup the char[] class to be used for String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800241 SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700242 char_array_class->SetComponentType(char_class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800243 mirror::CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700244
Ian Rogers23435d02012-09-24 11:23:12 -0700245 // Setup String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800246 SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
247 mirror::String::SetClass(java_lang_String.get());
248 java_lang_String->SetObjectSize(sizeof(mirror::String));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700249 java_lang_String->SetStatus(mirror::Class::kStatusResolved, self);
Jesse Wilson14150742011-07-29 19:04:44 -0400250
Ian Rogers23435d02012-09-24 11:23:12 -0700251 // Create storage for root classes, save away our work so far (requires descriptors).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800252 class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700253 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700254 SetClassRoot(kJavaLangClass, java_lang_Class.get());
255 SetClassRoot(kJavaLangObject, java_lang_Object.get());
256 SetClassRoot(kClassArrayClass, class_array_class.get());
257 SetClassRoot(kObjectArrayClass, object_array_class.get());
258 SetClassRoot(kCharArrayClass, char_array_class.get());
259 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700260
261 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700262 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
263 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
264 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
265 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
266 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
267 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
268 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
269 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700270
Ian Rogers23435d02012-09-24 11:23:12 -0700271 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700272 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700273
Ian Rogers23435d02012-09-24 11:23:12 -0700274 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800275 SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700276 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800277 mirror::IntArray::SetArrayClass(int_array_class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700278 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700279
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700280 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700281
Ian Rogers52813c92012-10-11 11:50:38 -0700282 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800283 SirtRef<mirror::Class>
284 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700285 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800286 java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCacheClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700287 java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700288
Mathieu Chartier66f19252012-09-18 08:57:04 -0700289 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Brian Carlstromea46f952013-07-30 01:26:50 -0700290 SirtRef<mirror::Class> java_lang_reflect_ArtField(self, AllocClass(self, java_lang_Class.get(),
291 sizeof(mirror::ArtFieldClass)));
292 CHECK(java_lang_reflect_ArtField.get() != NULL);
293 java_lang_reflect_ArtField->SetObjectSize(sizeof(mirror::ArtField));
294 SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700295 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700296 mirror::ArtField::SetClass(java_lang_reflect_ArtField.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700297
Brian Carlstromea46f952013-07-30 01:26:50 -0700298 SirtRef<mirror::Class> java_lang_reflect_ArtMethod(self, AllocClass(self, java_lang_Class.get(),
299 sizeof(mirror::ArtMethodClass)));
300 CHECK(java_lang_reflect_ArtMethod.get() != NULL);
301 java_lang_reflect_ArtMethod->SetObjectSize(sizeof(mirror::ArtMethod));
302 SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700303 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700304
Brian Carlstromea46f952013-07-30 01:26:50 -0700305 mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700306
307 // Set up array classes for string, field, method
Brian Carlstromea46f952013-07-30 01:26:50 -0700308 SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(),
309 sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700310 object_array_string->SetComponentType(java_lang_String.get());
311 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
312
Brian Carlstromea46f952013-07-30 01:26:50 -0700313 SirtRef<mirror::Class> object_array_art_method(self, AllocClass(self, java_lang_Class.get(),
314 sizeof(mirror::Class)));
315 object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.get());
316 SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.get());
Ian Rogers4445a7e2012-10-05 17:19:13 -0700317
Brian Carlstromea46f952013-07-30 01:26:50 -0700318 SirtRef<mirror::Class> object_array_art_field(self, AllocClass(self, java_lang_Class.get(),
319 sizeof(mirror::Class)));
320 object_array_art_field->SetComponentType(java_lang_reflect_ArtField.get());
321 SetClassRoot(kJavaLangReflectArtFieldArrayClass, object_array_art_field.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700322
Ian Rogers23435d02012-09-24 11:23:12 -0700323 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
324 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
325 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700326 CHECK_NE(0U, boot_class_path.size());
327 for (size_t i = 0; i != boot_class_path.size(); ++i) {
328 const DexFile* dex_file = boot_class_path[i];
329 CHECK(dex_file != NULL);
330 AppendToBootClassPath(*dex_file);
331 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700332
333 // now we can use FindSystemClass
334
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700335 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700336 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700337 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700338
Mathieu Chartier66f19252012-09-18 08:57:04 -0700339 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700340 java_lang_Object->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800341 mirror::Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700342 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800343 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700344 java_lang_String->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800345 mirror::Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700346 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800347 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700348 java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800349 mirror::Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700350 CHECK_EQ(java_lang_String.get(), String_class);
351 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800352 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700353
Ian Rogers23435d02012-09-24 11:23:12 -0700354 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700355 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800356 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700357
358 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800359 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700360
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800361 mirror::Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700362 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700363
364 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800365 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700366
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800367 mirror::Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700368 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700369
370 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800371 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700372
373 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800374 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700375
376 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800377 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700378
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800379 mirror::Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700380 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700381
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800382 mirror::Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700383 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700384
Ian Rogers23435d02012-09-24 11:23:12 -0700385 // Setup the single, global copy of "iftable".
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800386 mirror::Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700387 CHECK(java_lang_Cloneable != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800388 mirror::Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700389 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700390 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
391 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700392 array_iftable_->SetInterface(0, java_lang_Cloneable);
393 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700394
Ian Rogers23435d02012-09-24 11:23:12 -0700395 // Sanity check Class[] and Object[]'s interfaces.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800396 ClassHelper kh(class_array_class.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -0700397 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
398 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800399 kh.ChangeClass(object_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700400 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
401 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Brian Carlstromea46f952013-07-30 01:26:50 -0700402 // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700403 // dex_cache_ fields and register them in class_table_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800404 mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700405 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700406
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700407 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700408 mirror::Class* Art_method_class = FindSystemClass("Ljava/lang/reflect/ArtMethod;");
409 CHECK_EQ(java_lang_reflect_ArtMethod.get(), Art_method_class);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700410
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700411 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700412 mirror::Class* Art_field_class = FindSystemClass("Ljava/lang/reflect/ArtField;");
413 CHECK_EQ(java_lang_reflect_ArtField.get(), Art_field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700414
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800415 mirror::Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700416 CHECK_EQ(object_array_string.get(), String_array_class);
417
Brian Carlstromea46f952013-07-30 01:26:50 -0700418 mirror::Class* Art_method_array_class =
419 FindSystemClass(class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]);
420 CHECK_EQ(object_array_art_method.get(), Art_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700421
Brian Carlstromea46f952013-07-30 01:26:50 -0700422 mirror::Class* Art_field_array_class =
423 FindSystemClass(class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]);
424 CHECK_EQ(object_array_art_field.get(), Art_field_array_class);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700425
Ian Rogers23435d02012-09-24 11:23:12 -0700426 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700427
Ian Rogers23435d02012-09-24 11:23:12 -0700428 // Create java.lang.reflect.Proxy root.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800429 mirror::Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
Ian Rogers466bb252011-10-14 03:29:56 -0700430 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
431
Brian Carlstrom1f870082011-08-23 16:02:11 -0700432 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800433 mirror::Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700434 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800435 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700436 java_lang_ref_FinalizerReference->SetAccessFlags(
437 java_lang_ref_FinalizerReference->GetAccessFlags() |
438 kAccClassIsReference | kAccClassIsFinalizerReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800439 mirror::Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700440 java_lang_ref_PhantomReference->SetAccessFlags(
441 java_lang_ref_PhantomReference->GetAccessFlags() |
442 kAccClassIsReference | kAccClassIsPhantomReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800443 mirror::Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700444 java_lang_ref_SoftReference->SetAccessFlags(
445 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800446 mirror::Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700447 java_lang_ref_WeakReference->SetAccessFlags(
448 java_lang_ref_WeakReference->GetAccessFlags() |
449 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700450
Ian Rogers23435d02012-09-24 11:23:12 -0700451 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800452 mirror::Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
453 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700454 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
455
jeffhao8cd6dda2012-02-22 10:15:34 -0800456 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700457 // java.lang.StackTraceElement as a convenience.
Ian Rogers5167c972012-02-03 10:41:20 -0800458 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800459 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800460 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700461 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
462 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800463 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700464
Brian Carlstroma663ea52011-08-19 23:33:41 -0700465 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700466
Brian Carlstroma004aa92012-02-08 18:05:09 -0800467 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700468}
469
470void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800471 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700472
473 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700474 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700475 // as the types of the field can't be resolved prior to the runtime being
476 // fully initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800477 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Ian Rogersee39a102013-09-19 02:56:49 -0700478 mirror::Class* java_lang_ref_FinalizerReference =
479 FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800480
Brian Carlstromea46f952013-07-30 01:26:50 -0700481 mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800482 FieldHelper fh(pendingNext, this);
483 CHECK_STREQ(fh.GetName(), "pendingNext");
Ian Rogersee39a102013-09-19 02:56:49 -0700484 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700485
Brian Carlstromea46f952013-07-30 01:26:50 -0700486 mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800487 fh.ChangeField(queue);
488 CHECK_STREQ(fh.GetName(), "queue");
Ian Rogersee39a102013-09-19 02:56:49 -0700489 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700490
Brian Carlstromea46f952013-07-30 01:26:50 -0700491 mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800492 fh.ChangeField(queueNext);
493 CHECK_STREQ(fh.GetName(), "queueNext");
Ian Rogersee39a102013-09-19 02:56:49 -0700494 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700495
Brian Carlstromea46f952013-07-30 01:26:50 -0700496 mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800497 fh.ChangeField(referent);
498 CHECK_STREQ(fh.GetName(), "referent");
Ian Rogersee39a102013-09-19 02:56:49 -0700499 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700500
Brian Carlstromea46f952013-07-30 01:26:50 -0700501 mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800502 fh.ChangeField(zombie);
503 CHECK_STREQ(fh.GetName(), "zombie");
Ian Rogersee39a102013-09-19 02:56:49 -0700504 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700505
Ian Rogers1d54e732013-05-02 21:10:01 -0700506 gc::Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800507 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700508 queue->GetOffset(),
509 queueNext->GetOffset(),
510 pendingNext->GetOffset(),
511 zombie->GetOffset());
512
Brian Carlstroma663ea52011-08-19 23:33:41 -0700513 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700514 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700515 ClassRoot class_root = static_cast<ClassRoot>(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800516 mirror::Class* klass = GetClassRoot(class_root);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700517 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700518 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700519 // note SetClassRoot does additional validation.
520 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700521 }
522
Elliott Hughes92f14b22011-10-06 12:29:54 -0700523 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700524
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700525 // disable the slow paths in FindClass and CreatePrimitiveClass now
526 // that Object, Class, and Object[] are setup
527 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700528
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800529 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700530}
531
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700532void ClassLinker::RunRootClinits() {
533 Thread* self = Thread::Current();
534 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800535 mirror::Class* c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700536 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700537 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700538 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700539 }
540 }
541}
542
Brian Carlstromd601af82012-01-06 10:15:19 -0800543bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
544 int oat_fd,
545 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800546 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700547 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800548 const char* dex2oat = dex2oat_string.c_str();
549
Brian Carlstroma004aa92012-02-08 18:05:09 -0800550 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800551
Ian Rogers1d54e732013-05-02 21:10:01 -0700552 gc::Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800553 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700554 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800555 const char* boot_image_option = boot_image_option_string.c_str();
556
557 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800558 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800559 const char* dex_file_option = dex_file_option_string.c_str();
560
Brian Carlstromd601af82012-01-06 10:15:19 -0800561 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800562 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800563 const char* oat_fd_option = oat_fd_option_string.c_str();
564
Brian Carlstroma004aa92012-02-08 18:05:09 -0800565 std::string oat_location_option_string("--oat-location=");
566 oat_location_option_string += oat_cache_filename;
567 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800568
buzbeea024a062013-07-31 10:47:37 -0700569 std::string oat_compiler_filter_string("-compiler-filter:");
570 switch (Runtime::Current()->GetCompilerFilter()) {
571 case Runtime::kInterpretOnly:
572 oat_compiler_filter_string += "interpret-only";
573 break;
buzbeea024a062013-07-31 10:47:37 -0700574 case Runtime::kSpace:
575 oat_compiler_filter_string += "space";
576 break;
577 case Runtime::kBalanced:
578 oat_compiler_filter_string += "balanced";
579 break;
580 case Runtime::kSpeed:
581 oat_compiler_filter_string += "speed";
582 break;
buzbeefe9ca402013-08-21 09:48:11 -0700583 case Runtime::kEverything:
584 oat_compiler_filter_string += "everything";
585 break;
buzbeea024a062013-07-31 10:47:37 -0700586 default:
587 LOG(FATAL) << "Unexpected case.";
588 }
589 const char* oat_compiler_filter_option = oat_compiler_filter_string.c_str();
590
jeffhao262bf462011-10-20 18:36:32 -0700591 // fork and exec dex2oat
592 pid_t pid = fork();
593 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800594 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800595
596 // change process groups, so we don't get reaped by ProcessManager
597 setpgid(0, 0);
598
Brian Carlstromb00309f2013-09-30 14:23:30 -0700599 // gLogVerbosity.class_linker = true;
jeffhao10037c82012-01-23 15:06:23 -0800600 VLOG(class_linker) << dex2oat
601 << " --runtime-arg -Xms64m"
602 << " --runtime-arg -Xmx64m"
603 << " --runtime-arg -classpath"
604 << " --runtime-arg " << class_path
buzbeea024a062013-07-31 10:47:37 -0700605 << " --runtime-arg " << oat_compiler_filter_option
Brian Carlstrom265091e2013-01-30 14:08:26 -0800606#if !defined(ART_TARGET)
607 << " --host"
608#endif
jeffhao10037c82012-01-23 15:06:23 -0800609 << " " << boot_image_option
610 << " " << dex_file_option
611 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800612 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800613
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800614 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700615 "--runtime-arg", "-Xms64m",
616 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500617 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800618 "--runtime-arg", class_path,
buzbeea024a062013-07-31 10:47:37 -0700619 "--runtime-arg", oat_compiler_filter_option,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800620#if !defined(ART_TARGET)
621 "--host",
622#endif
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800623 boot_image_option,
624 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800625 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800626 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700627 NULL);
628
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800629 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800630 return false;
jeffhao262bf462011-10-20 18:36:32 -0700631 } else {
632 // wait for dex2oat to finish
633 int status;
634 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
635 if (got_pid != pid) {
636 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800637 return false;
jeffhao262bf462011-10-20 18:36:32 -0700638 }
639 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800640 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
641 return false;
jeffhao262bf462011-10-20 18:36:32 -0700642 }
643 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800644 return true;
jeffhao262bf462011-10-20 18:36:32 -0700645}
646
Brian Carlstrom866c8622012-01-06 16:35:13 -0800647void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700648 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800649 RegisterOatFileLocked(oat_file);
650}
651
652void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700653 dex_lock_.AssertExclusiveHeld(Thread::Current());
654 if (kIsDebugBuild) {
655 for (size_t i = 0; i < oat_files_.size(); ++i) {
656 CHECK_NE(&oat_file, oat_files_[i]) << oat_file.GetLocation();
657 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800658 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700659 VLOG(class_linker) << "Registering " << oat_file.GetLocation();
Brian Carlstrom866c8622012-01-06 16:35:13 -0800660 oat_files_.push_back(&oat_file);
661}
662
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700663OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
664 VLOG(startup) << "ClassLinker::GetImageOatFile entering";
665 OatFile& oat_file = space->ReleaseOatFile();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700666 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700667 RegisterOatFileLocked(oat_file);
668 VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700669 return oat_file;
670}
671
Brian Carlstromae826982011-11-09 01:33:42 -0800672const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700673 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700674 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation(), dex_file.GetLocationChecksum());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800675}
676
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700677const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location,
678 uint32_t dex_location_checksum) {
Brian Carlstromae826982011-11-09 01:33:42 -0800679 for (size_t i = 0; i < oat_files_.size(); i++) {
680 const OatFile* oat_file = oat_files_[i];
681 DCHECK(oat_file != NULL);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700682 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
683 &dex_location_checksum,
684 false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800685 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800686 return oat_file;
687 }
688 }
689 return NULL;
690}
691
Ian Rogerse3359f72013-06-11 15:14:11 -0700692const DexFile* ClassLinker::FindDexFileInOatLocation(const std::string& dex_location,
693 uint32_t dex_location_checksum,
694 const std::string& oat_location) {
Brian Carlstromf1d34552013-07-12 20:22:23 -0700695 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
696 !Runtime::Current()->IsCompiler()));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800697 if (oat_file.get() == NULL) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700698 VLOG(class_linker) << "Failed to find existing oat file at " << oat_location;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800699 return NULL;
700 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700701 Runtime* runtime = Runtime::Current();
702 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700703 uint32_t expected_image_oat_checksum = image_header.GetOatChecksum();
704 uint32_t actual_image_oat_checksum = oat_file->GetOatHeader().GetImageFileLocationOatChecksum();
705 if (expected_image_oat_checksum != actual_image_oat_checksum) {
706 VLOG(class_linker) << "Failed to find oat file at " << oat_location
707 << " with expected image oat checksum of " << expected_image_oat_checksum
708 << ", found " << actual_image_oat_checksum;
Brian Carlstrom28db0122012-10-18 16:20:41 -0700709 return NULL;
710 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700711
712 uint32_t expected_image_oat_offset = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
713 uint32_t actual_image_oat_offset = oat_file->GetOatHeader().GetImageFileLocationOatDataBegin();
714 if (expected_image_oat_offset != actual_image_oat_offset) {
715 VLOG(class_linker) << "Failed to find oat file at " << oat_location
716 << " with expected image oat offset " << expected_image_oat_offset
717 << ", found " << actual_image_oat_offset;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700718 return NULL;
719 }
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700720 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800721 if (oat_dex_file == NULL) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700722 VLOG(class_linker) << "Failed to find oat file at " << oat_location << " containing " << dex_location;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800723 return NULL;
724 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700725 uint32_t expected_dex_checksum = dex_location_checksum;
726 uint32_t actual_dex_checksum = oat_dex_file->GetDexFileLocationChecksum();
727 if (expected_dex_checksum != actual_dex_checksum) {
728 VLOG(class_linker) << "Failed to find oat file at " << oat_location
729 << " with expected dex checksum of " << expected_dex_checksum
730 << ", found " << actual_dex_checksum;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800731 return NULL;
732 }
Ian Rogerse3359f72013-06-11 15:14:11 -0700733 RegisterOatFileLocked(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800734 return oat_dex_file->OpenDexFile();
735}
736
737const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700738 uint32_t dex_location_checksum,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800739 const std::string& oat_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700740 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700741 return FindOrCreateOatFileForDexLocationLocked(dex_location, dex_location_checksum, oat_location);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700742}
743
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700744class ScopedFlock {
745 public:
746 ScopedFlock() {}
747
748 bool Init(const std::string& filename) {
749 while (true) {
750 file_.reset(OS::OpenFileWithFlags(filename.c_str(), O_CREAT | O_RDWR));
751 if (file_.get() == NULL) {
752 LOG(ERROR) << "Failed to open file: " << filename;
753 return false;
754 }
755 int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_EX));
756 if (flock_result != 0) {
757 PLOG(ERROR) << "Failed to lock file: " << filename;
758 return false;
759 }
760 struct stat fstat_stat;
761 int fstat_result = TEMP_FAILURE_RETRY(fstat(file_->Fd(), &fstat_stat));
762 if (fstat_result != 0) {
763 PLOG(ERROR) << "Failed to fstat: " << filename;
764 return false;
765 }
766 struct stat stat_stat;
767 int stat_result = TEMP_FAILURE_RETRY(stat(filename.c_str(), &stat_stat));
768 if (stat_result != 0) {
769 PLOG(WARNING) << "Failed to stat, will retry: " << filename;
770 // ENOENT can happen if someone racing with us unlinks the file we created so just retry.
771 continue;
772 }
773 if (fstat_stat.st_dev != stat_stat.st_dev || fstat_stat.st_ino != stat_stat.st_ino) {
774 LOG(WARNING) << "File changed while locking, will retry: " << filename;
775 continue;
776 }
777 return true;
778 }
779 }
780
781 File& GetFile() {
782 return *file_;
783 }
784
785 ~ScopedFlock() {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700786 if (file_.get() != NULL) {
787 int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_UN));
788 CHECK_EQ(0, flock_result);
789 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700790 }
791
792 private:
793 UniquePtr<File> file_;
794
795 DISALLOW_COPY_AND_ASSIGN(ScopedFlock);
796};
797
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700798const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700799 uint32_t dex_location_checksum,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700800 const std::string& oat_location) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700801 // We play a locking game here so that if two different processes
802 // race to generate (or worse, one tries to open a partial generated
803 // file) we will be okay. This is actually common with apps that use
804 // DexClassLoader to work around the dex method reference limit and
805 // that have a background service running in a separate process.
806 ScopedFlock scoped_flock;
807 if (!scoped_flock.Init(oat_location)) {
808 LOG(ERROR) << "Failed to open locked oat file: " << oat_location;
809 return NULL;
810 }
811
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800812 // Check if we already have an up-to-date output file
813 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
814 dex_location_checksum,
815 oat_location);
816 if (dex_file != NULL) {
817 return dex_file;
818 }
819
820 // Generate the output oat file for the dex file
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700821 VLOG(class_linker) << "Generating oat file " << oat_location << " for " << dex_location;
822 if (!GenerateOatFile(dex_location, scoped_flock.GetFile().Fd(), oat_location)) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800823 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
824 return NULL;
825 }
Brian Carlstromf1d34552013-07-12 20:22:23 -0700826 const OatFile* oat_file = OatFile::Open(oat_location, oat_location, NULL,
827 !Runtime::Current()->IsCompiler());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800828 if (oat_file == NULL) {
829 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
830 return NULL;
831 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700832 RegisterOatFileLocked(*oat_file);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700833 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800834 if (oat_dex_file == NULL) {
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700835 LOG(ERROR) << "Failed to find dex file " << dex_location
836 << " (checksum " << dex_location_checksum
837 << ") in generated oat file: " << oat_location;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800838 return NULL;
839 }
Brian Carlstromb00309f2013-09-30 14:23:30 -0700840 const DexFile* result = oat_dex_file->OpenDexFile();
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700841 CHECK_EQ(dex_location_checksum, result->GetLocationChecksum())
842 << "dex_location=" << dex_location << " oat_location=" << oat_location << std::hex
843 << " dex_location_checksum=" << dex_location_checksum
Brian Carlstromb00309f2013-09-30 14:23:30 -0700844 << " DexFile::GetLocationChecksum()=" << result->GetLocationChecksum();
845 return result;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800846}
847
Brian Carlstromafe25512012-06-27 17:02:58 -0700848bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
849 const std::string& dex_location,
850 uint32_t dex_location_checksum) {
851 Runtime* runtime = Runtime::Current();
852 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700853 uint32_t image_oat_checksum = image_header.GetOatChecksum();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800854 uint32_t image_oat_data_begin = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
Brian Carlstrom28db0122012-10-18 16:20:41 -0700855 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800856 && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700857
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700858 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700859 if (oat_dex_file == NULL) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700860 LOG(ERROR) << "oat file " << oat_file->GetLocation()
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700861 << " does not contain contents for " << dex_location
862 << " with checksum " << dex_location_checksum;
Brian Carlstromafe25512012-06-27 17:02:58 -0700863 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
864 for (size_t i = 0; i < oat_dex_files.size(); i++) {
865 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700866 LOG(ERROR) << "oat file " << oat_file->GetLocation()
Brian Carlstromafe25512012-06-27 17:02:58 -0700867 << " contains contents for " << oat_dex_file->GetDexFileLocation();
868 }
869 return false;
870 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700871 bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700872
Brian Carlstromafe25512012-06-27 17:02:58 -0700873 if (image_check && dex_check) {
874 return true;
875 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700876
Brian Carlstromafe25512012-06-27 17:02:58 -0700877 if (!image_check) {
878 std::string image_file(image_header.GetImageRoot(
879 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700880 LOG(WARNING) << "oat file " << oat_file->GetLocation()
Brian Carlstromb00309f2013-09-30 14:23:30 -0700881 << " mismatch (" << std::hex << oat_file->GetOatHeader().GetImageFileLocationOatChecksum()
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800882 << ", " << oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700883 << ") with " << image_file
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800884 << " (" << image_oat_checksum << ", " << std::hex << image_oat_data_begin << ")";
Brian Carlstromafe25512012-06-27 17:02:58 -0700885 }
886 if (!dex_check) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700887 LOG(WARNING) << "oat file " << oat_file->GetLocation()
Brian Carlstromb00309f2013-09-30 14:23:30 -0700888 << " mismatch (" << std::hex << oat_dex_file->GetDexFileLocationChecksum()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700889 << ") with " << dex_location
Brian Carlstromafe25512012-06-27 17:02:58 -0700890 << " (" << std::hex << dex_location_checksum << ")";
891 }
892 return false;
893}
894
895const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
896 const std::string& dex_location,
897 uint32_t dex_location_checksum) {
898 bool verified = VerifyOatFileChecksums(oat_file, dex_location, dex_location_checksum);
899 if (!verified) {
Brian Carlstromb00309f2013-09-30 14:23:30 -0700900 delete oat_file;
Brian Carlstromafe25512012-06-27 17:02:58 -0700901 return NULL;
902 }
903 RegisterOatFileLocked(*oat_file);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700904 return oat_file->GetOatDexFile(dex_location, &dex_location_checksum)->OpenDexFile();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700905}
906
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700907const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location,
908 uint32_t dex_location_checksum) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700909 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800910
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700911 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location,
912 dex_location_checksum);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800913 if (open_oat_file != NULL) {
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700914 return open_oat_file->GetOatDexFile(dex_location, &dex_location_checksum)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800915 }
916
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700917 // Look for an existing file next to dex. for example, for
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700918 // /foo/bar/baz.jar, look for /foo/bar/baz.odex.
919 std::string odex_filename(OatFile::DexFilenameToOdexFilename(dex_location));
Brian Carlstromb00309f2013-09-30 14:23:30 -0700920 UniquePtr<const OatFile> oat_file(FindOatFileFromOatLocationLocked(odex_filename));
921 if (oat_file.get() != NULL) {
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700922 uint32_t dex_location_checksum;
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -0700923 if (!DexFile::GetChecksum(dex_location, &dex_location_checksum)) {
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700924 // If no classes.dex found in dex_location, it has been stripped, assume oat is up-to-date.
925 // This is the common case in user builds for jar's and apk's in the /system directory.
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700926 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, NULL);
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700927 CHECK(oat_dex_file != NULL) << odex_filename << " " << dex_location;
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700928 RegisterOatFileLocked(*oat_file);
929 return oat_dex_file->OpenDexFile();
930 }
Brian Carlstromb00309f2013-09-30 14:23:30 -0700931 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file.release(),
Brian Carlstromafe25512012-06-27 17:02:58 -0700932 dex_location,
933 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700934 if (dex_file != NULL) {
935 return dex_file;
936 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800937 }
Brian Carlstrom7675e162013-06-10 16:18:04 -0700938 // Look for an existing file in the dalvik-cache, validating the result if found
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700939 // not found in /foo/bar/baz.odex? try /data/dalvik-cache/foo@bar@baz.jar@classes.dex
940 std::string cache_location(GetDalvikCacheFilenameOrDie(dex_location));
Brian Carlstromb00309f2013-09-30 14:23:30 -0700941 oat_file.reset(FindOatFileFromOatLocationLocked(cache_location));
942 if (oat_file.get() != NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800943 uint32_t dex_location_checksum;
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -0700944 if (!DexFile::GetChecksum(dex_location, &dex_location_checksum)) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800945 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
946 return NULL;
947 }
Brian Carlstromb00309f2013-09-30 14:23:30 -0700948 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file.release(),
Brian Carlstromafe25512012-06-27 17:02:58 -0700949 dex_location,
950 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700951 if (dex_file != NULL) {
952 return dex_file;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700953 }
Brian Carlstromb00309f2013-09-30 14:23:30 -0700954 if (TEMP_FAILURE_RETRY(unlink(cache_location.c_str())) != 0) {
955 PLOG(FATAL) << "Failed to remove obsolete oat file from " << cache_location;
Brian Carlstromd601af82012-01-06 10:15:19 -0800956 }
jeffhao262bf462011-10-20 18:36:32 -0700957 }
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700958 LOG(INFO) << "Failed to open oat file from " << odex_filename << " or " << cache_location << ".";
Brian Carlstroma004aa92012-02-08 18:05:09 -0800959
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800960 // Try to generate oat file if it wasn't found or was obsolete.
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700961 std::string oat_cache_filename(GetDalvikCacheFilenameOrDie(dex_location));
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700962 return FindOrCreateOatFileForDexLocationLocked(dex_location, dex_location_checksum, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700963}
964
Brian Carlstromae826982011-11-09 01:33:42 -0800965const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700966 for (size_t i = 0; i < oat_files_.size(); i++) {
967 const OatFile* oat_file = oat_files_[i];
968 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800969 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700970 return oat_file;
971 }
972 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700973 return NULL;
974}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700975
Brian Carlstromae826982011-11-09 01:33:42 -0800976const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700977 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700978 return FindOatFileFromOatLocationLocked(oat_location);
979}
980
981const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800982 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
983 if (oat_file != NULL) {
984 return oat_file;
985 }
986
Brian Carlstromf1d34552013-07-12 20:22:23 -0700987 oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700988 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800989 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700990 }
991 return oat_file;
992}
993
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700994static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
Ian Rogers848871b2013-08-05 10:56:33 -0700995 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700996 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
997
Ian Rogers848871b2013-08-05 10:56:33 -0700998 DCHECK(obj != NULL);
999 DCHECK(class_linker != NULL);
1000
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001001 if (obj->IsArtMethod()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001002 mirror::ArtMethod* method = obj->AsArtMethod();
Ian Rogers848871b2013-08-05 10:56:33 -07001003 if (!method->IsNative()) {
1004 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
1005 if (method != Runtime::Current()->GetResolutionMethod()) {
1006 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
1007 }
1008 }
1009 }
1010}
1011
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001012void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001013 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001014 CHECK(!init_done_);
1015
Ian Rogers1d54e732013-05-02 21:10:01 -07001016 gc::Heap* heap = Runtime::Current()->GetHeap();
1017 gc::space::ImageSpace* space = heap->GetImageSpace();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001018 dex_cache_image_class_lookup_required_ = true;
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001019 CHECK(space != NULL);
1020 OatFile& oat_file = GetImageOatFile(space);
1021 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
1022 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
1023 CHECK(oat_file.GetOatHeader().GetImageFileLocation().empty());
1024 portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
1025 quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001026 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
1027 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1028 dex_caches_object->AsObjectArray<mirror::DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001029
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001030 mirror::ObjectArray<mirror::Class>* class_roots =
1031 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>();
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001032 class_roots_ = class_roots;
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001033
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001034 // Special case of setting up the String class early so that we can test arbitrary objects
1035 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001036 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001037
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001038 CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001039 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers1f539342012-10-03 21:09:42 -07001040 Thread* self = Thread::Current();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001041 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001042 SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001043 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001044 const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location, NULL);
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001045 CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001046 const DexFile* dex_file = oat_dex_file->OpenDexFile();
1047 if (dex_file == NULL) {
1048 LOG(FATAL) << "Failed to open dex file " << dex_file_location
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001049 << " from within oat file " << oat_file.GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001050 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001051
1052 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
1053
1054 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001055 }
1056
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001057 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
1058 // bitmap walk.
Brian Carlstromea46f952013-07-30 01:26:50 -07001059 mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001060
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001061 // Set entry point to interpreter if in InterpretOnly mode.
1062 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001063 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001064 heap->FlushAllocStack();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001065 heap->GetLiveBitmap()->Walk(InitFromImageInterpretOnlyCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001066 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001067
1068 // reinit class_roots_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001069 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001070 class_roots_ = class_roots;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001071
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001072 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001073 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1074 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001075 // String class root was set above
Brian Carlstromea46f952013-07-30 01:26:50 -07001076 mirror::ArtField::SetClass(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001077 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1078 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1079 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1080 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1081 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1082 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1083 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1084 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1085 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1086 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001087
1088 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001089
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001090 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001091}
1092
Brian Carlstroma663ea52011-08-19 23:33:41 -07001093// Keep in sync with InitCallback. Anything we visit, we need to
1094// reinit references to when reinitializing a ClassLinker from a
1095// mapped image.
Mathieu Chartierc4621982013-09-16 19:43:47 -07001096void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool clean_dirty) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001097 visitor(class_roots_, arg);
Ian Rogers50b35e22012-10-04 10:09:15 -07001098 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001099 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001100 ReaderMutexLock mu(self, dex_lock_);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001101 if (!only_dirty || dex_caches_dirty_) {
1102 for (mirror::DexCache* dex_cache : dex_caches_) {
1103 visitor(dex_cache, arg);
1104 }
1105 if (clean_dirty) {
1106 dex_caches_dirty_ = false;
1107 }
Elliott Hughesf8349362012-06-18 15:00:06 -07001108 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001109 }
1110
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001111 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001112 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001113 if (!only_dirty || class_table_dirty_) {
1114 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
1115 visitor(it.second, arg);
1116 }
1117 if (clean_dirty) {
1118 class_table_dirty_ = false;
1119 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001120 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001121
1122 // We deliberately ignore the class roots in the image since we
1123 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001124 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001125
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001126 visitor(array_iftable_, arg);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001127}
1128
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001129void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) {
1130 if (dex_cache_image_class_lookup_required_) {
1131 MoveImageClassesToClassTable();
Elliott Hughesa2155262011-11-16 16:26:58 -08001132 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001133 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
1134 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001135 if (!visitor(it.second, arg)) {
Elliott Hughesa2155262011-11-16 16:26:58 -08001136 return;
1137 }
1138 }
1139}
1140
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001141static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1142 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001143 classes->insert(c);
1144 return true;
1145}
1146
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001147void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001148 std::set<mirror::Class*> classes;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001149 VisitClasses(GetClassesVisitor, &classes);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001150 for (mirror::Class* klass : classes) {
1151 if (!visitor(klass, arg)) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001152 return;
1153 }
1154 }
1155}
1156
1157
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001158ClassLinker::~ClassLinker() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001159 mirror::Class::ResetClass();
1160 mirror::String::ResetClass();
Brian Carlstromea46f952013-07-30 01:26:50 -07001161 mirror::ArtField::ResetClass();
1162 mirror::ArtMethod::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001163 mirror::BooleanArray::ResetArrayClass();
1164 mirror::ByteArray::ResetArrayClass();
1165 mirror::CharArray::ResetArrayClass();
1166 mirror::DoubleArray::ResetArrayClass();
1167 mirror::FloatArray::ResetArrayClass();
1168 mirror::IntArray::ResetArrayClass();
1169 mirror::LongArray::ResetArrayClass();
1170 mirror::ShortArray::ResetArrayClass();
1171 mirror::Throwable::ResetClass();
1172 mirror::StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001173 STLDeleteElements(&boot_class_path_);
1174 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001175}
1176
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001177mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001178 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001179 mirror::Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
1180 SirtRef<mirror::DexCache> dex_cache(self,
1181 down_cast<mirror::DexCache*>(heap->AllocObject(self, dex_cache_class,
1182 dex_cache_class->GetObjectSize())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001183 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001184 return NULL;
1185 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001186 SirtRef<mirror::String>
1187 location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001188 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001189 return NULL;
1190 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001191 SirtRef<mirror::ObjectArray<mirror::String> >
1192 strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001193 if (strings.get() == NULL) {
1194 return NULL;
1195 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001196 SirtRef<mirror::ObjectArray<mirror::Class> >
1197 types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001198 if (types.get() == NULL) {
1199 return NULL;
1200 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001201 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
1202 methods(self, AllocArtMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001203 if (methods.get() == NULL) {
1204 return NULL;
1205 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001206 SirtRef<mirror::ObjectArray<mirror::ArtField> >
1207 fields(self, AllocArtFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001208 if (fields.get() == NULL) {
1209 return NULL;
1210 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001211 SirtRef<mirror::ObjectArray<mirror::StaticStorageBase> >
Ian Rogers50b35e22012-10-04 10:09:15 -07001212 initialized_static_storage(self,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001213 AllocObjectArray<mirror::StaticStorageBase>(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001214 if (initialized_static_storage.get() == NULL) {
1215 return NULL;
1216 }
1217
Mathieu Chartier66f19252012-09-18 08:57:04 -07001218 dex_cache->Init(&dex_file,
1219 location.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001220 strings.get(),
1221 types.get(),
1222 methods.get(),
1223 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001224 initialized_static_storage.get());
1225 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001226}
1227
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001228mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
1229 size_t class_size) {
1230 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07001231 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogersa436fde2013-08-27 23:34:06 -07001232 mirror::Object* k = heap->AllocObject(self, java_lang_Class, class_size);
1233 if (UNLIKELY(k == NULL)) {
1234 CHECK(self->IsExceptionPending()); // OOME.
1235 return NULL;
1236 }
1237 mirror::Class* klass = k->AsClass();
Ian Rogersee39a102013-09-19 02:56:49 -07001238 klass->SetPrimitiveType(Primitive::kPrimNot); // Default to not being primitive.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001239 klass->SetClassSize(class_size);
Ian Rogersee39a102013-09-19 02:56:49 -07001240 klass->SetDexClassDefIndex(DexFile::kDexNoIndex16); // Default to no valid class def index.
1241 klass->SetDexTypeIndex(DexFile::kDexNoIndex16); // Default to no valid type index.
Ian Rogersa436fde2013-08-27 23:34:06 -07001242 return klass;
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001243}
1244
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001245mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001246 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001247}
1248
Brian Carlstromea46f952013-07-30 01:26:50 -07001249mirror::ArtField* ClassLinker::AllocArtField(Thread* self) {
1250 return down_cast<mirror::ArtField*>(GetClassRoot(kJavaLangReflectArtField)->AllocObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001251}
1252
Brian Carlstromea46f952013-07-30 01:26:50 -07001253mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) {
1254 return down_cast<mirror::ArtMethod*>(GetClassRoot(kJavaLangReflectArtMethod)->AllocObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001255}
1256
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001257mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
1258 size_t length) {
1259 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(self,
1260 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1261 length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001262}
1263
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001264static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001265 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001266 DCHECK(klass != NULL);
1267 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001268 if (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers1f539342012-10-03 21:09:42 -07001269 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001270 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001271 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001272 ThrowClassCircularityError(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001273 klass->SetStatus(mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001274 return NULL;
1275 }
1276 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001277 while (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers05f30572013-02-20 12:13:11 -08001278 lock.WaitIgnoringInterrupts();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001279 }
1280 }
1281 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001282 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001283 return NULL;
1284 }
1285 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001286 CHECK(klass->IsResolved()) << PrettyClass(klass);
Ian Rogers62d6c772013-02-27 08:32:07 -08001287 self->AssertNoPendingException();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001288 return klass;
1289}
1290
Ian Rogersbe7149f2013-08-20 09:29:39 -07001291bool ClassLinker::IsInBootClassPath(const char* descriptor) {
1292 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1293 return pair.second != NULL;
1294}
1295
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001296mirror::Class* ClassLinker::FindSystemClass(const char* descriptor) {
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001297 return FindClass(descriptor, NULL);
1298}
1299
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001300mirror::Class* ClassLinker::FindClass(const char* descriptor, mirror::ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001301 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001302 Thread* self = Thread::Current();
1303 DCHECK(self != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001304 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001305 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001306 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1307 // for primitive classes that aren't backed by dex files.
1308 return FindPrimitiveClass(descriptor[0]);
1309 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001310 // Find the class in the loaded classes table.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001311 mirror::Class* klass = LookupClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001312 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001313 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001314 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001315 // Class is not yet loaded.
1316 if (descriptor[0] == '[') {
1317 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001318
Jesse Wilson47daf872011-11-23 11:42:45 -05001319 } else if (class_loader == NULL) {
1320 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1321 if (pair.second != NULL) {
1322 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1323 }
1324
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001325 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001326 // First try the boot class path, we check the descriptor first to avoid an unnecessary
1327 // throw of a NoClassDefFoundError.
1328 if (IsInBootClassPath(descriptor)) {
1329 mirror::Class* system_class = FindSystemClass(descriptor);
1330 CHECK(system_class != NULL);
Jesse Wilson47daf872011-11-23 11:42:45 -05001331 return system_class;
1332 }
Ian Rogersbe7149f2013-08-20 09:29:39 -07001333 // Next try the compile time class path.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001334 const std::vector<const DexFile*>* class_path;
1335 {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001336 ScopedObjectAccessUnchecked soa(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001337 ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
1338 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1339 }
1340
1341 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001342 if (pair.second != NULL) {
1343 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001344 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001345
1346 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001347 ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1348 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
1349 soa.AddLocalReference<jobject>(class_loader));
Elliott Hughes95572412011-12-13 18:14:20 -08001350 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001351 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001352 {
1353 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001354 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1355 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001356 if (class_name_object.get() == NULL) {
1357 return NULL;
1358 }
1359 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001360 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1361 WellKnownClasses::java_lang_ClassLoader_loadClass,
1362 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001363 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001364 if (soa.Self()->IsExceptionPending()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001365 // If the ClassLoader threw, pass that exception up.
1366 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001367 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001368 // broken loader - throw NPE to be compatible with Dalvik
Ian Rogers62d6c772013-02-27 08:32:07 -08001369 ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1370 class_name_string.c_str()).c_str());
Ian Rogerscab01012012-01-10 17:35:46 -08001371 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001372 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001373 // success, return mirror::Class*
1374 return soa.Decode<mirror::Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001375 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001376 }
1377
Elliott Hughes82914b62012-04-09 15:56:29 -07001378 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001379 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001380}
1381
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001382mirror::Class* ClassLinker::DefineClass(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001383 mirror::ClassLoader* class_loader,
1384 const DexFile& dex_file,
1385 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001386 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001387 SirtRef<mirror::Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001388 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001389 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001390 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001391 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001392 klass.reset(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001393 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001394 klass.reset(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001395 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001396 klass.reset(GetClassRoot(kJavaLangString));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001397 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001398 klass.reset(GetClassRoot(kJavaLangDexCache));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001399 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001400 klass.reset(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001401 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001402 klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001403 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001404 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001405 }
1406 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001407 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001408 }
Ian Rogersa436fde2013-08-27 23:34:06 -07001409 if (UNLIKELY(klass.get() == NULL)) {
1410 CHECK(self->IsExceptionPending()); // Expect an OOME.
1411 return NULL;
1412 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001413 klass->SetDexCache(FindDexCache(dex_file));
1414 LoadClass(dex_file, dex_class_def, klass, class_loader);
1415 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001416 if (self->IsExceptionPending()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001417 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001418 return NULL;
1419 }
Ian Rogers1f539342012-10-03 21:09:42 -07001420 ObjectLock lock(self, klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001421 klass->SetClinitThreadId(self->GetTid());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001422 {
1423 // Add the newly loaded class to the loaded classes table.
1424 mirror::Class* existing = InsertClass(descriptor, klass.get(), Hash(descriptor));
1425 if (existing != NULL) {
1426 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
1427 // this thread to block.
1428 return EnsureResolved(self, existing);
1429 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001430 }
1431 // Finish loading (if necessary) by finding parents
1432 CHECK(!klass->IsLoaded());
1433 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1434 // Loading failed.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001435 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001436 return NULL;
1437 }
1438 CHECK(klass->IsLoaded());
1439 // Link the class (if necessary)
1440 CHECK(!klass->IsResolved());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001441 if (!LinkClass(klass, NULL, self)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001442 // Linking failed.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001443 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001444 return NULL;
1445 }
1446 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001447
1448 /*
1449 * We send CLASS_PREPARE events to the debugger from here. The
1450 * definition of "preparation" is creating the static fields for a
1451 * class and initializing them to the standard default values, but not
1452 * executing any code (that comes later, during "initialization").
1453 *
1454 * We did the static preparation in LinkClass.
1455 *
1456 * The class has been prepared and resolved but possibly not yet verified
1457 * at this point.
1458 */
1459 Dbg::PostClassPrepare(klass.get());
1460
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001461 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001462}
1463
Brian Carlstrom4873d462011-08-21 15:23:39 -07001464// Precomputes size that will be needed for Class, matching LinkStaticFields
1465size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1466 const DexFile::ClassDef& dex_class_def) {
1467 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001468 size_t num_ref = 0;
1469 size_t num_32 = 0;
1470 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001471 if (class_data != NULL) {
1472 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1473 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001474 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001475 char c = descriptor[0];
1476 if (c == 'L' || c == '[') {
1477 num_ref++;
1478 } else if (c == 'J' || c == 'D') {
1479 num_64++;
1480 } else {
1481 num_32++;
1482 }
1483 }
1484 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001485 // start with generic class data
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001486 size_t size = sizeof(mirror::Class);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001487 // follow with reference fields which must be contiguous at start
1488 size += (num_ref * sizeof(uint32_t));
1489 // if there are 64-bit fields to add, make sure they are aligned
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001490 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
Brian Carlstrom4873d462011-08-21 15:23:39 -07001491 if (num_32 != 0) {
1492 // use an available 32-bit field for padding
1493 num_32--;
1494 }
1495 size += sizeof(uint32_t); // either way, we are adding a word
1496 DCHECK_EQ(size, RoundUp(size, 8));
1497 }
1498 // tack on any 64-bit fields now that alignment is assured
1499 size += (num_64 * sizeof(uint64_t));
1500 // tack on any remaining 32-bit fields
1501 size += (num_32 * sizeof(uint32_t));
1502 return size;
1503}
1504
Ian Rogersee39a102013-09-19 02:56:49 -07001505const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) {
1506 DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
Ian Rogers19846512012-02-24 11:42:47 -08001507 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Ian Rogersee39a102013-09-19 02:56:49 -07001508 CHECK(oat_file != NULL) << dex_file.GetLocation();
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001509 uint dex_location_checksum = dex_file.GetLocationChecksum();
1510 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation(),
1511 &dex_location_checksum);
Ian Rogersee39a102013-09-19 02:56:49 -07001512 CHECK(oat_dex_file != NULL) << dex_file.GetLocation();
1513 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_idx);
1514 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << class_def_idx;
Ian Rogers19846512012-02-24 11:42:47 -08001515 return oat_class;
1516}
1517
Ian Rogersee39a102013-09-19 02:56:49 -07001518static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint16_t class_def_idx,
1519 uint32_t method_idx) {
1520 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
1521 const byte* class_data = dex_file.GetClassData(class_def);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001522 CHECK(class_data != NULL);
1523 ClassDataItemIterator it(dex_file, class_data);
1524 // Skip fields
1525 while (it.HasNextStaticField()) {
1526 it.Next();
1527 }
1528 while (it.HasNextInstanceField()) {
1529 it.Next();
1530 }
1531 // Process methods
1532 size_t class_def_method_index = 0;
1533 while (it.HasNextDirectMethod()) {
1534 if (it.GetMemberIndex() == method_idx) {
1535 return class_def_method_index;
1536 }
1537 class_def_method_index++;
1538 it.Next();
1539 }
1540 while (it.HasNextVirtualMethod()) {
1541 if (it.GetMemberIndex() == method_idx) {
1542 return class_def_method_index;
1543 }
1544 class_def_method_index++;
1545 it.Next();
1546 }
1547 DCHECK(!it.HasNext());
1548 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1549 return 0;
1550}
1551
Brian Carlstromea46f952013-07-30 01:26:50 -07001552const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::ArtMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001553 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001554 // method for direct methods (or virtual methods made direct).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001555 mirror::Class* declaring_class = method->GetDeclaringClass();
Ian Rogersfb6adba2012-03-04 21:51:51 -08001556 size_t oat_method_index;
1557 if (method->IsStatic() || method->IsDirect()) {
1558 // Simple case where the oat method index was stashed at load time.
1559 oat_method_index = method->GetMethodIndex();
1560 } else {
1561 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1562 // by search for its position in the declared virtual methods.
1563 oat_method_index = declaring_class->NumDirectMethods();
1564 size_t end = declaring_class->NumVirtualMethods();
1565 bool found = false;
1566 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001567 if (declaring_class->GetVirtualMethod(i) == method) {
1568 found = true;
1569 break;
1570 }
Ian Rogersf320b632012-03-13 18:47:47 -07001571 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001572 }
1573 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1574 }
Ian Rogersee39a102013-09-19 02:56:49 -07001575 UniquePtr<const OatFile::OatClass>
1576 oat_class(GetOatClass(*declaring_class->GetDexCache()->GetDexFile(),
1577 declaring_class->GetDexClassDefIndex()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001578 CHECK(oat_class.get() != NULL);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001579 DCHECK_EQ(oat_method_index,
1580 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
Ian Rogersee39a102013-09-19 02:56:49 -07001581 method->GetDeclaringClass()->GetDexClassDefIndex(),
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001582 method->GetDexMethodIndex()));
1583
TDYa12785321912012-04-01 15:24:56 -07001584 return oat_class->GetOatMethod(oat_method_index);
1585}
1586
1587// Special case to get oat code without overwriting a trampoline.
Brian Carlstromea46f952013-07-30 01:26:50 -07001588const void* ClassLinker::GetOatCodeFor(const mirror::ArtMethod* method) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001589 CHECK(!method->IsAbstract()) << PrettyMethod(method);
Jeff Hao8df6cea2013-07-29 13:54:48 -07001590 if (method->IsProxyMethod()) {
1591#if !defined(ART_USE_PORTABLE_COMPILER)
1592 return reinterpret_cast<void*>(art_quick_proxy_invoke_handler);
1593#else
1594 return reinterpret_cast<void*>(art_portable_proxy_invoke_handler);
1595#endif
1596 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001597 const void* result = GetOatMethodFor(method).GetCode();
1598 if (result == NULL) {
1599 // No code? You must mean to go into the interpreter.
Ian Rogers848871b2013-08-05 10:56:33 -07001600 result = GetCompiledCodeToInterpreterBridge();
Ian Rogersf3e98552013-03-20 15:49:49 -07001601 }
1602 return result;
TDYa12785321912012-04-01 15:24:56 -07001603}
1604
Ian Rogersee39a102013-09-19 02:56:49 -07001605const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
1606 uint32_t method_idx) {
1607 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, class_def_idx));
1608 CHECK(oat_class.get() != nullptr);
1609 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001610 return oat_class->GetOatMethod(oat_method_idx).GetCode();
1611}
1612
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001613// Returns true if the method must run with interpreter, false otherwise.
Brian Carlstromea46f952013-07-30 01:26:50 -07001614static bool NeedsInterpreter(const mirror::ArtMethod* method, const void* code) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001615 if (code == NULL) {
1616 // No code: need interpreter.
1617 return true;
1618 }
Dragos Sbirlea90af14d2013-08-15 17:50:16 -07001619#ifdef ART_SEA_IR_MODE
1620 ScopedObjectAccess soa(Thread::Current());
1621 if (std::string::npos != PrettyMethod(method).find("fibonacci")) {
1622 LOG(INFO) << "Found " << PrettyMethod(method);
1623 return false;
1624 }
1625#endif
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001626 // If interpreter mode is enabled, every method (except native and proxy) must
1627 // be run with interpreter.
1628 return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
1629 !method->IsNative() && !method->IsProxyMethod();
1630}
1631
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001632void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001633 ClassHelper kh(klass);
1634 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1635 CHECK(dex_class_def != NULL);
1636 const DexFile& dex_file = kh.GetDexFile();
1637 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1638 if (class_data == NULL) {
1639 return; // no fields or methods - for example a marker interface
1640 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001641 Runtime* runtime = Runtime::Current();
1642 if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001643 // OAT file unavailable
1644 return;
1645 }
Ian Rogersee39a102013-09-19 02:56:49 -07001646 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001647 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001648 ClassDataItemIterator it(dex_file, class_data);
1649 // Skip fields
1650 while (it.HasNextStaticField()) {
1651 it.Next();
1652 }
1653 while (it.HasNextInstanceField()) {
1654 it.Next();
1655 }
Ian Rogers19846512012-02-24 11:42:47 -08001656 // Link the code of methods skipped by LinkCode
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001657 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001658 mirror::ArtMethod* method = klass->GetDirectMethod(method_index);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001659 if (!method->IsStatic()) {
1660 // Only update static methods.
1661 continue;
Ian Rogers19846512012-02-24 11:42:47 -08001662 }
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001663 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1664 const bool enter_interpreter = NeedsInterpreter(method, code);
1665 if (enter_interpreter) {
1666 // Use interpreter entry point.
Ian Rogers848871b2013-08-05 10:56:33 -07001667 code = GetCompiledCodeToInterpreterBridge();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001668 }
1669 runtime->GetInstrumentation()->UpdateMethodsCode(method, code);
Ian Rogers19846512012-02-24 11:42:47 -08001670 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001671 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08001672}
1673
Brian Carlstromea46f952013-07-30 01:26:50 -07001674static void LinkCode(SirtRef<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001675 uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001676 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001677 // Method shouldn't have already been linked.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001678 DCHECK(method->GetEntryPointFromCompiledCode() == NULL);
Brian Carlstrom92827a52011-10-10 15:50:01 -07001679 // Every kind of method should at least get an invoke stub from the oat_method.
1680 // non-abstract methods also get their code pointers.
1681 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstrom265091e2013-01-30 14:08:26 -08001682 oat_method.LinkMethod(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001683
Jeff Hao16743632013-05-08 10:59:04 -07001684 // Install entry point from interpreter.
Jeff Hao790ad902013-05-22 15:02:08 -07001685 Runtime* runtime = Runtime::Current();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001686 bool enter_interpreter = NeedsInterpreter(method.get(), method->GetEntryPointFromCompiledCode());
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001687 if (enter_interpreter) {
Ian Rogers848871b2013-08-05 10:56:33 -07001688 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001689 } else {
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07001690 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001691 }
1692
Brian Carlstrom92827a52011-10-10 15:50:01 -07001693 if (method->IsAbstract()) {
Ian Rogers848871b2013-08-05 10:56:33 -07001694 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001695 return;
1696 }
Ian Rogers19846512012-02-24 11:42:47 -08001697
1698 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001699 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001700 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
1701 // after initializing class (see ClassLinker::InitializeClass method).
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001702 method->SetEntryPointFromCompiledCode(GetResolutionTrampoline(runtime->GetClassLinker()));
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001703 } else if (enter_interpreter) {
1704 // Set entry point from compiled code if there's no code or in interpreter only mode.
Ian Rogers848871b2013-08-05 10:56:33 -07001705 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08001706 }
jeffhao26c0a1a2012-01-17 16:28:33 -08001707
Ian Rogers62d6c772013-02-27 08:32:07 -08001708 if (method->IsNative()) {
1709 // Unregistering restores the dlsym lookup stub.
1710 method->UnregisterNative(Thread::Current());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001711 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001712
Ian Rogers62d6c772013-02-27 08:32:07 -08001713 // Allow instrumentation its chance to hijack code.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001714 runtime->GetInstrumentation()->UpdateMethodsCode(method.get(),
1715 method->GetEntryPointFromCompiledCode());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001716}
1717
Brian Carlstromf615a612011-07-23 12:50:34 -07001718void ClassLinker::LoadClass(const DexFile& dex_file,
1719 const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001720 SirtRef<mirror::Class>& klass,
1721 mirror::ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001722 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001723 CHECK(klass->GetDexCache() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001724 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001725 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001726 CHECK(descriptor != NULL);
1727
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001728 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001729 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001730 // Make sure that none of our runtime-only flags are set.
mikaelpeltier6ffd0962012-10-25 15:37:45 +02001731 // TODO: JACK CLASS ACCESS (HACK TO BE REMOVED)
1732 CHECK_EQ(access_flags & ~(kAccJavaFlagsMask | kAccClassJack), 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001733 klass->SetAccessFlags(access_flags);
1734 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001735 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001736 klass->SetStatus(mirror::Class::kStatusIdx, NULL);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001737
Ian Rogersee39a102013-09-19 02:56:49 -07001738 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001739 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001740
Ian Rogers0571d352011-11-03 19:51:38 -07001741 // Load fields fields.
1742 const byte* class_data = dex_file.GetClassData(dex_class_def);
1743 if (class_data == NULL) {
1744 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001745 }
Ian Rogers0571d352011-11-03 19:51:38 -07001746 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001747 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001748 if (it.NumStaticFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001749 mirror::ObjectArray<mirror::ArtField>* statics = AllocArtFieldArray(self, it.NumStaticFields());
1750 if (UNLIKELY(statics == NULL)) {
1751 CHECK(self->IsExceptionPending()); // OOME.
1752 return;
1753 }
1754 klass->SetSFields(statics);
Ian Rogers0571d352011-11-03 19:51:38 -07001755 }
1756 if (it.NumInstanceFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001757 mirror::ObjectArray<mirror::ArtField>* fields =
1758 AllocArtFieldArray(self, it.NumInstanceFields());
1759 if (UNLIKELY(fields == NULL)) {
1760 CHECK(self->IsExceptionPending()); // OOME.
1761 return;
1762 }
1763 klass->SetIFields(fields);
Ian Rogers0571d352011-11-03 19:51:38 -07001764 }
1765 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001766 SirtRef<mirror::ArtField> sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07001767 if (UNLIKELY(sfield.get() == NULL)) {
1768 CHECK(self->IsExceptionPending()); // OOME.
1769 return;
1770 }
Ian Rogers0571d352011-11-03 19:51:38 -07001771 klass->SetStaticField(i, sfield.get());
1772 LoadField(dex_file, it, klass, sfield);
1773 }
1774 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001775 SirtRef<mirror::ArtField> ifield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07001776 if (UNLIKELY(ifield.get() == NULL)) {
1777 CHECK(self->IsExceptionPending()); // OOME.
1778 return;
1779 }
Ian Rogers0571d352011-11-03 19:51:38 -07001780 klass->SetInstanceField(i, ifield.get());
1781 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001782 }
1783
Brian Carlstromf5822582012-03-19 22:34:31 -07001784 UniquePtr<const OatFile::OatClass> oat_class;
1785 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogersee39a102013-09-19 02:56:49 -07001786 oat_class.reset(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001787 }
Ian Rogers19846512012-02-24 11:42:47 -08001788
Ian Rogers0571d352011-11-03 19:51:38 -07001789 // Load methods.
1790 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001791 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07001792 mirror::ObjectArray<mirror::ArtMethod>* directs =
1793 AllocArtMethodArray(self, it.NumDirectMethods());
1794 if (UNLIKELY(directs == NULL)) {
1795 CHECK(self->IsExceptionPending()); // OOME.
1796 return;
1797 }
1798 klass->SetDirectMethods(directs);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001799 }
Ian Rogers0571d352011-11-03 19:51:38 -07001800 if (it.NumVirtualMethods() != 0) {
1801 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07001802 mirror::ObjectArray<mirror::ArtMethod>* virtuals =
1803 AllocArtMethodArray(self, it.NumVirtualMethods());
1804 if (UNLIKELY(virtuals == NULL)) {
1805 CHECK(self->IsExceptionPending()); // OOME.
1806 return;
1807 }
1808 klass->SetVirtualMethods(virtuals);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001809 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001810 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001811 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001812 SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogersa436fde2013-08-27 23:34:06 -07001813 if (UNLIKELY(method.get() == NULL)) {
1814 CHECK(self->IsExceptionPending()); // OOME.
1815 return;
1816 }
Ian Rogers0571d352011-11-03 19:51:38 -07001817 klass->SetDirectMethod(i, method.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001818 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001819 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001820 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001821 method->SetMethodIndex(class_def_method_index);
1822 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001823 }
1824 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001825 SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogersa436fde2013-08-27 23:34:06 -07001826 if (UNLIKELY(method.get() == NULL)) {
1827 CHECK(self->IsExceptionPending()); // OOME.
1828 return;
1829 }
Ian Rogers0571d352011-11-03 19:51:38 -07001830 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001831 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001832 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001833 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001834 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001835 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001836 }
1837 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001838}
1839
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001840void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Brian Carlstromea46f952013-07-30 01:26:50 -07001841 SirtRef<mirror::Class>& klass, SirtRef<mirror::ArtField>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001842 uint32_t field_idx = it.GetMemberIndex();
1843 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001844 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001845 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001846}
1847
Brian Carlstromea46f952013-07-30 01:26:50 -07001848mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
Ian Rogersa436fde2013-08-27 23:34:06 -07001849 const ClassDataItemIterator& it,
1850 SirtRef<mirror::Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001851 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001852 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001853 StringPiece method_name(dex_file.GetMethodName(method_id));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001854
Brian Carlstromea46f952013-07-30 01:26:50 -07001855 mirror::ArtMethod* dst = AllocArtMethod(self);
Ian Rogersa436fde2013-08-27 23:34:06 -07001856 if (UNLIKELY(dst == NULL)) {
1857 CHECK(self->IsExceptionPending()); // OOME.
1858 return NULL;
1859 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001860 DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001861
Ian Rogers50b35e22012-10-04 10:09:15 -07001862 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07001863 dst->SetDexMethodIndex(dex_method_idx);
1864 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001865
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001866 if (method_name == "finalize") {
1867 // Create the prototype for a signature of "()V"
1868 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1869 if (void_string_id != NULL) {
1870 const DexFile::TypeId* void_type_id =
1871 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1872 if (void_type_id != NULL) {
1873 std::vector<uint16_t> no_args;
1874 const DexFile::ProtoId* finalizer_proto =
1875 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1876 if (finalizer_proto != NULL) {
1877 // We have the prototype in the dex file
1878 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1879 klass->SetFinalizable();
1880 } else {
Ian Rogersee39a102013-09-19 02:56:49 -07001881 ClassHelper kh(klass.get());
1882 StringPiece klass_descriptor(kh.GetDescriptor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001883 // The Enum class declares a "final" finalize() method to prevent subclasses from
1884 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1885 // subclasses, so we exclude it here.
1886 // We also want to avoid setting the flag on Object, where we know that finalize() is
1887 // empty.
1888 if (klass_descriptor != "Ljava/lang/Object;" &&
1889 klass_descriptor != "Ljava/lang/Enum;") {
1890 klass->SetFinalizable();
1891 }
1892 }
1893 }
1894 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001895 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001896 }
Ian Rogers0571d352011-11-03 19:51:38 -07001897 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001898 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001899
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001900 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001901 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001902 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001903 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001904
Brian Carlstromea46f952013-07-30 01:26:50 -07001905 CHECK(dst->IsArtMethod());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001906
Ian Rogers50b35e22012-10-04 10:09:15 -07001907 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001908 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07001909}
1910
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001911void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001912 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001913 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Ian Rogersa436fde2013-08-27 23:34:06 -07001914 CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001915 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001916}
1917
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001918void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001919 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001920 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001921 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001922}
1923
Brian Carlstromaded5f72011-10-07 17:15:04 -07001924bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001925 dex_lock_.AssertSharedHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001926 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1927 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001928 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001929 }
1930 }
1931 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001932}
1933
Brian Carlstromaded5f72011-10-07 17:15:04 -07001934bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001935 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001936 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001937}
1938
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001939void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001940 dex_lock_.AssertExclusiveHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001941 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -07001942 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()))
1943 << dex_cache->GetLocation()->ToModifiedUtf8() << " " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001944 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001945 dex_cache->SetDexFile(&dex_file);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001946 dex_caches_dirty_ = true;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001947}
1948
Brian Carlstromaded5f72011-10-07 17:15:04 -07001949void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07001950 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001951 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001952 ReaderMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001953 if (IsDexFileRegisteredLocked(dex_file)) {
1954 return;
1955 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001956 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001957 // Don't alloc while holding the lock, since allocation may need to
1958 // suspend all threads and another thread may need the dex_lock_ to
1959 // get to a suspend point.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001960 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Ian Rogersa436fde2013-08-27 23:34:06 -07001961 CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001962 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001963 WriterMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001964 if (IsDexFileRegisteredLocked(dex_file)) {
1965 return;
1966 }
1967 RegisterDexFileLocked(dex_file, dex_cache);
1968 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001969}
1970
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001971void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001972 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001973 RegisterDexFileLocked(dex_file, dex_cache);
1974}
1975
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001976mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001977 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001978 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07001979 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001980 mirror::DexCache* dex_cache = dex_caches_[i];
Mathieu Chartier66f19252012-09-18 08:57:04 -07001981 if (dex_cache->GetDexFile() == &dex_file) {
1982 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001983 }
1984 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001985 // Search matching by location name.
1986 std::string location(dex_file.GetLocation());
1987 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001988 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001989 if (dex_cache->GetDexFile()->GetLocation() == location) {
1990 return dex_cache;
1991 }
1992 }
1993 // Failure, dump diagnostic and abort.
1994 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001995 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001996 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
1997 }
1998 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001999 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002000}
2001
Brian Carlstromea46f952013-07-30 01:26:50 -07002002void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002003 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08002004 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2005 dex_caches_[i]->Fixup(resolution_method);
2006 }
2007}
2008
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002009mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002010 mirror::Class* klass = AllocClass(self, sizeof(mirror::Class));
2011 if (UNLIKELY(klass == NULL)) {
2012 return NULL;
2013 }
2014 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002015}
2016
2017mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002018 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07002019 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002020 Thread* self = Thread::Current();
2021 ObjectLock lock(self, primitive_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002022 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002023 primitive_class->SetPrimitiveType(type);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002024 primitive_class->SetStatus(mirror::Class::kStatusInitialized, self);
2025 const char* descriptor = Primitive::Descriptor(type);
2026 mirror::Class* existing = InsertClass(descriptor, primitive_class, Hash(descriptor));
Ian Rogersc8982582012-09-07 16:53:25 -07002027 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002028 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07002029}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002030
Brian Carlstrombe977852011-07-19 14:54:54 -07002031// Create an array class (i.e. the class object for the array, not the
2032// array itself). "descriptor" looks like "[C" or "[[[[B" or
2033// "[Ljava/lang/String;".
2034//
2035// If "descriptor" refers to an array of primitives, look up the
2036// primitive type's internally-generated class object.
2037//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002038// "class_loader" is the class loader of the class that's referring to
2039// us. It's used to ensure that we're looking for the element type in
2040// the right context. It does NOT become the class loader for the
2041// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07002042//
2043// Returns NULL with an exception raised on failure.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002044mirror::Class* ClassLinker::CreateArrayClass(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002045 mirror::ClassLoader* class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002046 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002047 CHECK_EQ('[', descriptor[0]);
2048 mirror::Class* component_type = FindClass(descriptor + 1, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002049 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002050 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002051 return NULL;
2052 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002053
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002054 // See if the component type is already loaded. Array classes are
2055 // always associated with the class loader of their underlying
2056 // element type -- an array of Strings goes with the loader for
2057 // java/lang/String -- so we need to look for it there. (The
2058 // caller should have checked for the existence of the class
2059 // before calling here, but they did so with *their* class loader,
2060 // not the component type's loader.)
2061 //
2062 // If we find it, the caller adds "loader" to the class' initiating
2063 // loader list, which should prevent us from going through this again.
2064 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002065 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002066 // are the same, because our caller (FindClass) just did the
2067 // lookup. (Even if we get this wrong we still have correct behavior,
2068 // because we effectively do this lookup again when we add the new
2069 // class to the hash table --- necessary because of possible races with
2070 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002071 if (class_loader != component_type->GetClassLoader()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002072 mirror::Class* new_class = LookupClass(descriptor, component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002073 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002074 return new_class;
2075 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002076 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002077
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002078 // Fill out the fields in the Class.
2079 //
2080 // It is possible to execute some methods against arrays, because
2081 // all arrays are subclasses of java_lang_Object_, so we need to set
2082 // up a vtable. We can just point at the one in java_lang_Object_.
2083 //
2084 // Array classes are simple enough that we don't need to do a full
2085 // link step.
Ian Rogers1f539342012-10-03 21:09:42 -07002086 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002087 SirtRef<mirror::Class> new_class(self, NULL);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002088 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002089 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002090 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002091 new_class.reset(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002092 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002093 new_class.reset(GetClassRoot(kObjectArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002094 } else if (strcmp(descriptor, class_roots_descriptors_[kJavaLangStringArrayClass]) == 0) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002095 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002096 } else if (strcmp(descriptor,
2097 class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002098 new_class.reset(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002099 } else if (strcmp(descriptor,
2100 class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002101 new_class.reset(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002102 } else if (strcmp(descriptor, "[C") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002103 new_class.reset(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002104 } else if (strcmp(descriptor, "[I") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002105 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002106 }
2107 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002108 if (new_class.get() == NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002109 new_class.reset(AllocClass(self, sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002110 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002111 return NULL;
2112 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002113 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002114 }
Ian Rogers1f539342012-10-03 21:09:42 -07002115 ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002116 DCHECK(new_class->GetComponentType() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002117 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002118 new_class->SetSuperClass(java_lang_Object);
2119 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002120 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002121 new_class->SetClassLoader(component_type->GetClassLoader());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002122 new_class->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002123 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002124 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002125
2126
2127 // All arrays have java/lang/Cloneable and java/io/Serializable as
2128 // interfaces. We need to set that up here, so that stuff like
2129 // "instanceof" works right.
2130 //
2131 // Note: The GC could run during the call to FindSystemClass,
2132 // so we need to make sure the class object is GC-valid while we're in
2133 // there. Do this by clearing the interface list so the GC will just
2134 // think that the entries are null.
2135
2136
2137 // Use the single, global copies of "interfaces" and "iftable"
2138 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07002139 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002140 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002141
Elliott Hughes00626c22013-06-14 15:04:14 -07002142 // Inherit access flags from the component type.
2143 int access_flags = new_class->GetComponentType()->GetAccessFlags();
2144 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2145 access_flags &= kAccJavaFlagsMask;
2146 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002147 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07002148 access_flags |= kAccAbstract | kAccFinal;
2149 access_flags &= ~kAccInterface;
2150
2151 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002152
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002153 mirror::Class* existing = InsertClass(descriptor, new_class.get(), Hash(descriptor));
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002154 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002155 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002156 }
2157 // Another thread must have loaded the class after we
2158 // started but before we finished. Abandon what we've
2159 // done.
2160 //
2161 // (Yes, this happens.)
2162
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002163 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002164}
2165
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002166mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002167 switch (Primitive::GetType(type)) {
2168 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002169 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002170 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002171 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002172 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002173 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002174 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002175 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002176 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002177 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002178 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002179 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002180 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002181 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002182 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002183 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002184 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002185 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002186 case Primitive::kPrimNot:
2187 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002188 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002189 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002190 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002191 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002192}
2193
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002194mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass,
2195 size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002196 if (VLOG_IS_ON(class_linker)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002197 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08002198 std::string source;
2199 if (dex_cache != NULL) {
2200 source += " from ";
2201 source += dex_cache->GetLocation()->ToModifiedUtf8();
2202 }
2203 LOG(INFO) << "Loaded class " << descriptor << source;
2204 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002205 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers1d54e732013-05-02 21:10:01 -07002206 mirror::Class* existing =
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002207 LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002208 if (existing != NULL) {
2209 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002210 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002211 if (kIsDebugBuild && klass->GetClassLoader() == NULL && dex_cache_image_class_lookup_required_) {
2212 // Check a class loaded with the system class loader matches one in the image if the class
2213 // is in the image.
2214 existing = LookupClassFromImage(descriptor);
2215 if (existing != NULL) {
2216 CHECK(klass == existing);
2217 }
2218 }
Ian Rogers1d54e732013-05-02 21:10:01 -07002219 Runtime::Current()->GetHeap()->VerifyObject(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002220 class_table_.insert(std::make_pair(hash, klass));
Mathieu Chartierc4621982013-09-16 19:43:47 -07002221 class_table_dirty_ = true;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002222 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002223}
2224
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002225bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002226 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002227 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002228 ClassHelper kh;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002229 for (auto it = class_table_.lower_bound(hash), end = class_table_.end(); it != end && it->first == hash;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002230 ++it) {
2231 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002232 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002233 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002234 class_table_.erase(it);
Brian Carlstromae826982011-11-09 01:33:42 -08002235 return true;
2236 }
2237 }
2238 return false;
2239}
2240
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002241mirror::Class* ClassLinker::LookupClass(const char* descriptor,
2242 const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002243 size_t hash = Hash(descriptor);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002244 {
2245 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2246 mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
2247 if (result != NULL) {
2248 return result;
2249 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002250 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002251 if (class_loader != NULL || !dex_cache_image_class_lookup_required_) {
2252 return NULL;
2253 } else {
2254 // Lookup failed but need to search dex_caches_.
2255 mirror::Class* result = LookupClassFromImage(descriptor);
2256 if (result != NULL) {
2257 InsertClass(descriptor, result, hash);
2258 } else {
2259 // Searching the image dex files/caches failed, we don't want to get into this situation
2260 // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image
2261 // classes into the class table.
2262 const int32_t kMaxFailedDexCacheLookups = 1000;
2263 if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) {
2264 MoveImageClassesToClassTable();
2265 }
2266 }
2267 return result;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002268 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002269}
2270
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002271mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor,
2272 const mirror::ClassLoader* class_loader,
2273 size_t hash) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002274 ClassHelper kh(NULL, this);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002275 auto end = class_table_.end();
2276 for (auto it = class_table_.lower_bound(hash); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002277 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002278 kh.ChangeClass(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002279 if (klass->GetClassLoader() == class_loader && strcmp(descriptor, kh.GetDescriptor()) == 0) {
2280 if (kIsDebugBuild) {
2281 // Check for duplicates in the table.
2282 for (++it; it != end && it->first == hash; ++it) {
2283 mirror::Class* klass2 = it->second;
2284 kh.ChangeClass(klass2);
2285 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
2286 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
2287 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
2288 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002289 }
Ian Rogers5d76c432011-10-31 21:42:49 -07002290 return klass;
2291 }
2292 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002293 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002294}
2295
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002296static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches()
2297 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2298 gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
2299 CHECK(image != NULL);
2300 mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
2301 return root->AsObjectArray<mirror::DexCache>();
2302}
2303
2304void ClassLinker::MoveImageClassesToClassTable() {
2305 Thread* self = Thread::Current();
2306 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2307 if (!dex_cache_image_class_lookup_required_) {
2308 return; // All dex cache classes are already in the class table.
2309 }
2310 const char* old_no_suspend_cause =
2311 self->StartAssertNoThreadSuspension("Moving image classes to class table");
2312 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002313 ClassHelper kh(NULL, this);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002314 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
2315 mirror::DexCache* dex_cache = dex_caches->Get(i);
2316 mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes();
2317 for (int32_t j = 0; j < types->GetLength(); j++) {
2318 mirror::Class* klass = types->Get(j);
2319 if (klass != NULL) {
2320 kh.ChangeClass(klass);
2321 DCHECK(klass->GetClassLoader() == NULL);
2322 const char* descriptor = kh.GetDescriptor();
2323 size_t hash = Hash(descriptor);
2324 mirror::Class* existing = LookupClassFromTableLocked(descriptor, NULL, hash);
2325 if (existing != NULL) {
2326 CHECK(existing == klass) << PrettyClassAndClassLoader(existing) << " != "
2327 << PrettyClassAndClassLoader(klass);
2328 } else {
2329 class_table_.insert(std::make_pair(hash, klass));
2330 }
2331 }
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002332 }
2333 }
Mathieu Chartierc4621982013-09-16 19:43:47 -07002334 class_table_dirty_ = true;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002335 dex_cache_image_class_lookup_required_ = false;
2336 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2337}
2338
2339mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
2340 Thread* self = Thread::Current();
2341 const char* old_no_suspend_cause =
2342 self->StartAssertNoThreadSuspension("Image class lookup");
2343 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
2344 for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
2345 mirror::DexCache* dex_cache = dex_caches->Get(i);
2346 const DexFile* dex_file = dex_cache->GetDexFile();
2347 // First search using the class def map, but don't bother for non-class types.
2348 if (descriptor[0] == 'L') {
Ian Rogersee39a102013-09-19 02:56:49 -07002349 const DexFile::StringId* descriptor_string_id = dex_file->FindStringId(descriptor);
2350 if (descriptor_string_id != NULL) {
2351 const DexFile::TypeId* type_id =
2352 dex_file->FindTypeId(dex_file->GetIndexForStringId(*descriptor_string_id));
2353 if (type_id != NULL) {
2354 mirror::Class* klass = dex_cache->GetResolvedType(dex_file->GetIndexForTypeId(*type_id));
2355 if (klass != NULL) {
2356 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2357 return klass;
2358 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002359 }
2360 }
2361 }
2362 // Now try binary searching the string/type index.
2363 const DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
2364 if (string_id != NULL) {
2365 const DexFile::TypeId* type_id =
2366 dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
2367 if (type_id != NULL) {
2368 uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id);
2369 mirror::Class* klass = dex_cache->GetResolvedType(type_idx);
2370 if (klass != NULL) {
2371 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2372 return klass;
2373 }
2374 }
2375 }
2376 }
2377 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2378 return NULL;
2379}
2380
2381void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) {
2382 result.clear();
2383 if (dex_cache_image_class_lookup_required_) {
2384 MoveImageClassesToClassTable();
2385 }
2386 size_t hash = Hash(descriptor);
2387 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2388 ClassHelper kh(NULL, this);
2389 for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
Mathieu Chartier02e25112013-08-14 16:14:24 -07002390 it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002391 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002392 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002393 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002394 result.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002395 }
2396 }
2397}
2398
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002399void ClassLinker::VerifyClass(mirror::Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002400 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002401 Thread* self = Thread::Current();
2402 ObjectLock lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002403
Ian Rogers9ffb0392012-09-10 11:56:50 -07002404 // Don't attempt to re-verify if already sufficiently verified.
2405 if (klass->IsVerified() ||
2406 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002407 return;
2408 }
2409
Ian Rogers9ffb0392012-09-10 11:56:50 -07002410 // The class might already be erroneous, for example at compile time if we attempted to verify
2411 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002412 if (klass->IsErroneous()) {
2413 ThrowEarlierClassFailure(klass);
2414 return;
2415 }
2416
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002417 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002418 klass->SetStatus(mirror::Class::kStatusVerifying, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002419 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002420 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
2421 << PrettyClass(klass);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002422 CHECK(!Runtime::Current()->IsCompiler());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002423 klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002424 }
jeffhao98eacac2011-09-14 16:11:53 -07002425
Ian Rogers9ffb0392012-09-10 11:56:50 -07002426 // Verify super class.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002427 SirtRef<mirror::Class> super(self, klass->GetSuperClass());
2428 if (super.get() != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002429 // Acquire lock to prevent races on verifying the super class.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002430 ObjectLock lock(self, super.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002431
2432 if (!super->IsVerified() && !super->IsErroneous()) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002433 VerifyClass(super.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002434 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002435 if (!super->IsCompileTimeVerified()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002436 std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
2437 PrettyDescriptor(klass).c_str(),
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002438 PrettyDescriptor(super.get()).c_str()));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002439 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002440 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002441 if (cause.get() != NULL) {
2442 self->ClearException();
2443 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002444 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002445 if (cause.get() != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002446 self->GetException(NULL)->SetCause(cause.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002447 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002448 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002449 return;
2450 }
2451 }
2452
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002453 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002454 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002455 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002456 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002457 if (oat_file_class_status == mirror::Class::kStatusError) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07002458 VLOG(class_linker) << "Skipping runtime verification of erroneous class "
2459 << PrettyDescriptor(klass) << " in "
2460 << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002461 ThrowVerifyError(klass, "Rejecting class %s because it failed compile-time verification",
2462 PrettyDescriptor(klass).c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002463 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhaoec014232012-09-05 10:42:25 -07002464 return;
2465 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002466 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
Ian Rogers62d6c772013-02-27 08:32:07 -08002467 std::string error_msg;
jeffhaof1e6b7c2012-06-05 18:33:30 -07002468 if (!preverified) {
Ian Rogersee39a102013-09-19 02:56:49 -07002469 verifier_failure = verifier::MethodVerifier::VerifyClass(klass,
2470 Runtime::Current()->IsCompiler(),
2471 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07002472 }
2473 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002474 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07002475 VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass)
Ian Rogers529781d2012-07-23 17:24:29 -07002476 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2477 << " because: " << error_msg;
2478 }
Ian Rogers1f539342012-10-03 21:09:42 -07002479 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002480 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002481 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002482 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002483 // Even though there were no verifier failures we need to respect whether the super-class
2484 // was verified or requiring runtime reverification.
2485 if (super.get() == NULL || super->IsVerified()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002486 klass->SetStatus(mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002487 } else {
2488 CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002489 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07002490 // Pretend a soft failure occured so that we don't consider the class verified below.
2491 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002492 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002493 } else {
2494 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2495 // Soft failures at compile time should be retried at runtime. Soft
2496 // failures at runtime will be handled by slow paths in the generated
2497 // code. Set status accordingly.
2498 if (Runtime::Current()->IsCompiler()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002499 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002500 } else {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002501 klass->SetStatus(mirror::Class::kStatusVerified, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002502 }
2503 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002504 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002505 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002506 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2507 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002508 self->AssertNoPendingException();
Ian Rogers62d6c772013-02-27 08:32:07 -08002509 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002510 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002511 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002512 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07002513 // Class is verified so we don't need to do any access check on its methods.
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002514 // Let the interpreter know it by setting the kAccPreverified flag onto each
2515 // method.
2516 // Note: we're going here during compilation and at runtime. When we set the
2517 // kAccPreverified flag when compiling image classes, the flag is recorded
2518 // in the image and is set when loading the image.
2519 klass->SetPreverifiedFlagOnAllMethods();
2520 }
jeffhao98eacac2011-09-14 16:11:53 -07002521}
2522
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002523bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
2524 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002525 // If we're compiling, we can only verify the class using the oat file if
2526 // we are not compiling the image or if the class we're verifying is not part of
2527 // the app. In other words, we will only check for preverification of bootclasspath
2528 // classes.
2529 if (Runtime::Current()->IsCompiler()) {
2530 // Are we compiling the bootclasspath?
2531 if (!Runtime::Current()->UseCompileTimeClassPath()) {
2532 return false;
2533 }
2534 // We are compiling an app (not the image).
2535
2536 // Is this an app class? (I.e. not a bootclasspath class)
2537 if (klass->GetClassLoader() != NULL) {
2538 return false;
2539 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002540 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002541
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002542 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07002543 // Make this work with gtests, which do not set up the image properly.
2544 // TODO: we should clean up gtests to set up the image path properly.
2545 if (Runtime::Current()->IsCompiler() && (oat_file == NULL)) {
2546 return false;
2547 }
2548
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002549 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002550 uint dex_location_checksum = dex_file.GetLocationChecksum();
2551 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation(),
2552 &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002553 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002554 const char* descriptor = ClassHelper(klass).GetDescriptor();
Ian Rogersee39a102013-09-19 02:56:49 -07002555 uint16_t class_def_index = klass->GetDexClassDefIndex();
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002556 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002557 CHECK(oat_class.get() != NULL)
2558 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002559 oat_file_class_status = oat_class->GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002560 if (oat_file_class_status == mirror::Class::kStatusVerified ||
2561 oat_file_class_status == mirror::Class::kStatusInitialized) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002562 return true;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002563 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002564 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002565 // Compile time verification failed with a soft error. Compile time verification can fail
2566 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002567 // class ... {
2568 // Foo x;
2569 // .... () {
2570 // if (...) {
2571 // v1 gets assigned a type of resolved class Foo
2572 // } else {
2573 // v1 gets assigned a type of unresolved class Bar
2574 // }
2575 // iput x = v1
2576 // } }
2577 // when we merge v1 following the if-the-else it results in Conflict
2578 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2579 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2580 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2581 // at compile time).
2582 return false;
2583 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002584 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07002585 // Compile time verification failed with a hard error. This is caused by invalid instructions
2586 // in the class. These errors are unrecoverable.
2587 return false;
2588 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002589 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002590 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2591 // not loading the class.
2592 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2593 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002594 return false;
2595 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002596 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002597 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2598
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002599 return false;
2600}
2601
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002602void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002603 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2604 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2605 }
2606 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2607 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2608 }
2609}
2610
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002611void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
Brian Carlstromea46f952013-07-30 01:26:50 -07002612 mirror::ArtMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002613 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2614 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2615 if (code_item == NULL) {
2616 return; // native or abstract method
2617 }
2618 if (code_item->tries_size_ == 0) {
2619 return; // nothing to process
2620 }
2621 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2622 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2623 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2624 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2625 CatchHandlerIterator iterator(handlers_ptr);
2626 for (; iterator.HasNext(); iterator.Next()) {
2627 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2628 // unresolved exception types will be ignored by exception delivery
2629 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002630 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002631 if (exception_type == NULL) {
2632 DCHECK(Thread::Current()->IsExceptionPending());
2633 Thread::Current()->ClearException();
2634 }
2635 }
2636 }
2637 handlers_ptr = iterator.EndDataPointer();
2638 }
2639}
2640
Brian Carlstromea46f952013-07-30 01:26:50 -07002641static void CheckProxyConstructor(mirror::ArtMethod* constructor);
2642static void CheckProxyMethod(mirror::ArtMethod* method,
2643 SirtRef<mirror::ArtMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002644
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002645mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
2646 mirror::ObjectArray<mirror::Class>* interfaces,
2647 mirror::ClassLoader* loader,
Brian Carlstromea46f952013-07-30 01:26:50 -07002648 mirror::ObjectArray<mirror::ArtMethod>* methods,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002649 mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws) {
Ian Rogers1f539342012-10-03 21:09:42 -07002650 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002651 SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2652 sizeof(mirror::SynthesizedProxyClass)));
Ian Rogersa436fde2013-08-27 23:34:06 -07002653 if (klass.get() == NULL) {
2654 CHECK(self->IsExceptionPending()); // OOME.
2655 return NULL;
2656 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002657 DCHECK(klass->GetClass() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002658 klass->SetObjectSize(sizeof(mirror::Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002659 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002660 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002661 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002662 klass->SetName(name);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002663 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002664 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002665
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002666 klass->SetStatus(mirror::Class::kStatusIdx, self);
Ian Rogersc2b44472011-12-14 21:17:17 -08002667
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002668 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogersa436fde2013-08-27 23:34:06 -07002669 {
2670 mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
2671 if (UNLIKELY(sfields == NULL)) {
2672 CHECK(self->IsExceptionPending()); // OOME.
2673 return NULL;
2674 }
2675 klass->SetSFields(sfields);
2676 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002677 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2678 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Brian Carlstromea46f952013-07-30 01:26:50 -07002679 SirtRef<mirror::ArtField> interfaces_sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002680 if (UNLIKELY(interfaces_sfield.get() == NULL)) {
2681 CHECK(self->IsExceptionPending()); // OOME.
2682 return NULL;
2683 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002684 klass->SetStaticField(0, interfaces_sfield.get());
2685 interfaces_sfield->SetDexFieldIndex(0);
2686 interfaces_sfield->SetDeclaringClass(klass.get());
2687 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2688 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Brian Carlstromea46f952013-07-30 01:26:50 -07002689 SirtRef<mirror::ArtField> throws_sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002690 if (UNLIKELY(throws_sfield.get() == NULL)) {
2691 CHECK(self->IsExceptionPending()); // OOME.
2692 return NULL;
2693 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002694 klass->SetStaticField(1, throws_sfield.get());
2695 throws_sfield->SetDexFieldIndex(1);
2696 throws_sfield->SetDeclaringClass(klass.get());
2697 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002698
Ian Rogers466bb252011-10-14 03:29:56 -07002699 // Proxies have 1 direct method, the constructor
Ian Rogersa436fde2013-08-27 23:34:06 -07002700 {
2701 mirror::ObjectArray<mirror::ArtMethod>* directs =
2702 AllocArtMethodArray(self, 1);
2703 if (UNLIKELY(directs == NULL)) {
2704 CHECK(self->IsExceptionPending()); // OOME.
2705 return NULL;
2706 }
2707 klass->SetDirectMethods(directs);
2708 mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class);
2709 if (UNLIKELY(constructor == NULL)) {
2710 CHECK(self->IsExceptionPending()); // OOME.
2711 return NULL;
2712 }
2713 klass->SetDirectMethod(0, constructor);
2714 }
Jesse Wilson95caa792011-10-12 18:14:17 -04002715
Ian Rogers466bb252011-10-14 03:29:56 -07002716 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002717 size_t num_virtual_methods = methods->GetLength();
Ian Rogersa436fde2013-08-27 23:34:06 -07002718 {
2719 mirror::ObjectArray<mirror::ArtMethod>* virtuals =
2720 AllocArtMethodArray(self, num_virtual_methods);
2721 if (UNLIKELY(virtuals == NULL)) {
2722 CHECK(self->IsExceptionPending()); // OOME.
2723 return NULL;
2724 }
2725 klass->SetVirtualMethods(virtuals);
2726 }
Jesse Wilson95caa792011-10-12 18:14:17 -04002727 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002728 SirtRef<mirror::ArtMethod> prototype(self, methods->Get(i));
Ian Rogersa436fde2013-08-27 23:34:06 -07002729 mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype);
2730 if (UNLIKELY(clone == NULL)) {
2731 CHECK(self->IsExceptionPending()); // OOME.
2732 return NULL;
2733 }
2734 klass->SetVirtualMethod(i, clone);
Jesse Wilson95caa792011-10-12 18:14:17 -04002735 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002736
2737 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002738 klass->SetStatus(mirror::Class::kStatusLoaded, self); // Class is now effectively in the loaded state
Ian Rogers62d6c772013-02-27 08:32:07 -08002739 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08002740
Ian Rogersc8982582012-09-07 16:53:25 -07002741 {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002742 ObjectLock lock(self, klass.get()); // Must hold lock on object when resolved.
2743 // Link the fields and virtual methods, creating vtable and iftables
2744 if (!LinkClass(klass, interfaces, self)) {
2745 klass->SetStatus(mirror::Class::kStatusError, self);
2746 return NULL;
2747 }
2748
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002749 interfaces_sfield->SetObject(klass.get(), interfaces);
2750 throws_sfield->SetObject(klass.get(), throws);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002751 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogersc8982582012-09-07 16:53:25 -07002752 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002753
2754 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002755 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002756 CHECK(klass->GetIFields() == NULL);
2757 CheckProxyConstructor(klass->GetDirectMethod(0));
2758 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002759 SirtRef<mirror::ArtMethod> prototype(self, methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002760 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2761 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002762
2763 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2764 name->ToModifiedUtf8().c_str()));
2765 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2766
2767 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2768 name->ToModifiedUtf8().c_str()));
2769 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002770
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002771 mirror::SynthesizedProxyClass* synth_proxy_class =
2772 down_cast<mirror::SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002773 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002774 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2775 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002776 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002777}
2778
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002779std::string ClassLinker::GetDescriptorForProxy(const mirror::Class* proxy_class) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002780 DCHECK(proxy_class->IsProxyClass());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002781 mirror::String* name = proxy_class->GetName();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002782 DCHECK(name != NULL);
2783 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2784}
2785
Brian Carlstromea46f952013-07-30 01:26:50 -07002786mirror::ArtMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
2787 const mirror::ArtMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002788 DCHECK(proxy_class->IsProxyClass());
2789 DCHECK(proxy_method->IsProxyMethod());
2790 // Locate the dex cache of the original interface/Object
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002791 mirror::DexCache* dex_cache = NULL;
Ian Rogers16f93672012-02-14 12:29:06 -08002792 {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002793 mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002794 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002795 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2796 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2797 dex_cache = dex_caches_[i];
2798 break;
2799 }
2800 }
2801 }
2802 CHECK(dex_cache != NULL);
2803 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Brian Carlstromea46f952013-07-30 01:26:50 -07002804 mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002805 CHECK(resolved_method != NULL);
2806 return resolved_method;
2807}
2808
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002809
Brian Carlstromea46f952013-07-30 01:26:50 -07002810mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
2811 SirtRef<mirror::Class>& klass,
2812 mirror::Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002813 // Create constructor for Proxy that must initialize h
Brian Carlstromea46f952013-07-30 01:26:50 -07002814 mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002815 proxy_class->GetDirectMethods();
Brian Carlstromea46f952013-07-30 01:26:50 -07002816 CHECK_EQ(proxy_direct_methods->GetLength(), 16);
2817 mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002818 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2819 // code_ too)
Brian Carlstromea46f952013-07-30 01:26:50 -07002820 mirror::ArtMethod* constructor =
2821 down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002822 if (constructor == NULL) {
2823 CHECK(self->IsExceptionPending()); // OOME.
2824 return NULL;
2825 }
Ian Rogers466bb252011-10-14 03:29:56 -07002826 // Make this constructor public and fix the class to be our Proxy version
2827 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002828 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002829 return constructor;
2830}
2831
Brian Carlstromea46f952013-07-30 01:26:50 -07002832static void CheckProxyConstructor(mirror::ArtMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002833 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002834 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002835 MethodHelper mh(constructor);
2836 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002837 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002838 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002839}
2840
Brian Carlstromea46f952013-07-30 01:26:50 -07002841mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
2842 SirtRef<mirror::ArtMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002843 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2844 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002845 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2846 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002847 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002848 // as necessary
Brian Carlstromea46f952013-07-30 01:26:50 -07002849 mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002850 if (UNLIKELY(method == NULL)) {
2851 CHECK(self->IsExceptionPending()); // OOME.
2852 return NULL;
2853 }
Ian Rogers466bb252011-10-14 03:29:56 -07002854
2855 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2856 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002857 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002858 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002859
Ian Rogers466bb252011-10-14 03:29:56 -07002860 // At runtime the method looks like a reference and argument saving method, clone the code
2861 // related parameters from this method.
Brian Carlstromea46f952013-07-30 01:26:50 -07002862 mirror::ArtMethod* refs_and_args =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002863 Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07002864 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2865 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2866 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
Ian Rogers848871b2013-08-05 10:56:33 -07002867 method->SetEntryPointFromCompiledCode(GetProxyInvokeHandler());
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07002868 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Ian Rogers16f93672012-02-14 12:29:06 -08002869
Ian Rogersc2b44472011-12-14 21:17:17 -08002870 return method;
2871}
Jesse Wilson95caa792011-10-12 18:14:17 -04002872
Brian Carlstromea46f952013-07-30 01:26:50 -07002873static void CheckProxyMethod(mirror::ArtMethod* method,
2874 SirtRef<mirror::ArtMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002875 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002876 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002877 CHECK(!prototype->IsFinal());
2878 CHECK(method->IsFinal());
2879 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002880
2881 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2882 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2883 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2884 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2885 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2886 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2887 method->GetDexCacheInitializedStaticStorage());
2888 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2889
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002890 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002891 MethodHelper mh2(prototype.get());
2892 CHECK_STREQ(mh.GetName(), mh2.GetName());
2893 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002894 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002895 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002896}
2897
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002898static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics,
2899 bool can_init_parents)
2900 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2901 if (can_init_statics && can_init_statics) {
2902 return true;
2903 }
2904 if (!can_init_statics) {
2905 // Check if there's a class initializer.
2906 mirror::ArtMethod* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2907 if (clinit != NULL) {
2908 return false;
2909 }
2910 // Check if there are encoded static values needing initialization.
2911 if (klass->NumStaticFields() != 0) {
2912 ClassHelper kh(klass);
2913 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
2914 DCHECK(dex_class_def != NULL);
2915 if (dex_class_def->static_values_off_ != 0) {
2916 return false;
2917 }
2918 }
2919 }
2920 if (!klass->IsInterface() && klass->HasSuperClass()) {
2921 mirror::Class* super_class = klass->GetSuperClass();
2922 if (!can_init_parents && !super_class->IsInitialized()) {
2923 return false;
2924 } else {
2925 if (!CanWeInitializeClass(super_class, can_init_statics, true)) {
2926 return false;
2927 }
2928 }
2929 }
2930 return true;
2931}
2932
2933bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
2934 bool can_init_parents) {
2935 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
2936
2937 // Are we already initialized and therefore done?
2938 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
2939 // an initialized class will never change its state.
2940 if (klass->IsInitialized()) {
2941 return true;
2942 }
2943
2944 // Fast fail if initialization requires a full runtime. Not part of the JLS.
2945 if (!CanWeInitializeClass(klass, can_init_statics, can_init_parents)) {
2946 return false;
2947 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002948
Carl Shapirob5573532011-07-12 18:22:59 -07002949 Thread* self = Thread::Current();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002950 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002951 {
Ian Rogers1f539342012-10-03 21:09:42 -07002952 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002953
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002954 // Re-check under the lock in case another thread initialized ahead of us.
2955 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002956 return true;
2957 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002958
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002959 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07002960 if (klass->IsErroneous()) {
2961 ThrowEarlierClassFailure(klass);
2962 return false;
2963 }
2964
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002965 CHECK(klass->IsResolved()) << PrettyClass(klass) << ": state=" << klass->GetStatus();
2966
2967 if (!klass->IsVerified()) {
jeffhao98eacac2011-09-14 16:11:53 -07002968 VerifyClass(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002969 if (!klass->IsVerified()) {
2970 // We failed to verify, expect either the klass to be erroneous or verification failed at
2971 // compile time.
2972 if (klass->IsErroneous()) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07002973 CHECK(self->IsExceptionPending());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002974 } else {
2975 CHECK(Runtime::Current()->IsCompiler());
2976 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07002977 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002978 return false;
2979 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002980 }
2981
Brian Carlstromd1422f82011-09-28 11:37:09 -07002982 // If the class is kStatusInitializing, either this thread is
2983 // initializing higher up the stack or another thread has beat us
2984 // to initializing and we need to wait. Either way, this
2985 // invocation of InitializeClass will not be responsible for
2986 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002987 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002988 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002989 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002990 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002991 return true;
2992 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002993 // No. That's fine. Wait for another thread to finish initializing.
2994 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002995 }
2996
2997 if (!ValidateSuperClassDescriptors(klass)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002998 klass->SetStatus(mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002999 return false;
3000 }
3001
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003002 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003003
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003004 // From here out other threads may observe that we're initializing and so changes of state
3005 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07003006 klass->SetClinitThreadId(self->GetTid());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003007 klass->SetStatus(mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003008
3009 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003010 }
3011
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07003012 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003013 if (!klass->IsInterface() && klass->HasSuperClass()) {
3014 mirror::Class* super_class = klass->GetSuperClass();
3015 if (!super_class->IsInitialized()) {
3016 CHECK(!super_class->IsInterface());
3017 CHECK(can_init_parents);
3018 bool super_initialized = InitializeClass(super_class, can_init_statics, true);
3019 if (!super_initialized) {
3020 // The super class was verified ahead of entering initializing, we should only be here if
3021 // the super class became erroneous due to initialization.
3022 CHECK(super_class->IsErroneous() && self->IsExceptionPending())
3023 << "Super class initialization failed for " << PrettyDescriptor(super_class)
3024 << " that has unexpected status " << super_class->GetStatus()
3025 << "\nPending exception:\n"
3026 << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
3027 ObjectLock lock(self, klass);
3028 // Initialization failed because the super-class is erroneous.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003029 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003030 return false;
3031 }
Ian Rogers1bddec32012-02-04 12:27:34 -08003032 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003033 }
3034
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003035 if (klass->NumStaticFields() > 0) {
3036 ClassHelper kh(klass);
3037 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
3038 CHECK(dex_class_def != NULL);
3039 const DexFile& dex_file = kh.GetDexFile();
3040 EncodedStaticFieldValueIterator it(dex_file, kh.GetDexCache(), klass->GetClassLoader(),
3041 this, *dex_class_def);
3042 if (it.HasNext()) {
3043 CHECK(can_init_statics);
3044 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
3045 SafeMap<uint32_t, mirror::ArtField*> field_map;
3046 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
3047 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
3048 it.ReadValueToField(field_map.Get(i));
3049 }
3050 }
3051 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003052
Ian Rogersbe7149f2013-08-20 09:29:39 -07003053 mirror::ArtMethod* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003054 if (clinit != NULL) {
3055 CHECK(can_init_statics);
3056 if (LIKELY(Runtime::Current()->IsStarted())) {
Jeff Hao5d917302013-02-27 17:57:33 -08003057 JValue result;
Jeff Hao6474d192013-03-26 14:08:09 -07003058 clinit->Invoke(self, NULL, 0, &result, 'V');
Ian Rogers64b6d142012-10-29 16:34:15 -07003059 } else {
Jeff Hao6474d192013-03-26 14:08:09 -07003060 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
Ian Rogers64b6d142012-10-29 16:34:15 -07003061 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003062 }
3063
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003064 // Opportunistically set static method trampolines to their destination.
3065 FixupStaticTrampolines(klass);
Ian Rogers19846512012-02-24 11:42:47 -08003066
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003067 uint64_t t1 = NanoTime();
3068
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003069 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003070 {
Ian Rogers1f539342012-10-03 21:09:42 -07003071 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003072
3073 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003074 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003075 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003076 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003077 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003078 RuntimeStats* global_stats = Runtime::Current()->GetStats();
3079 RuntimeStats* thread_stats = self->GetStats();
3080 ++global_stats->class_init_count;
3081 ++thread_stats->class_init_count;
3082 global_stats->class_init_time_ns += (t1 - t0);
3083 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003084 // Set the class as initialized except if failed to initialize static fields.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003085 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003086 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003087 ClassHelper kh(klass);
3088 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08003089 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003090 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003091 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003092 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003093}
3094
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003095bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003096 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003097 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003098 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003099 CHECK(!klass->IsInitialized());
Ian Rogers05f30572013-02-20 12:13:11 -08003100 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07003101
3102 // When we wake up, repeat the test for init-in-progress. If
3103 // there's an exception pending (only possible if
3104 // "interruptShouldThrow" was set), bail out.
3105 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003106 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003107 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07003108 return false;
3109 }
3110 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003111 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003112 continue;
3113 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003114 if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07003115 // Compile time initialization failed.
3116 return false;
3117 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003118 if (klass->IsErroneous()) {
3119 // The caller wants an exception, but it was thrown in a
3120 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07003121 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003122 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07003123 return false;
3124 }
3125 if (klass->IsInitialized()) {
3126 return true;
3127 }
3128 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
3129 }
3130 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
3131}
3132
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003133bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003134 if (klass->IsInterface()) {
3135 return true;
3136 }
3137 // begin with the methods local to the superclass
3138 if (klass->HasSuperClass() &&
3139 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003140 const mirror::Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08003141 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003142 const mirror::ArtMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08003143 if (method != super->GetVTable()->Get(i) &&
3144 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003145 ThrowLinkageError(klass, "Class %s method %s resolves differently in superclass %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003146 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
3147 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003148 return false;
3149 }
3150 }
3151 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003152 mirror::IfTable* iftable = klass->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003153 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003154 mirror::Class* interface = iftable->GetInterface(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003155 if (klass->GetClassLoader() != interface->GetClassLoader()) {
3156 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003157 const mirror::ArtMethod* method = iftable->GetMethodArray(i)->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08003158 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
3159 method->GetDeclaringClass())) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003160 ThrowLinkageError(klass, "Class %s method %s resolves differently in interface %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003161 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
3162 PrettyMethod(method).c_str(),
3163 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003164 return false;
3165 }
3166 }
3167 }
3168 }
3169 return true;
3170}
3171
Ian Rogers595799e2012-01-11 17:32:51 -08003172// Returns true if classes referenced by the signature of the method are the
3173// same classes in klass1 as they are in klass2.
Brian Carlstromea46f952013-07-30 01:26:50 -07003174bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::ArtMethod* method,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003175 const mirror::Class* klass1,
3176 const mirror::Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07003177 if (klass1 == klass2) {
3178 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07003179 }
Ian Rogers4445a7e2012-10-05 17:19:13 -07003180 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003181 const DexFile::ProtoId& proto_id =
3182 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07003183 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
3184 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003185 if (descriptor == NULL) {
3186 break;
3187 }
3188 if (descriptor[0] == 'L' || descriptor[0] == '[') {
3189 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08003190 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003191 return false;
3192 }
3193 }
3194 }
3195 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003196 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003197 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08003198 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003199 return false;
3200 }
3201 }
3202 return true;
3203}
3204
Ian Rogers595799e2012-01-11 17:32:51 -08003205// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
3206bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003207 const mirror::Class* klass1,
3208 const mirror::Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003209 CHECK(descriptor != NULL);
3210 CHECK(klass1 != NULL);
3211 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07003212 if (klass1 == klass2) {
3213 return true;
3214 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003215 mirror::Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08003216 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07003217 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003218 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003219 mirror::Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08003220 if (found2 == NULL) {
3221 Thread::Current()->ClearException();
3222 }
3223 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003224}
3225
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003226bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_init_fields, bool can_init_parents) {
Mathieu Chartier155dfe92012-10-09 14:24:49 -07003227 DCHECK(c != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07003228 if (c->IsInitialized()) {
3229 return true;
3230 }
3231
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003232 bool success = InitializeClass(c, can_init_fields, can_init_parents);
Ian Rogers595799e2012-01-11 17:32:51 -08003233 if (!success) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003234 Thread* self = Thread::Current();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003235 CHECK(self->IsExceptionPending() || !can_init_fields || !can_init_parents) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08003236 }
3237 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07003238}
3239
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003240void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Brian Carlstromea46f952013-07-30 01:26:50 -07003241 mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003242 mirror::ClassLoader* cl = c->GetClassLoader();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003243 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07003244 ClassDataItemIterator it(dex_file, class_data);
3245 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07003246 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003247 }
3248}
3249
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003250bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003251 mirror::ObjectArray<mirror::Class>* interfaces, Thread* self) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003252 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003253 if (!LinkSuperClass(klass)) {
3254 return false;
3255 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003256 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003257 return false;
3258 }
3259 if (!LinkInstanceFields(klass)) {
3260 return false;
3261 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07003262 if (!LinkStaticFields(klass)) {
3263 return false;
3264 }
3265 CreateReferenceInstanceOffsets(klass);
3266 CreateReferenceStaticOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003267 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003268 klass->SetStatus(mirror::Class::kStatusResolved, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003269 return true;
3270}
3271
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003272bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file) {
3273 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogersee39a102013-09-19 02:56:49 -07003274 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
3275 uint16_t super_class_idx = class_def.superclass_idx_;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003276 if (super_class_idx != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003277 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003278 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003279 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003280 return false;
3281 }
Ian Rogersbe125a92012-01-11 15:19:49 -08003282 // Verify
3283 if (!klass->CanAccess(super_class)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003284 ThrowIllegalAccessError(klass.get(), "Class %s extended by class %s is inaccessible",
3285 PrettyDescriptor(super_class).c_str(),
3286 PrettyDescriptor(klass.get()).c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08003287 return false;
3288 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003289 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003290 }
Ian Rogersee39a102013-09-19 02:56:49 -07003291 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003292 if (interfaces != NULL) {
3293 for (size_t i = 0; i < interfaces->Size(); i++) {
3294 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003295 mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003296 if (interface == NULL) {
3297 DCHECK(Thread::Current()->IsExceptionPending());
3298 return false;
3299 }
3300 // Verify
3301 if (!klass->CanAccess(interface)) {
3302 // TODO: the RI seemed to ignore this in my testing.
Ian Rogers62d6c772013-02-27 08:32:07 -08003303 ThrowIllegalAccessError(klass.get(), "Interface %s implemented by class %s is inaccessible",
3304 PrettyDescriptor(interface).c_str(),
3305 PrettyDescriptor(klass.get()).c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003306 return false;
3307 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003308 }
3309 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003310 // Mark the class as loaded.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003311 klass->SetStatus(mirror::Class::kStatusLoaded, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003312 return true;
3313}
3314
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003315bool ClassLinker::LinkSuperClass(SirtRef<mirror::Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003316 CHECK(!klass->IsPrimitive());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003317 mirror::Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003318 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003319 if (super != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003320 ThrowClassFormatError(klass.get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003321 return false;
3322 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003323 return true;
3324 }
3325 if (super == NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003326 ThrowLinkageError(klass.get(), "No superclass defined for class %s",
3327 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003328 return false;
3329 }
3330 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003331 if (super->IsFinal() || super->IsInterface()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003332 ThrowIncompatibleClassChangeError(klass.get(), "Superclass %s of %s is %s",
3333 PrettyDescriptor(super).c_str(),
3334 PrettyDescriptor(klass.get()).c_str(),
3335 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003336 return false;
3337 }
3338 if (!klass->CanAccess(super)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003339 ThrowIllegalAccessError(klass.get(), "Superclass %s is inaccessible to class %s",
3340 PrettyDescriptor(super).c_str(),
3341 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003342 return false;
3343 }
Elliott Hughes20cde902011-10-04 17:37:27 -07003344
3345 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3346 if (super->IsFinalizable()) {
3347 klass->SetFinalizable();
3348 }
3349
Elliott Hughes2da50362011-10-10 16:57:08 -07003350 // Inherit reference flags (if any) from the superclass.
3351 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3352 if (reference_flags != 0) {
3353 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3354 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003355 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07003356 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003357 ThrowLinkageError(klass.get(),
3358 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
3359 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003360 return false;
3361 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003362
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003363 if (kIsDebugBuild) {
3364 // Ensure super classes are fully resolved prior to resolving fields..
3365 while (super != NULL) {
3366 CHECK(super->IsResolved());
3367 super = super->GetSuperClass();
3368 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003369 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003370 return true;
3371}
3372
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003373// Populate the class vtable and itable. Compute return type indices.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003374bool ClassLinker::LinkMethods(SirtRef<mirror::Class>& klass,
3375 mirror::ObjectArray<mirror::Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003376 if (klass->IsInterface()) {
3377 // No vtable.
3378 size_t count = klass->NumVirtualMethods();
3379 if (!IsUint(16, count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003380 ThrowClassFormatError(klass.get(), "Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003381 return false;
3382 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003383 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003384 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003385 }
jeffhaobdb76512011-09-07 11:43:16 -07003386 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003387 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003388 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003389 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003390 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003391 }
3392 return true;
3393}
3394
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003395bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003396 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003397 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003398 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3399 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003400 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003401 // TODO: do not assign to the vtable field until it is fully constructed.
Brian Carlstromea46f952013-07-30 01:26:50 -07003402 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003403 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003404 if (UNLIKELY(vtable.get() == NULL)) {
3405 CHECK(self->IsExceptionPending()); // OOME.
3406 return false;
3407 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003408 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003409 MethodHelper local_mh(NULL, this);
3410 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003411 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003412 mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003413 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003414 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003415 for (; j < actual_count; ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003416 mirror::ArtMethod* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003417 super_mh.ChangeMethod(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003418 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3419 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3420 if (super_method->IsFinal()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003421 ThrowLinkageError(klass.get(), "Method %s overrides final method in class %s",
Elliott Hughes39717372012-07-13 16:21:23 -07003422 PrettyMethod(local_method).c_str(),
3423 super_mh.GetDeclaringClassDescriptor());
3424 return false;
3425 }
3426 vtable->Set(j, local_method);
3427 local_method->SetMethodIndex(j);
3428 break;
3429 } else {
3430 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3431 << " would have incorrectly overridden the package-private method in "
3432 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003433 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003434 }
3435 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003436 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003437 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003438 vtable->Set(actual_count, local_method);
3439 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003440 actual_count += 1;
3441 }
3442 }
3443 if (!IsUint(16, actual_count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003444 ThrowClassFormatError(klass.get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003445 return false;
3446 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003447 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003448 CHECK_LE(actual_count, max_count);
3449 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003450 vtable.reset(vtable->CopyOf(self, actual_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003451 if (UNLIKELY(vtable.get() == NULL)) {
3452 CHECK(self->IsExceptionPending()); // OOME.
3453 return false;
3454 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003455 }
Ian Rogers30fab402012-01-23 15:43:46 -08003456 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003457 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003458 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003459 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003460 if (!IsUint(16, num_virtual_methods)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003461 ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003462 return false;
3463 }
Brian Carlstromea46f952013-07-30 01:26:50 -07003464 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3465 vtable(self, AllocArtMethodArray(self, num_virtual_methods));
Ian Rogersa436fde2013-08-27 23:34:06 -07003466 if (UNLIKELY(vtable.get() == NULL)) {
3467 CHECK(self->IsExceptionPending()); // OOME.
3468 return false;
3469 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003470 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003471 mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003472 vtable->Set(i, virtual_method);
3473 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003474 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003475 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003476 }
3477 return true;
3478}
3479
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003480bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
3481 mirror::ObjectArray<mirror::Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003482 size_t super_ifcount;
3483 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003484 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003485 } else {
3486 super_ifcount = 0;
3487 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003488 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003489 ClassHelper kh(klass.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -07003490 uint32_t num_interfaces = interfaces == NULL ? kh.NumDirectInterfaces() : interfaces->GetLength();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003491 ifcount += num_interfaces;
3492 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003493 mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003494 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003495 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003496 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003497 // Class implements no interfaces.
3498 DCHECK_EQ(klass->GetIfTableCount(), 0);
3499 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003500 return true;
3501 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003502 if (ifcount == super_ifcount) {
3503 // Class implements same interfaces as parent, are any of these not marker interfaces?
3504 bool has_non_marker_interface = false;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003505 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Ian Rogers9bc81912012-10-11 21:43:36 -07003506 for (size_t i = 0; i < ifcount; ++i) {
3507 if (super_iftable->GetMethodArrayCount(i) > 0) {
3508 has_non_marker_interface = true;
3509 break;
3510 }
3511 }
3512 if (!has_non_marker_interface) {
3513 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3514 klass->SetIfTable(super_iftable);
3515 return true;
3516 }
3517 }
Ian Rogers1f539342012-10-03 21:09:42 -07003518 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003519 SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
Ian Rogersa436fde2013-08-27 23:34:06 -07003520 if (UNLIKELY(iftable.get() == NULL)) {
3521 CHECK(self->IsExceptionPending()); // OOME.
3522 return false;
3523 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003524 if (super_ifcount != 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003525 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003526 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003527 mirror::Class* super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003528 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003529 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003530 }
3531 // Flatten the interface inheritance hierarchy.
3532 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003533 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003534 mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003535 DCHECK(interface != NULL);
3536 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003537 ClassHelper ih(interface);
Ian Rogers62d6c772013-02-27 08:32:07 -08003538 ThrowIncompatibleClassChangeError(klass.get(), "Class %s implements non-interface class %s",
3539 PrettyDescriptor(klass.get()).c_str(),
3540 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003541 return false;
3542 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003543 // Check if interface is already in iftable
3544 bool duplicate = false;
3545 for (size_t j = 0; j < idx; j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003546 mirror::Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003547 if (existing_interface == interface) {
3548 duplicate = true;
3549 break;
3550 }
3551 }
3552 if (!duplicate) {
3553 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003554 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003555 // Add this interface's non-duplicate super-interfaces.
3556 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003557 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003558 bool super_duplicate = false;
3559 for (size_t k = 0; k < idx; k++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003560 mirror::Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003561 if (existing_interface == super_interface) {
3562 super_duplicate = true;
3563 break;
3564 }
3565 }
3566 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003567 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003568 }
3569 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003570 }
3571 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003572 // Shrink iftable in case duplicates were found
3573 if (idx < ifcount) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003574 iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003575 if (UNLIKELY(iftable.get() == NULL)) {
3576 CHECK(self->IsExceptionPending()); // OOME.
3577 return false;
3578 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003579 ifcount = idx;
3580 } else {
3581 CHECK_EQ(idx, ifcount);
3582 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003583 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003584
3585 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003586 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003587 return true;
3588 }
Brian Carlstromea46f952013-07-30 01:26:50 -07003589 std::vector<mirror::ArtMethod*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003590 MethodHelper vtable_mh(NULL, this);
3591 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003592 for (size_t i = 0; i < ifcount; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003593 mirror::Class* interface = iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003594 size_t num_methods = interface->NumVirtualMethods();
3595 if (num_methods > 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003596 mirror::ObjectArray<mirror::ArtMethod>* method_array =
3597 AllocArtMethodArray(self, num_methods);
Ian Rogersa436fde2013-08-27 23:34:06 -07003598 if (UNLIKELY(method_array == NULL)) {
3599 CHECK(self->IsExceptionPending()); // OOME.
3600 return false;
3601 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003602 iftable->SetMethodArray(i, method_array);
Brian Carlstromea46f952013-07-30 01:26:50 -07003603 mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
Ian Rogers62d6c772013-02-27 08:32:07 -08003604 for (size_t j = 0; j < num_methods; ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003605 mirror::ArtMethod* interface_method = interface->GetVirtualMethod(j);
Ian Rogers9bc81912012-10-11 21:43:36 -07003606 interface_mh.ChangeMethod(interface_method);
3607 int32_t k;
3608 // For each method listed in the interface's method list, find the
3609 // matching method in our class's method list. We want to favor the
3610 // subclass over the superclass, which just requires walking
3611 // back from the end of the vtable. (This only matters if the
3612 // superclass defines a private method and this class redefines
3613 // it -- otherwise it would use the same vtable slot. In .dex files
3614 // those don't end up in the virtual method table, so it shouldn't
3615 // matter which direction we go. We walk it backward anyway.)
3616 for (k = vtable->GetLength() - 1; k >= 0; --k) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003617 mirror::ArtMethod* vtable_method = vtable->Get(k);
Ian Rogers9bc81912012-10-11 21:43:36 -07003618 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003619 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Elliott Hughes68243612013-02-22 17:16:07 -08003620 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003621 ThrowIllegalAccessError(klass.get(),
3622 "Method '%s' implementing interface method '%s' is not public",
3623 PrettyMethod(vtable_method).c_str(),
3624 PrettyMethod(interface_method).c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07003625 return false;
3626 }
3627 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003628 break;
3629 }
3630 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003631 if (k < 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003632 SirtRef<mirror::ArtMethod> miranda_method(self, NULL);
Ian Rogers9bc81912012-10-11 21:43:36 -07003633 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003634 mirror::ArtMethod* mir_method = miranda_list[mir];
Ian Rogers9bc81912012-10-11 21:43:36 -07003635 vtable_mh.ChangeMethod(mir_method);
3636 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3637 miranda_method.reset(miranda_list[mir]);
3638 break;
3639 }
3640 }
3641 if (miranda_method.get() == NULL) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003642 // Point the interface table at a phantom slot.
Brian Carlstromea46f952013-07-30 01:26:50 -07003643 miranda_method.reset(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003644 if (UNLIKELY(miranda_method.get() == NULL)) {
3645 CHECK(self->IsExceptionPending()); // OOME.
3646 return false;
3647 }
3648#ifdef MOVING_GARBAGE_COLLECTOR
3649 // TODO: If a methods move then the miranda_list may hold stale references.
3650 UNIMPLEMENTED(FATAL);
3651#endif
Ian Rogers9bc81912012-10-11 21:43:36 -07003652 miranda_list.push_back(miranda_method.get());
3653 }
3654 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003655 }
3656 }
3657 }
3658 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003659 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003660 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003661 int new_method_count = old_method_count + miranda_list.size();
Ian Rogersa436fde2013-08-27 23:34:06 -07003662 mirror::ObjectArray<mirror::ArtMethod>* virtuals;
3663 if (old_method_count == 0) {
3664 virtuals = AllocArtMethodArray(self, new_method_count);
3665 } else {
3666 virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count);
3667 }
3668 if (UNLIKELY(virtuals == NULL)) {
3669 CHECK(self->IsExceptionPending()); // OOME.
3670 return false;
3671 }
3672 klass->SetVirtualMethods(virtuals);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003673
Brian Carlstromea46f952013-07-30 01:26:50 -07003674 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003675 vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003676 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003677 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003678 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003679 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003680 if (UNLIKELY(vtable.get() == NULL)) {
3681 CHECK(self->IsExceptionPending()); // OOME.
3682 return false;
3683 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003684 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003685 mirror::ArtMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003686 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003687 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3688 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3689 klass->SetVirtualMethod(old_method_count + i, method);
3690 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003691 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003692 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003693 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003694 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003695
Brian Carlstromea46f952013-07-30 01:26:50 -07003696 mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003697 for (int i = 0; i < vtable->GetLength(); ++i) {
3698 CHECK(vtable->Get(i) != NULL);
3699 }
3700
3701// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3702
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003703 return true;
3704}
3705
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003706bool ClassLinker::LinkInstanceFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003707 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003708 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003709}
3710
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003711bool ClassLinker::LinkStaticFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003712 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003713 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003714 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003715 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003716 return success;
3717}
3718
Brian Carlstromdbc05252011-09-09 01:59:59 -07003719struct LinkFieldsComparator {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003720 explicit LinkFieldsComparator(FieldHelper* fh)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003721 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003722 : fh_(fh) {}
3723 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Brian Carlstromea46f952013-07-30 01:26:50 -07003724 bool operator()(const mirror::ArtField* field1, const mirror::ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003725 NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003726 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003727 fh_->ChangeField(field1);
3728 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3729 fh_->ChangeField(field2);
3730 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003731 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3732 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3733 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3734 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003735 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3736 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3737 if (order1 != order2) {
3738 return order1 < order2;
3739 }
3740
3741 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003742 fh_->ChangeField(field1);
3743 StringPiece name1(fh_->GetName());
3744 fh_->ChangeField(field2);
3745 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003746 return name1 < name2;
3747 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003748
3749 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003750};
3751
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003752bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003753 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003754 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003755
Brian Carlstromea46f952013-07-30 01:26:50 -07003756 mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003757 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003758
3759 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003760 size_t size;
3761 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003762 if (is_static) {
3763 size = klass->GetClassSize();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003764 field_offset = mirror::Class::FieldsOffset();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003765 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003766 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003767 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003768 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003769 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003770 }
3771 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003772 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003773
Brian Carlstromdbc05252011-09-09 01:59:59 -07003774 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003775
Brian Carlstromdbc05252011-09-09 01:59:59 -07003776 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003777 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromea46f952013-07-30 01:26:50 -07003778 std::deque<mirror::ArtField*> grouped_and_sorted_fields;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003779 for (size_t i = 0; i < num_fields; i++) {
3780 grouped_and_sorted_fields.push_back(fields->Get(i));
3781 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003782 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003783 std::sort(grouped_and_sorted_fields.begin(),
3784 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003785 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003786
3787 // References should be at the front.
3788 size_t current_field = 0;
3789 size_t num_reference_fields = 0;
3790 for (; current_field < num_fields; current_field++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003791 mirror::ArtField* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003792 fh.ChangeField(field);
3793 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003794 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003795 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003796 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003797 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003798 grouped_and_sorted_fields.pop_front();
3799 num_reference_fields++;
3800 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003801 field->SetOffset(field_offset);
3802 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003803 }
3804
3805 // Now we want to pack all of the double-wide fields together. If
3806 // we're not aligned, though, we want to shuffle one 32-bit field
3807 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003808 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003809 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003810 mirror::ArtField* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003811 fh.ChangeField(field);
3812 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003813 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3814 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003815 continue;
3816 }
3817 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003818 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003819 // drop the consumed field
3820 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3821 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003822 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003823 // whether we found a 32-bit field for padding or not, we advance
3824 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003825 }
3826
3827 // Alignment is good, shuffle any double-wide fields forward, and
3828 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003829 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003830 while (!grouped_and_sorted_fields.empty()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003831 mirror::ArtField* field = grouped_and_sorted_fields.front();
Brian Carlstromdbc05252011-09-09 01:59:59 -07003832 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003833 fh.ChangeField(field);
3834 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003835 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003836 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003837 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003838 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003839 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003840 ? sizeof(uint64_t)
3841 : sizeof(uint32_t)));
3842 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003843 }
3844
Elliott Hughesadb460d2011-10-05 17:02:34 -07003845 // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
Ian Rogers64b6d142012-10-29 16:34:15 -07003846 if (!is_static &&
3847 StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003848 // We know there are no non-reference fields in the Reference classes, and we know
3849 // that 'referent' is alphabetically last, so this is easy...
3850 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003851 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003852 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003853 --num_reference_fields;
3854 }
3855
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003856#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003857 // Make sure that all reference fields appear before
3858 // non-reference fields, and all double-wide fields are aligned.
3859 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003860 for (size_t i = 0; i < num_fields; i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003861 mirror::ArtField* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003862 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003863 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003864 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003865 << " field=" << PrettyField(field)
Brian Carlstromea46f952013-07-30 01:26:50 -07003866 << " offset=" << field->GetField32(MemberOffset(mirror::ArtField::OffsetOffset()),
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003867 false);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003868 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003869 fh.ChangeField(field);
3870 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003871 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers64b6d142012-10-29 16:34:15 -07003872 if (StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;" &&
3873 StringPiece(fh.GetName()) == "referent") {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003874 is_primitive = true; // We lied above, so we have to expect a lie here.
Elliott Hughesadb460d2011-10-05 17:02:34 -07003875 }
3876 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003877 if (!seen_non_ref) {
3878 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003879 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003880 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003881 } else {
3882 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003883 }
3884 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003885 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003886 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003887 }
3888#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003889 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003890 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003891 if (is_static) {
3892 klass->SetNumReferenceStaticFields(num_reference_fields);
3893 klass->SetClassSize(size);
3894 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003895 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003896 if (!klass->IsVariableSize()) {
Brian Carlstrom62cd0982013-06-03 11:30:25 -07003897 DCHECK_GE(size, sizeof(mirror::Object)) << ClassHelper(klass.get(), this).GetDescriptor();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003898 klass->SetObjectSize(size);
3899 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003900 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003901 return true;
3902}
3903
3904// Set the bitmap of reference offsets, refOffsets, from the ifields
3905// list.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003906void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003907 uint32_t reference_offsets = 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003908 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003909 if (super_class != NULL) {
3910 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003911 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003912 if (reference_offsets == CLASS_WALK_SUPER) {
3913 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003914 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003915 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003916 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003917 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003918}
3919
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003920void ClassLinker::CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003921 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003922}
3923
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003924void ClassLinker::CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003925 uint32_t reference_offsets) {
3926 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003927 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3928 : klass->NumReferenceInstanceFieldsDuringLinking();
Brian Carlstromea46f952013-07-30 01:26:50 -07003929 const mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003930 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003931 // All of the fields that contain object references are guaranteed
3932 // to be at the beginning of the fields list.
3933 for (size_t i = 0; i < num_reference_fields; ++i) {
3934 // Note that byte_offset is the offset from the beginning of
3935 // object, not the offset into instance data
Brian Carlstromea46f952013-07-30 01:26:50 -07003936 const mirror::ArtField* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003937 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003938 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3939 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3940 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003941 CHECK_NE(new_bit, 0U);
3942 reference_offsets |= new_bit;
3943 } else {
3944 reference_offsets = CLASS_WALK_SUPER;
3945 break;
3946 }
3947 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003948 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003949 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003950 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003951 } else {
3952 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003953 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003954}
3955
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003956mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
3957 uint32_t string_idx, mirror::DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003958 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003959 mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003960 if (resolved != NULL) {
3961 return resolved;
3962 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003963 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3964 int32_t utf16_length = dex_file.GetStringLength(string_id);
3965 const char* utf8_data = dex_file.GetStringData(string_id);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003966 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003967 dex_cache->SetResolvedString(string_idx, string);
3968 return string;
3969}
3970
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003971mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
3972 uint16_t type_idx,
3973 mirror::DexCache* dex_cache,
3974 mirror::ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003975 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003976 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003977 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003978 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003979 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003980 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003981 // TODO: we used to throw here if resolved's class loader was not the
3982 // boot class loader. This was to permit different classes with the
3983 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003984 dex_cache->SetResolvedType(type_idx, resolved);
3985 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003986 Thread* self = Thread::Current();
3987 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08003988 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08003989 // Convert a ClassNotFoundException to a NoClassDefFoundError.
3990 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
3991 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
jeffhao8cd6dda2012-02-22 10:15:34 -08003992 Thread::Current()->ClearException();
3993 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Ian Rogers62d6c772013-02-27 08:32:07 -08003994 self->GetException(NULL)->SetCause(cause.get());
jeffhao8cd6dda2012-02-22 10:15:34 -08003995 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003996 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003997 }
Brian Carlstromabcf7ae2013-09-23 22:19:52 -07003998 DCHECK((resolved == NULL) || resolved->IsResolved() || resolved->IsErroneous())
3999 << PrettyDescriptor(resolved) << " " << resolved->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004000 return resolved;
4001}
4002
Brian Carlstromea46f952013-07-30 01:26:50 -07004003mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004004 uint32_t method_idx,
4005 mirror::DexCache* dex_cache,
4006 mirror::ClassLoader* class_loader,
Brian Carlstromea46f952013-07-30 01:26:50 -07004007 const mirror::ArtMethod* referrer,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004008 InvokeType type) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08004009 DCHECK(dex_cache != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07004010 // Check for hit in the dex cache.
Brian Carlstromea46f952013-07-30 01:26:50 -07004011 mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004012 if (resolved != NULL) {
4013 return resolved;
4014 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004015 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004016 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004017 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004018 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07004019 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004020 return NULL;
4021 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004022 // Scan using method_idx, this saves string compares but will only hit for matching dex
4023 // caches/files.
4024 switch (type) {
4025 case kDirect: // Fall-through.
4026 case kStatic:
4027 resolved = klass->FindDirectMethod(dex_cache, method_idx);
4028 break;
4029 case kInterface:
4030 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Ian Rogers4c5b2652012-12-15 21:36:16 -08004031 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07004032 break;
4033 case kSuper: // Fall-through.
4034 case kVirtual:
4035 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
4036 break;
4037 default:
4038 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004039 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004040 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07004041 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004042 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
4043 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
Ian Rogers08f753d2012-08-24 14:35:25 -07004044 switch (type) {
4045 case kDirect: // Fall-through.
4046 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08004047 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004048 break;
4049 case kInterface:
4050 resolved = klass->FindInterfaceMethod(name, signature);
Ian Rogers4c5b2652012-12-15 21:36:16 -08004051 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07004052 break;
4053 case kSuper: // Fall-through.
4054 case kVirtual:
4055 resolved = klass->FindVirtualMethod(name, signature);
4056 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004057 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004058 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004059 if (resolved != NULL) {
4060 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07004061 if (resolved->CheckIncompatibleClassChange(type)) {
4062 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07004063 }
4064 }
4065 if (resolved != NULL) {
4066 // Be a good citizen and update the dex cache to speed subsequent calls.
4067 dex_cache->SetResolvedMethod(method_idx, resolved);
4068 return resolved;
4069 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07004070 // We failed to find the method which means either an access error, an incompatible class
4071 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07004072 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
4073 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
4074 switch (type) {
4075 case kDirect:
4076 case kStatic:
4077 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07004078 break;
4079 case kInterface:
4080 case kVirtual:
4081 case kSuper:
4082 resolved = klass->FindDirectMethod(name, signature);
4083 break;
4084 }
4085
4086 // If we found something, check that it can be accessed by the referrer.
4087 if (resolved != NULL && referrer != NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004088 mirror::Class* methods_class = resolved->GetDeclaringClass();
4089 mirror::Class* referring_class = referrer->GetDeclaringClass();
jeffhaoc0228b82012-08-29 18:15:05 -07004090 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07004091 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
4092 referrer, resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07004093 return NULL;
4094 } else if (!referring_class->CanAccessMember(methods_class,
4095 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07004096 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07004097 return NULL;
4098 }
4099 }
4100
4101 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
4102 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
4103 switch (type) {
4104 case kDirect:
4105 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07004106 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004107 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004108 } else {
4109 resolved = klass->FindInterfaceMethod(name, signature);
4110 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004111 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004112 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004113 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004114 }
4115 }
4116 break;
4117 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07004118 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004119 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004120 } else {
4121 resolved = klass->FindVirtualMethod(name, signature);
4122 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004123 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004124 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004125 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004126 }
4127 }
4128 break;
4129 case kSuper:
Ian Rogers62d6c772013-02-27 08:32:07 -08004130 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004131 break;
4132 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07004133 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004134 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004135 } else {
4136 resolved = klass->FindInterfaceMethod(name, signature);
4137 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004138 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004139 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004140 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004141 }
4142 }
4143 break;
4144 }
4145 DCHECK(Thread::Current()->IsExceptionPending());
4146 return NULL;
4147 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004148}
4149
Brian Carlstromea46f952013-07-30 01:26:50 -07004150mirror::ArtField* ClassLinker::ResolveField(const DexFile& dex_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004151 uint32_t field_idx,
4152 mirror::DexCache* dex_cache,
4153 mirror::ClassLoader* class_loader,
4154 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08004155 DCHECK(dex_cache != NULL);
Brian Carlstromea46f952013-07-30 01:26:50 -07004156 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004157 if (resolved != NULL) {
4158 return resolved;
4159 }
4160 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004161 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004162 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08004163 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004164 return NULL;
4165 }
4166
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004167 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004168 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004169 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004170 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004171 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004172
4173 if (resolved == NULL) {
4174 const char* name = dex_file.GetFieldName(field_id);
4175 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
4176 if (is_static) {
4177 resolved = klass->FindStaticField(name, type);
4178 } else {
4179 resolved = klass->FindInstanceField(name, type);
4180 }
4181 if (resolved == NULL) {
4182 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
4183 return NULL;
4184 }
Ian Rogersb067ac22011-12-13 18:05:09 -08004185 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004186 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08004187 return resolved;
4188}
4189
Brian Carlstromea46f952013-07-30 01:26:50 -07004190mirror::ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004191 uint32_t field_idx,
4192 mirror::DexCache* dex_cache,
4193 mirror::ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08004194 DCHECK(dex_cache != NULL);
Brian Carlstromea46f952013-07-30 01:26:50 -07004195 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Ian Rogersb067ac22011-12-13 18:05:09 -08004196 if (resolved != NULL) {
4197 return resolved;
4198 }
4199 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004200 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Ian Rogersb067ac22011-12-13 18:05:09 -08004201 if (klass == NULL) {
4202 DCHECK(Thread::Current()->IsExceptionPending());
4203 return NULL;
4204 }
4205
4206 const char* name = dex_file.GetFieldName(field_id);
4207 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
4208 resolved = klass->FindField(name, type);
4209 if (resolved != NULL) {
4210 dex_cache->SetResolvedField(field_idx, resolved);
4211 } else {
4212 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004213 }
4214 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07004215}
4216
Brian Carlstromea46f952013-07-30 01:26:50 -07004217const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004218 uint32_t* length) {
4219 mirror::Class* declaring_class = referrer->GetDeclaringClass();
4220 mirror::DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07004221 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07004222 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08004223 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07004224}
4225
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004226void ClassLinker::DumpAllClasses(int flags) {
4227 if (dex_cache_image_class_lookup_required_) {
4228 MoveImageClassesToClassTable();
4229 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004230 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
4231 // lock held, because it might need to resolve a field's type, which would try to take the lock.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004232 std::vector<mirror::Class*> all_classes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004233 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004234 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004235 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07004236 all_classes.push_back(it.second);
Ian Rogers5d76c432011-10-31 21:42:49 -07004237 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004238 }
4239
4240 for (size_t i = 0; i < all_classes.size(); ++i) {
4241 all_classes[i]->DumpClass(std::cerr, flags);
4242 }
4243}
4244
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004245void ClassLinker::DumpForSigQuit(std::ostream& os) {
4246 if (dex_cache_image_class_lookup_required_) {
4247 MoveImageClassesToClassTable();
4248 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004249 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004250 os << "Loaded classes: " << class_table_.size() << " allocated classes\n";
Elliott Hughescac6cc72011-11-03 20:31:21 -07004251}
4252
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004253size_t ClassLinker::NumLoadedClasses() {
4254 if (dex_cache_image_class_lookup_required_) {
4255 MoveImageClassesToClassTable();
4256 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004257 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004258 return class_table_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07004259}
4260
Brian Carlstrom47d237a2011-10-18 15:08:33 -07004261pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07004262 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07004263}
4264
4265pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004266 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07004267}
4268
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004269void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004270 DCHECK(!init_done_);
4271
4272 DCHECK(klass != NULL);
4273 DCHECK(klass->GetClassLoader() == NULL);
4274
4275 DCHECK(class_roots_ != NULL);
4276 DCHECK(class_roots_->Get(class_root) == NULL);
4277 class_roots_->Set(class_root, klass);
4278}
4279
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004280} // namespace art