blob: 500cb59bee44ffbd8e88d8183ecae461aaf35738 [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
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800173ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700174 // dex_lock_ is recursive as it may be used in stack dumping.
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700175 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700176 dex_cache_image_class_lookup_required_(false),
177 failed_dex_cache_class_lookups_(0),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700178 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700179 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700180 init_done_(false),
Mathieu Chartierc4621982013-09-16 19:43:47 -0700181 dex_caches_dirty_(false),
182 class_table_dirty_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700183 intern_table_(intern_table),
184 portable_resolution_trampoline_(NULL),
Jeff Hao88474b42013-10-23 16:24:40 -0700185 quick_resolution_trampoline_(NULL),
186 portable_imt_conflict_trampoline_(NULL),
187 quick_imt_conflict_trampoline_(NULL) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700188 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700189}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700190
Brian Carlstroma004aa92012-02-08 18:05:09 -0800191void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
192 VLOG(startup) << "ClassLinker::Init";
193 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700194
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700195 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700196
Elliott Hughes30646832011-10-13 16:59:46 -0700197 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700198 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700199 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700200 // The GC can't handle an object with a null class since we can't get the size of this object.
201 heap->IncrementDisableGC(self);
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800202 SirtRef<mirror::Class> java_lang_Class(self, down_cast<mirror::Class*>(
203 heap->AllocNonMovableObject<true>(self, nullptr, sizeof(mirror::ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700204 CHECK(java_lang_Class.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800205 mirror::Class::SetClassClass(java_lang_Class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700206 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800207 java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700208 heap->DecrementDisableGC(self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800209 // AllocClass(mirror::Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700210
Elliott Hughes418d20f2011-09-22 14:00:39 -0700211 // Class[] is used for reflection support.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800212 SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700213 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700214
Ian Rogers23435d02012-09-24 11:23:12 -0700215 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800216 SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700217 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700218 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700219 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700220 java_lang_Object->SetStatus(mirror::Class::kStatusLoaded, self);
Brian Carlstroma0808032011-07-18 00:39:23 -0700221
Ian Rogers23435d02012-09-24 11:23:12 -0700222 // Object[] next to hold class roots.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800223 SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700224 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700225
Ian Rogers23435d02012-09-24 11:23:12 -0700226 // Setup the char class to be used for char[].
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800227 SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700228
Ian Rogers23435d02012-09-24 11:23:12 -0700229 // Setup the char[] class to be used for String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800230 SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700231 char_array_class->SetComponentType(char_class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800232 mirror::CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700233
Ian Rogers23435d02012-09-24 11:23:12 -0700234 // Setup String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800235 SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
236 mirror::String::SetClass(java_lang_String.get());
237 java_lang_String->SetObjectSize(sizeof(mirror::String));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700238 java_lang_String->SetStatus(mirror::Class::kStatusResolved, self);
Jesse Wilson14150742011-07-29 19:04:44 -0400239
Ian Rogers23435d02012-09-24 11:23:12 -0700240 // Create storage for root classes, save away our work so far (requires descriptors).
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800241 class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(),
242 kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700243 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700244 SetClassRoot(kJavaLangClass, java_lang_Class.get());
245 SetClassRoot(kJavaLangObject, java_lang_Object.get());
246 SetClassRoot(kClassArrayClass, class_array_class.get());
247 SetClassRoot(kObjectArrayClass, object_array_class.get());
248 SetClassRoot(kCharArrayClass, char_array_class.get());
249 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700250
251 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700252 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
253 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
254 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
255 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
256 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
257 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
258 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
259 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700260
Ian Rogers23435d02012-09-24 11:23:12 -0700261 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700262 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700263
Ian Rogers23435d02012-09-24 11:23:12 -0700264 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800265 SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700266 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800267 mirror::IntArray::SetArrayClass(int_array_class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700268 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700269
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700270 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700271
Ian Rogers52813c92012-10-11 11:50:38 -0700272 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800273 SirtRef<mirror::Class>
274 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700275 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
Mathieu Chartier79b4f382013-10-23 15:21:37 -0700276 java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCache));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700277 java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700278
Mathieu Chartier66f19252012-09-18 08:57:04 -0700279 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Brian Carlstromea46f952013-07-30 01:26:50 -0700280 SirtRef<mirror::Class> java_lang_reflect_ArtField(self, AllocClass(self, java_lang_Class.get(),
281 sizeof(mirror::ArtFieldClass)));
282 CHECK(java_lang_reflect_ArtField.get() != NULL);
283 java_lang_reflect_ArtField->SetObjectSize(sizeof(mirror::ArtField));
284 SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700285 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700286 mirror::ArtField::SetClass(java_lang_reflect_ArtField.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700287
Brian Carlstromea46f952013-07-30 01:26:50 -0700288 SirtRef<mirror::Class> java_lang_reflect_ArtMethod(self, AllocClass(self, java_lang_Class.get(),
289 sizeof(mirror::ArtMethodClass)));
290 CHECK(java_lang_reflect_ArtMethod.get() != NULL);
291 java_lang_reflect_ArtMethod->SetObjectSize(sizeof(mirror::ArtMethod));
292 SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700293 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700294
Brian Carlstromea46f952013-07-30 01:26:50 -0700295 mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700296
297 // Set up array classes for string, field, method
Brian Carlstromea46f952013-07-30 01:26:50 -0700298 SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(),
299 sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700300 object_array_string->SetComponentType(java_lang_String.get());
301 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
302
Brian Carlstromea46f952013-07-30 01:26:50 -0700303 SirtRef<mirror::Class> object_array_art_method(self, AllocClass(self, java_lang_Class.get(),
304 sizeof(mirror::Class)));
305 object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.get());
306 SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.get());
Ian Rogers4445a7e2012-10-05 17:19:13 -0700307
Brian Carlstromea46f952013-07-30 01:26:50 -0700308 SirtRef<mirror::Class> object_array_art_field(self, AllocClass(self, java_lang_Class.get(),
309 sizeof(mirror::Class)));
310 object_array_art_field->SetComponentType(java_lang_reflect_ArtField.get());
311 SetClassRoot(kJavaLangReflectArtFieldArrayClass, object_array_art_field.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700312
Ian Rogers23435d02012-09-24 11:23:12 -0700313 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
314 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
315 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700316 CHECK_NE(0U, boot_class_path.size());
317 for (size_t i = 0; i != boot_class_path.size(); ++i) {
318 const DexFile* dex_file = boot_class_path[i];
319 CHECK(dex_file != NULL);
320 AppendToBootClassPath(*dex_file);
321 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700322
323 // now we can use FindSystemClass
324
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700325 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700326 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700327 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700328
Jeff Hao88474b42013-10-23 16:24:40 -0700329 // Create runtime resolution and imt conflict methods. Also setup the default imt.
330 Runtime* runtime = Runtime::Current();
331 runtime->SetResolutionMethod(runtime->CreateResolutionMethod());
332 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod());
333 runtime->SetDefaultImt(runtime->CreateDefaultImt(this));
334
Mathieu Chartier66f19252012-09-18 08:57:04 -0700335 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700336 java_lang_Object->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800337 mirror::Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700338 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800339 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700340 java_lang_String->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800341 mirror::Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700342 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800343 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700344 java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800345 mirror::Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700346 CHECK_EQ(java_lang_String.get(), String_class);
347 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800348 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700349
Ian Rogers23435d02012-09-24 11:23:12 -0700350 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700351 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800352 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700353
354 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800355 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700356
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800357 mirror::Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700358 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700359
360 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800361 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700362
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800363 mirror::Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700364 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700365
366 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800367 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700368
369 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800370 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700371
372 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800373 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700374
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800375 mirror::Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700376 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700377
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800378 mirror::Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700379 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700380
Ian Rogers23435d02012-09-24 11:23:12 -0700381 // Setup the single, global copy of "iftable".
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800382 mirror::Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700383 CHECK(java_lang_Cloneable != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800384 mirror::Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700385 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700386 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
387 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700388 array_iftable_->SetInterface(0, java_lang_Cloneable);
389 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700390
Ian Rogers23435d02012-09-24 11:23:12 -0700391 // Sanity check Class[] and Object[]'s interfaces.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700392 ClassHelper kh(class_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700393 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
394 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800395 kh.ChangeClass(object_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700396 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
397 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Brian Carlstromea46f952013-07-30 01:26:50 -0700398 // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700399 // dex_cache_ fields and register them in class_table_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800400 mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700401 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700402
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700403 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700404 mirror::Class* Art_method_class = FindSystemClass("Ljava/lang/reflect/ArtMethod;");
405 CHECK_EQ(java_lang_reflect_ArtMethod.get(), Art_method_class);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700406
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700407 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700408 mirror::Class* Art_field_class = FindSystemClass("Ljava/lang/reflect/ArtField;");
409 CHECK_EQ(java_lang_reflect_ArtField.get(), Art_field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700410
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800411 mirror::Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700412 CHECK_EQ(object_array_string.get(), String_array_class);
413
Brian Carlstromea46f952013-07-30 01:26:50 -0700414 mirror::Class* Art_method_array_class =
415 FindSystemClass(class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]);
416 CHECK_EQ(object_array_art_method.get(), Art_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700417
Brian Carlstromea46f952013-07-30 01:26:50 -0700418 mirror::Class* Art_field_array_class =
419 FindSystemClass(class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]);
420 CHECK_EQ(object_array_art_field.get(), Art_field_array_class);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700421
Ian Rogers23435d02012-09-24 11:23:12 -0700422 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700423
Ian Rogers23435d02012-09-24 11:23:12 -0700424 // Create java.lang.reflect.Proxy root.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800425 mirror::Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
Ian Rogers466bb252011-10-14 03:29:56 -0700426 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
427
Brian Carlstrom1f870082011-08-23 16:02:11 -0700428 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800429 mirror::Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700430 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800431 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700432 java_lang_ref_FinalizerReference->SetAccessFlags(
433 java_lang_ref_FinalizerReference->GetAccessFlags() |
434 kAccClassIsReference | kAccClassIsFinalizerReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800435 mirror::Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700436 java_lang_ref_PhantomReference->SetAccessFlags(
437 java_lang_ref_PhantomReference->GetAccessFlags() |
438 kAccClassIsReference | kAccClassIsPhantomReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800439 mirror::Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700440 java_lang_ref_SoftReference->SetAccessFlags(
441 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800442 mirror::Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700443 java_lang_ref_WeakReference->SetAccessFlags(
444 java_lang_ref_WeakReference->GetAccessFlags() |
445 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700446
Ian Rogers23435d02012-09-24 11:23:12 -0700447 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800448 mirror::Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
449 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700450 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
451
jeffhao8cd6dda2012-02-22 10:15:34 -0800452 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700453 // java.lang.StackTraceElement as a convenience.
Ian Rogers5167c972012-02-03 10:41:20 -0800454 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800455 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800456 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700457 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
458 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800459 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700460
Brian Carlstroma663ea52011-08-19 23:33:41 -0700461 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700462
Brian Carlstroma004aa92012-02-08 18:05:09 -0800463 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700464}
465
466void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800467 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700468
469 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700470 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700471 // as the types of the field can't be resolved prior to the runtime being
472 // fully initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800473 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700474 mirror::Class* java_lang_ref_FinalizerReference =
475 FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800476
Brian Carlstromea46f952013-07-30 01:26:50 -0700477 mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700478 FieldHelper fh(pendingNext);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800479 CHECK_STREQ(fh.GetName(), "pendingNext");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700480 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700481
Brian Carlstromea46f952013-07-30 01:26:50 -0700482 mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800483 fh.ChangeField(queue);
484 CHECK_STREQ(fh.GetName(), "queue");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700485 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700486
Brian Carlstromea46f952013-07-30 01:26:50 -0700487 mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800488 fh.ChangeField(queueNext);
489 CHECK_STREQ(fh.GetName(), "queueNext");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700490 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700491
Brian Carlstromea46f952013-07-30 01:26:50 -0700492 mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800493 fh.ChangeField(referent);
494 CHECK_STREQ(fh.GetName(), "referent");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700495 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700496
Brian Carlstromea46f952013-07-30 01:26:50 -0700497 mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800498 fh.ChangeField(zombie);
499 CHECK_STREQ(fh.GetName(), "zombie");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700500 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700501
Ian Rogers1d54e732013-05-02 21:10:01 -0700502 gc::Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800503 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700504 queue->GetOffset(),
505 queueNext->GetOffset(),
506 pendingNext->GetOffset(),
507 zombie->GetOffset());
508
Brian Carlstroma663ea52011-08-19 23:33:41 -0700509 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700510 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700511 ClassRoot class_root = static_cast<ClassRoot>(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800512 mirror::Class* klass = GetClassRoot(class_root);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700513 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700514 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700515 // note SetClassRoot does additional validation.
516 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700517 }
518
Elliott Hughes92f14b22011-10-06 12:29:54 -0700519 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700520
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700521 // disable the slow paths in FindClass and CreatePrimitiveClass now
522 // that Object, Class, and Object[] are setup
523 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700524
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800525 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700526}
527
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700528void ClassLinker::RunRootClinits() {
529 Thread* self = Thread::Current();
530 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800531 mirror::Class* c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700532 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700533 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700534 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700535 }
536 }
537}
538
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700539bool ClassLinker::GenerateOatFile(const char* dex_filename,
Brian Carlstromd601af82012-01-06 10:15:19 -0800540 int oat_fd,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700541 const char* oat_cache_filename) {
542 Locks::mutator_lock_->AssertNotHeld(Thread::Current()); // Avoid starving GC.
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800543 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700544 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800545 const char* dex2oat = dex2oat_string.c_str();
546
Brian Carlstroma004aa92012-02-08 18:05:09 -0800547 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800548
Ian Rogers1d54e732013-05-02 21:10:01 -0700549 gc::Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800550 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700551 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800552 const char* boot_image_option = boot_image_option_string.c_str();
553
554 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800555 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800556 const char* dex_file_option = dex_file_option_string.c_str();
557
Brian Carlstromd601af82012-01-06 10:15:19 -0800558 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800559 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800560 const char* oat_fd_option = oat_fd_option_string.c_str();
561
Brian Carlstroma004aa92012-02-08 18:05:09 -0800562 std::string oat_location_option_string("--oat-location=");
563 oat_location_option_string += oat_cache_filename;
564 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800565
buzbeea024a062013-07-31 10:47:37 -0700566 std::string oat_compiler_filter_string("-compiler-filter:");
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700567 Runtime::CompilerFilter filter = Runtime::Current()->GetCompilerFilter();
568 switch (filter) {
buzbeea024a062013-07-31 10:47:37 -0700569 case Runtime::kInterpretOnly:
570 oat_compiler_filter_string += "interpret-only";
571 break;
buzbeea024a062013-07-31 10:47:37 -0700572 case Runtime::kSpace:
573 oat_compiler_filter_string += "space";
574 break;
575 case Runtime::kBalanced:
576 oat_compiler_filter_string += "balanced";
577 break;
578 case Runtime::kSpeed:
579 oat_compiler_filter_string += "speed";
580 break;
buzbeefe9ca402013-08-21 09:48:11 -0700581 case Runtime::kEverything:
582 oat_compiler_filter_string += "everything";
583 break;
buzbeea024a062013-07-31 10:47:37 -0700584 default:
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700585 LOG(FATAL) << "Unexpected case: " << filter;
buzbeea024a062013-07-31 10:47:37 -0700586 }
587 const char* oat_compiler_filter_option = oat_compiler_filter_string.c_str();
588
jeffhao262bf462011-10-20 18:36:32 -0700589 // fork and exec dex2oat
590 pid_t pid = fork();
591 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800592 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800593
594 // change process groups, so we don't get reaped by ProcessManager
595 setpgid(0, 0);
596
Brian Carlstromb00309f2013-09-30 14:23:30 -0700597 // gLogVerbosity.class_linker = true;
jeffhao10037c82012-01-23 15:06:23 -0800598 VLOG(class_linker) << dex2oat
599 << " --runtime-arg -Xms64m"
600 << " --runtime-arg -Xmx64m"
601 << " --runtime-arg -classpath"
602 << " --runtime-arg " << class_path
buzbeea024a062013-07-31 10:47:37 -0700603 << " --runtime-arg " << oat_compiler_filter_option
Brian Carlstrom265091e2013-01-30 14:08:26 -0800604#if !defined(ART_TARGET)
605 << " --host"
606#endif
jeffhao10037c82012-01-23 15:06:23 -0800607 << " " << boot_image_option
608 << " " << dex_file_option
609 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800610 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800611
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800612 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700613 "--runtime-arg", "-Xms64m",
614 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500615 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800616 "--runtime-arg", class_path,
buzbeea024a062013-07-31 10:47:37 -0700617 "--runtime-arg", oat_compiler_filter_option,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800618#if !defined(ART_TARGET)
619 "--host",
620#endif
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800621 boot_image_option,
622 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800623 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800624 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700625 NULL);
626
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800627 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800628 return false;
jeffhao262bf462011-10-20 18:36:32 -0700629 } else {
630 // wait for dex2oat to finish
631 int status;
632 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
633 if (got_pid != pid) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700634 ScopedObjectAccess soa(Thread::Current());
635 ThrowIOException("Failed to create oat file. Waitpid failed: wanted %d, got %d", pid,
636 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) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700640 ScopedObjectAccess soa(Thread::Current());
641 ThrowIOException("Failed to create oat file. %s failed with dex-file '%s'", dex2oat,
642 dex_filename);
Brian Carlstromd601af82012-01-06 10:15:19 -0800643 return false;
jeffhao262bf462011-10-20 18:36:32 -0700644 }
645 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800646 return true;
jeffhao262bf462011-10-20 18:36:32 -0700647}
648
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700649const OatFile* ClassLinker::RegisterOatFile(const OatFile* oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700650 WriterMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700651 for (size_t i = 0; i < oat_files_.size(); ++i) {
652 if (UNLIKELY(oat_file->GetLocation() == oat_files_[i]->GetLocation())) {
653 VLOG(class_linker) << "Attempt to register oat file that's already registered: "
654 << oat_file->GetLocation();
655 for (size_t j = i; j < oat_files_.size(); ++j) {
656 CHECK_NE(oat_file, oat_files_[j]) << "Attempt to re-register dex file.";
657 }
658 delete oat_file;
659 return oat_files_[i];
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700660 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800661 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700662 VLOG(class_linker) << "Registering " << oat_file->GetLocation();
663 oat_files_.push_back(oat_file);
664 return oat_file;
Brian Carlstrom866c8622012-01-06 16:35:13 -0800665}
666
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700667OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
668 VLOG(startup) << "ClassLinker::GetImageOatFile entering";
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700669 OatFile* oat_file = space->ReleaseOatFile();
670 CHECK_EQ(RegisterOatFile(oat_file), oat_file);
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700671 VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700672 return *oat_file;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700673}
674
Brian Carlstromae826982011-11-09 01:33:42 -0800675const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700676 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation().c_str(),
677 dex_file.GetLocationChecksum());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800678}
679
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700680const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const char* dex_location,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700681 uint32_t dex_location_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700682 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -0800683 for (size_t i = 0; i < oat_files_.size(); i++) {
684 const OatFile* oat_file = oat_files_[i];
685 DCHECK(oat_file != NULL);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700686 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
687 &dex_location_checksum,
688 false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800689 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800690 return oat_file;
691 }
692 }
693 return NULL;
694}
695
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700696const DexFile* ClassLinker::FindDexFileInOatLocation(const char* dex_location,
Ian Rogerse3359f72013-06-11 15:14:11 -0700697 uint32_t dex_location_checksum,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700698 const char* oat_location,
699 std::string* error_msg) {
Brian Carlstromf1d34552013-07-12 20:22:23 -0700700 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700701 !Runtime::Current()->IsCompiler(),
702 error_msg));
703 if (oat_file.get() == nullptr) {
704 *error_msg = StringPrintf("Failed to find existing oat file at %s: %s", oat_location,
705 error_msg->c_str());
706 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800707 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700708 Runtime* runtime = Runtime::Current();
709 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700710 uint32_t expected_image_oat_checksum = image_header.GetOatChecksum();
711 uint32_t actual_image_oat_checksum = oat_file->GetOatHeader().GetImageFileLocationOatChecksum();
712 if (expected_image_oat_checksum != actual_image_oat_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700713 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat checksum of "
714 "0x%x, found 0x%x", oat_location, expected_image_oat_checksum,
715 actual_image_oat_checksum);
716 return nullptr;
Brian Carlstrom28db0122012-10-18 16:20:41 -0700717 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700718
719 uint32_t expected_image_oat_offset = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
720 uint32_t actual_image_oat_offset = oat_file->GetOatHeader().GetImageFileLocationOatDataBegin();
721 if (expected_image_oat_offset != actual_image_oat_offset) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700722 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat offset %ud, "
723 "found %ud", oat_location, expected_image_oat_offset,
724 actual_image_oat_offset);
725 return nullptr;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700726 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700727 // TODO: this registers the oat file now as we may use the oat_dex_file later and we want the
728 // intern behavior of RegisterOatFile. However, if we take an early return we could remove
729 // the oat file.
730 const OatFile* opened_oat_file = RegisterOatFile(oat_file.release());
731 const OatFile::OatDexFile* oat_dex_file = opened_oat_file->GetOatDexFile(dex_location,
732 &dex_location_checksum);
733 if (oat_dex_file == nullptr) {
734 *error_msg = StringPrintf("Failed to find oat file at '%s' containing '%s'", oat_location,
735 dex_location);
736 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800737 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700738 uint32_t expected_dex_checksum = dex_location_checksum;
739 uint32_t actual_dex_checksum = oat_dex_file->GetDexFileLocationChecksum();
740 if (expected_dex_checksum != actual_dex_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700741 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected dex checksum of 0x%x, "
742 "found 0x%x", oat_location, expected_dex_checksum,
743 actual_dex_checksum);
744 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800745 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700746 return oat_dex_file->OpenDexFile(error_msg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700747}
748
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700749class ScopedFlock {
750 public:
751 ScopedFlock() {}
752
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700753 bool Init(const char* filename, std::string* error_msg) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700754 while (true) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700755 file_.reset(OS::OpenFileWithFlags(filename, O_CREAT | O_RDWR));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700756 if (file_.get() == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700757 *error_msg = StringPrintf("Failed to open file '%s'", filename);
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700758 return false;
759 }
760 int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_EX));
761 if (flock_result != 0) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700762 *error_msg = StringPrintf("Failed to lock file '%s': %s", filename, strerror(errno));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700763 return false;
764 }
765 struct stat fstat_stat;
766 int fstat_result = TEMP_FAILURE_RETRY(fstat(file_->Fd(), &fstat_stat));
767 if (fstat_result != 0) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700768 *error_msg = StringPrintf("Failed to fstat file '%s': %s", filename, strerror(errno));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700769 return false;
770 }
771 struct stat stat_stat;
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700772 int stat_result = TEMP_FAILURE_RETRY(stat(filename, &stat_stat));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700773 if (stat_result != 0) {
774 PLOG(WARNING) << "Failed to stat, will retry: " << filename;
775 // ENOENT can happen if someone racing with us unlinks the file we created so just retry.
776 continue;
777 }
778 if (fstat_stat.st_dev != stat_stat.st_dev || fstat_stat.st_ino != stat_stat.st_ino) {
779 LOG(WARNING) << "File changed while locking, will retry: " << filename;
780 continue;
781 }
782 return true;
783 }
784 }
785
786 File& GetFile() {
787 return *file_;
788 }
789
790 ~ScopedFlock() {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700791 if (file_.get() != NULL) {
792 int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_UN));
793 CHECK_EQ(0, flock_result);
794 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700795 }
796
797 private:
798 UniquePtr<File> file_;
799
800 DISALLOW_COPY_AND_ASSIGN(ScopedFlock);
801};
802
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700803const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const char* dex_location,
804 uint32_t dex_location_checksum,
805 const char* oat_location,
806 std::string* error_msg) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700807 // We play a locking game here so that if two different processes
808 // race to generate (or worse, one tries to open a partial generated
809 // file) we will be okay. This is actually common with apps that use
810 // DexClassLoader to work around the dex method reference limit and
811 // that have a background service running in a separate process.
812 ScopedFlock scoped_flock;
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700813 if (!scoped_flock.Init(oat_location, error_msg)) {
814 return nullptr;
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700815 }
816
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800817 // Check if we already have an up-to-date output file
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700818 const DexFile* dex_file = FindDexFileInOatLocation(dex_location, dex_location_checksum,
819 oat_location, error_msg);
820 if (dex_file != nullptr) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800821 return dex_file;
822 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700823 VLOG(class_linker) << "Failed to find dex file '" << dex_location << "' in oat location '"
824 << oat_location << "': " << *error_msg;
825 error_msg->clear();
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800826
827 // Generate the output oat file for the dex file
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700828 VLOG(class_linker) << "Generating oat file " << oat_location << " for " << dex_location;
829 if (!GenerateOatFile(dex_location, scoped_flock.GetFile().Fd(), oat_location)) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700830 CHECK(Thread::Current()->IsExceptionPending());
831 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800832 }
Brian Carlstromf1d34552013-07-12 20:22:23 -0700833 const OatFile* oat_file = OatFile::Open(oat_location, oat_location, NULL,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700834 !Runtime::Current()->IsCompiler(),
835 error_msg);
836 if (oat_file == nullptr) {
837 *error_msg = StringPrintf("Failed to open generated oat file '%s': %s",
838 oat_location, error_msg->c_str());
839 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800840 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700841 oat_file = RegisterOatFile(oat_file);
842 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
843 &dex_location_checksum);
844 if (oat_dex_file == nullptr) {
845 *error_msg = StringPrintf("Failed to find dex file '%s' (checksum 0x%x) in generated out file "
846 "'%s'", dex_location, dex_location_checksum, oat_location);
847 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800848 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700849 const DexFile* result = oat_dex_file->OpenDexFile(error_msg);
850 CHECK(result != nullptr) << *error_msg;
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700851 CHECK_EQ(dex_location_checksum, result->GetLocationChecksum())
852 << "dex_location=" << dex_location << " oat_location=" << oat_location << std::hex
853 << " dex_location_checksum=" << dex_location_checksum
Brian Carlstromb00309f2013-09-30 14:23:30 -0700854 << " DexFile::GetLocationChecksum()=" << result->GetLocationChecksum();
855 return result;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800856}
857
Brian Carlstromafe25512012-06-27 17:02:58 -0700858bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700859 const char* dex_location,
860 uint32_t dex_location_checksum,
861 std::string* error_msg) {
Brian Carlstromafe25512012-06-27 17:02:58 -0700862 Runtime* runtime = Runtime::Current();
863 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700864 uint32_t image_oat_checksum = image_header.GetOatChecksum();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800865 uint32_t image_oat_data_begin = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
Brian Carlstrom28db0122012-10-18 16:20:41 -0700866 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800867 && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700868
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700869 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700870 if (oat_dex_file == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700871 *error_msg = StringPrintf("oat file '%s' does not contain contents for '%s' with checksum 0x%x",
872 oat_file->GetLocation().c_str(), dex_location, dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700873 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
874 for (size_t i = 0; i < oat_dex_files.size(); i++) {
875 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700876 *error_msg += StringPrintf("\noat file '%s' contains contents for '%s'",
877 oat_file->GetLocation().c_str(),
878 oat_dex_file->GetDexFileLocation().c_str());
Brian Carlstromafe25512012-06-27 17:02:58 -0700879 }
880 return false;
881 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700882 bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700883
Brian Carlstromafe25512012-06-27 17:02:58 -0700884 if (image_check && dex_check) {
885 return true;
886 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700887
Brian Carlstromafe25512012-06-27 17:02:58 -0700888 if (!image_check) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700889 ScopedObjectAccess soa(Thread::Current());
890 mirror::String* oat_location = image_header.GetImageRoot(ImageHeader::kOatLocation)->AsString();
891 std::string image_file(oat_location->ToModifiedUtf8());
892 *error_msg = StringPrintf("oat file '%s' mismatch (0x%x, %d) with '%s' (0x%x, %d)",
893 oat_file->GetLocation().c_str(),
894 oat_file->GetOatHeader().GetImageFileLocationOatChecksum(),
895 oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(),
896 image_file.c_str(), image_oat_checksum, image_oat_data_begin);
Brian Carlstromafe25512012-06-27 17:02:58 -0700897 }
898 if (!dex_check) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700899 *error_msg = StringPrintf("oat file '%s' mismatch (0x%x) with '%s' (0x%x)",
900 oat_file->GetLocation().c_str(),
901 oat_dex_file->GetDexFileLocationChecksum(),
902 dex_location, dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700903 }
904 return false;
905}
906
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700907const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const std::string& oat_file_location,
908 const char* dex_location,
909 std::string* error_msg,
910 bool* open_failed) {
911 UniquePtr<const OatFile> oat_file(FindOatFileFromOatLocation(oat_file_location, error_msg));
912 if (oat_file.get() == nullptr) {
913 *open_failed = true;
914 return nullptr;
Brian Carlstromafe25512012-06-27 17:02:58 -0700915 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700916 *open_failed = false;
917 uint32_t dex_location_checksum;
918 if (!DexFile::GetChecksum(dex_location, &dex_location_checksum, error_msg)) {
919 // If no classes.dex found in dex_location, it has been stripped or is corrupt, assume oat is
920 // up-to-date. This is the common case in user builds for jar's and apk's in the /system
921 // directory.
922 const OatFile* opened_oat_file = oat_file.release();
923 opened_oat_file = RegisterOatFile(opened_oat_file);
924 const OatFile::OatDexFile* oat_dex_file = opened_oat_file->GetOatDexFile(dex_location, NULL);
925 if (oat_dex_file == nullptr) {
926 *error_msg = StringPrintf("Dex checksum mismatch for location '%s' and failed to find oat "
927 "dex file '%s': %s", oat_file_location.c_str(), dex_location,
928 error_msg->c_str());
929 return nullptr;
930 }
931 return oat_dex_file->OpenDexFile(error_msg);
932 }
933
934 bool verified = VerifyOatFileChecksums(oat_file.get(), dex_location, dex_location_checksum,
935 error_msg);
936 if (!verified) {
937 return nullptr;
938 }
939 const OatFile* opened_oat_file = oat_file.release();
940 opened_oat_file = RegisterOatFile(opened_oat_file);
941 return opened_oat_file->GetOatDexFile(dex_location,
942 &dex_location_checksum)->OpenDexFile(error_msg);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700943}
944
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700945const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const char* dex_location,
946 uint32_t dex_location_checksum,
947 std::string* error_msg) {
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700948 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location,
949 dex_location_checksum);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700950 if (open_oat_file != nullptr) {
951 const OatFile::OatDexFile* oat_dex_file = open_oat_file->GetOatDexFile(dex_location,
952 &dex_location_checksum);
953 return oat_dex_file->OpenDexFile(error_msg);
Brian Carlstromae826982011-11-09 01:33:42 -0800954 }
955
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700956 // Look for an existing file next to dex. for example, for
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700957 // /foo/bar/baz.jar, look for /foo/bar/baz.odex.
958 std::string odex_filename(OatFile::DexFilenameToOdexFilename(dex_location));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700959 bool open_failed;
960 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(odex_filename, dex_location,
961 error_msg, &open_failed);
962 if (dex_file != nullptr) {
963 return dex_file;
Brian Carlstroma004aa92012-02-08 18:05:09 -0800964 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700965 std::string cache_error_msg;
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700966 std::string cache_location(GetDalvikCacheFilenameOrDie(dex_location));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700967 dex_file = VerifyAndOpenDexFileFromOatFile(cache_location, dex_location, &cache_error_msg,
968 &open_failed);
969 if (dex_file != nullptr) {
970 return dex_file;
jeffhao262bf462011-10-20 18:36:32 -0700971 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700972 if (!open_failed && TEMP_FAILURE_RETRY(unlink(cache_location.c_str())) != 0) {
973 PLOG(FATAL) << "Failed to remove obsolete oat file from " << cache_location;
974 }
975 VLOG(class_linker) << "Failed to open oat file from " << odex_filename
976 << " (error '" << *error_msg << "') or " << cache_location
977 << " (error '" << cache_error_msg << "').";
Brian Carlstroma004aa92012-02-08 18:05:09 -0800978
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800979 // Try to generate oat file if it wasn't found or was obsolete.
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700980 error_msg->clear();
981 return FindOrCreateOatFileForDexLocation(dex_location, dex_location_checksum,
982 cache_location.c_str(), error_msg);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700983}
984
Brian Carlstromae826982011-11-09 01:33:42 -0800985const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700986 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700987 for (size_t i = 0; i < oat_files_.size(); i++) {
988 const OatFile* oat_file = oat_files_[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700989 DCHECK(oat_file != nullptr);
Brian Carlstromae826982011-11-09 01:33:42 -0800990 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700991 return oat_file;
992 }
993 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700994 return nullptr;
Brian Carlstromfad71432011-10-16 20:25:10 -0700995}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700996
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700997const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location,
998 std::string* error_msg) {
jeffhaof6174e82012-01-31 16:14:17 -0800999 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001000 if (oat_file != nullptr) {
jeffhaof6174e82012-01-31 16:14:17 -08001001 return oat_file;
1002 }
1003
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001004 oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler(),
1005 error_msg);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001006 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -08001007 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001008 }
1009 return oat_file;
1010}
1011
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001012static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
Ian Rogers848871b2013-08-05 10:56:33 -07001013 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001014 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
1015
Ian Rogers848871b2013-08-05 10:56:33 -07001016 DCHECK(obj != NULL);
1017 DCHECK(class_linker != NULL);
1018
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001019 if (obj->IsArtMethod()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001020 mirror::ArtMethod* method = obj->AsArtMethod();
Ian Rogers848871b2013-08-05 10:56:33 -07001021 if (!method->IsNative()) {
1022 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
1023 if (method != Runtime::Current()->GetResolutionMethod()) {
1024 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
1025 }
1026 }
1027 }
1028}
1029
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001030void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001031 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001032 CHECK(!init_done_);
1033
Mathieu Chartier590fee92013-09-13 13:46:47 -07001034 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -07001035 gc::Heap* heap = Runtime::Current()->GetHeap();
1036 gc::space::ImageSpace* space = heap->GetImageSpace();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001037 dex_cache_image_class_lookup_required_ = true;
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001038 CHECK(space != NULL);
1039 OatFile& oat_file = GetImageOatFile(space);
1040 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
1041 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
1042 CHECK(oat_file.GetOatHeader().GetImageFileLocation().empty());
1043 portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
1044 quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
Jeff Hao88474b42013-10-23 16:24:40 -07001045 portable_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetPortableImtConflictTrampoline();
1046 quick_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetQuickImtConflictTrampoline();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001047 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
1048 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1049 dex_caches_object->AsObjectArray<mirror::DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001050
Mathieu Chartier590fee92013-09-13 13:46:47 -07001051 SirtRef<mirror::ObjectArray<mirror::Class> > class_roots(
1052 self,
1053 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>());
1054 class_roots_ = class_roots.get();
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001055
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001056 // Special case of setting up the String class early so that we can test arbitrary objects
1057 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001058 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001059
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001060 CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001061 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001062 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001063 SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001064 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001065 const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location.c_str(),
1066 nullptr);
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001067 CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001068 std::string error_msg;
1069 const DexFile* dex_file = oat_dex_file->OpenDexFile(&error_msg);
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001070 if (dex_file == NULL) {
1071 LOG(FATAL) << "Failed to open dex file " << dex_file_location
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001072 << " from within oat file " << oat_file.GetLocation()
1073 << " error '" << error_msg << "'";
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001074 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001075
1076 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
1077
1078 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001079 }
1080
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001081 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
1082 // bitmap walk.
Brian Carlstromea46f952013-07-30 01:26:50 -07001083 mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001084
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001085 // Set entry point to interpreter if in InterpretOnly mode.
1086 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001087 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001088 heap->VisitObjects(InitFromImageInterpretOnlyCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001089 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001090
1091 // reinit class_roots_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001092 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
Mathieu Chartier590fee92013-09-13 13:46:47 -07001093 class_roots_ = class_roots.get();
Brian Carlstroma663ea52011-08-19 23:33:41 -07001094
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001095 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001096 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1097 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001098 // String class root was set above
Brian Carlstromea46f952013-07-30 01:26:50 -07001099 mirror::ArtField::SetClass(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001100 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1101 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1102 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1103 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1104 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1105 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1106 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1107 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1108 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1109 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001110
1111 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001112
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001113 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001114}
1115
Brian Carlstroma663ea52011-08-19 23:33:41 -07001116// Keep in sync with InitCallback. Anything we visit, we need to
1117// reinit references to when reinitializing a ClassLinker from a
1118// mapped image.
Mathieu Chartierc4621982013-09-16 19:43:47 -07001119void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool clean_dirty) {
Mathieu Chartierb3070522013-09-17 14:18:21 -07001120 class_roots_ = down_cast<mirror::ObjectArray<mirror::Class>*>(visitor(class_roots_, arg));
Ian Rogers50b35e22012-10-04 10:09:15 -07001121 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001122 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001123 ReaderMutexLock mu(self, dex_lock_);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001124 if (!only_dirty || dex_caches_dirty_) {
Mathieu Chartierb3070522013-09-17 14:18:21 -07001125 for (mirror::DexCache*& dex_cache : dex_caches_) {
1126 dex_cache = down_cast<mirror::DexCache*>(visitor(dex_cache, arg));
1127 DCHECK(dex_cache != nullptr);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001128 }
1129 if (clean_dirty) {
1130 dex_caches_dirty_ = false;
1131 }
Elliott Hughesf8349362012-06-18 15:00:06 -07001132 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001133 }
1134
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001135 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001136 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001137 if (!only_dirty || class_table_dirty_) {
Mathieu Chartierb3070522013-09-17 14:18:21 -07001138 for (std::pair<const size_t, mirror::Class*>& it : class_table_) {
1139 it.second = down_cast<mirror::Class*>(visitor(it.second, arg));
1140 DCHECK(it.second != nullptr);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001141 }
1142 if (clean_dirty) {
1143 class_table_dirty_ = false;
1144 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001145 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001146
1147 // We deliberately ignore the class roots in the image since we
1148 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001149 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001150
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001151 array_iftable_ = reinterpret_cast<mirror::IfTable*>(visitor(array_iftable_, arg));
1152 DCHECK(array_iftable_ != nullptr);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001153}
1154
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001155void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) {
1156 if (dex_cache_image_class_lookup_required_) {
1157 MoveImageClassesToClassTable();
Elliott Hughesa2155262011-11-16 16:26:58 -08001158 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001159 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
1160 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001161 if (!visitor(it.second, arg)) {
Elliott Hughesa2155262011-11-16 16:26:58 -08001162 return;
1163 }
1164 }
1165}
1166
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001167static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1168 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001169 classes->insert(c);
1170 return true;
1171}
1172
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001173void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001174 std::set<mirror::Class*> classes;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001175 VisitClasses(GetClassesVisitor, &classes);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001176 for (mirror::Class* klass : classes) {
1177 if (!visitor(klass, arg)) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001178 return;
1179 }
1180 }
1181}
1182
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001183ClassLinker::~ClassLinker() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001184 mirror::Class::ResetClass();
1185 mirror::String::ResetClass();
Brian Carlstromea46f952013-07-30 01:26:50 -07001186 mirror::ArtField::ResetClass();
1187 mirror::ArtMethod::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001188 mirror::BooleanArray::ResetArrayClass();
1189 mirror::ByteArray::ResetArrayClass();
1190 mirror::CharArray::ResetArrayClass();
1191 mirror::DoubleArray::ResetArrayClass();
1192 mirror::FloatArray::ResetArrayClass();
1193 mirror::IntArray::ResetArrayClass();
1194 mirror::LongArray::ResetArrayClass();
1195 mirror::ShortArray::ResetArrayClass();
1196 mirror::Throwable::ResetClass();
1197 mirror::StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001198 STLDeleteElements(&boot_class_path_);
1199 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001200}
1201
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001202mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001203 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001204 SirtRef<mirror::Class> dex_cache_class(self, GetClassRoot(kJavaLangDexCache));
1205 SirtRef<mirror::DexCache> dex_cache(
1206 self, down_cast<mirror::DexCache*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001207 heap->AllocObject<true>(self, dex_cache_class.get(), dex_cache_class->GetObjectSize())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001208 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001209 return NULL;
1210 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001211 SirtRef<mirror::String>
1212 location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001213 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001214 return NULL;
1215 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001216 SirtRef<mirror::ObjectArray<mirror::String> >
1217 strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001218 if (strings.get() == NULL) {
1219 return NULL;
1220 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001221 SirtRef<mirror::ObjectArray<mirror::Class> >
1222 types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001223 if (types.get() == NULL) {
1224 return NULL;
1225 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001226 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
1227 methods(self, AllocArtMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001228 if (methods.get() == NULL) {
1229 return NULL;
1230 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001231 SirtRef<mirror::ObjectArray<mirror::ArtField> >
1232 fields(self, AllocArtFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001233 if (fields.get() == NULL) {
1234 return NULL;
1235 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001236 SirtRef<mirror::ObjectArray<mirror::StaticStorageBase> >
Ian Rogers50b35e22012-10-04 10:09:15 -07001237 initialized_static_storage(self,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001238 AllocObjectArray<mirror::StaticStorageBase>(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001239 if (initialized_static_storage.get() == NULL) {
1240 return NULL;
1241 }
1242
Mathieu Chartier590fee92013-09-13 13:46:47 -07001243 dex_cache->Init(&dex_file, location.get(), strings.get(), types.get(), methods.get(),
1244 fields.get(), initialized_static_storage.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001245 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001246}
1247
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001248mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
1249 size_t class_size) {
1250 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07001251 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001252 mirror::Object* k = heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size);
Ian Rogersa436fde2013-08-27 23:34:06 -07001253 if (UNLIKELY(k == NULL)) {
1254 CHECK(self->IsExceptionPending()); // OOME.
1255 return NULL;
1256 }
1257 mirror::Class* klass = k->AsClass();
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001258 klass->SetPrimitiveType(Primitive::kPrimNot); // Default to not being primitive.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001259 klass->SetClassSize(class_size);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001260 klass->SetDexClassDefIndex(DexFile::kDexNoIndex16); // Default to no valid class def index.
1261 klass->SetDexTypeIndex(DexFile::kDexNoIndex16); // Default to no valid type index.
Ian Rogersa436fde2013-08-27 23:34:06 -07001262 return klass;
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001263}
1264
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001265mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001266 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001267}
1268
Brian Carlstromea46f952013-07-30 01:26:50 -07001269mirror::ArtField* ClassLinker::AllocArtField(Thread* self) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001270 return down_cast<mirror::ArtField*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001271 GetClassRoot(kJavaLangReflectArtField)->AllocNonMovableObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001272}
1273
Brian Carlstromea46f952013-07-30 01:26:50 -07001274mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001275 return down_cast<mirror::ArtMethod*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001276 GetClassRoot(kJavaLangReflectArtMethod)->AllocNonMovableObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001277}
1278
Mathieu Chartier590fee92013-09-13 13:46:47 -07001279mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
1280 Thread* self, size_t length) {
1281 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
1282 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001283}
1284
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001285static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001286 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001287 DCHECK(klass != NULL);
1288 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001289 if (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers1f539342012-10-03 21:09:42 -07001290 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001291 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001292 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001293 ThrowClassCircularityError(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001294 klass->SetStatus(mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001295 return NULL;
1296 }
1297 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001298 while (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers05f30572013-02-20 12:13:11 -08001299 lock.WaitIgnoringInterrupts();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001300 }
1301 }
1302 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001303 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001304 return NULL;
1305 }
1306 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001307 CHECK(klass->IsResolved()) << PrettyClass(klass);
Ian Rogers62d6c772013-02-27 08:32:07 -08001308 self->AssertNoPendingException();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001309 return klass;
1310}
1311
Ian Rogersbe7149f2013-08-20 09:29:39 -07001312bool ClassLinker::IsInBootClassPath(const char* descriptor) {
1313 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1314 return pair.second != NULL;
1315}
1316
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001317mirror::Class* ClassLinker::FindSystemClass(const char* descriptor) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001318 SirtRef<mirror::ClassLoader> class_loader(Thread::Current(), nullptr);
1319 return FindClass(descriptor, class_loader);
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001320}
1321
Mathieu Chartier590fee92013-09-13 13:46:47 -07001322mirror::Class* ClassLinker::FindClass(const char* descriptor,
1323 SirtRef<mirror::ClassLoader>& class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001324 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001325 Thread* self = Thread::Current();
1326 DCHECK(self != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001327 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001328 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001329 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1330 // for primitive classes that aren't backed by dex files.
1331 return FindPrimitiveClass(descriptor[0]);
1332 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001333 // Find the class in the loaded classes table.
Mathieu Chartier590fee92013-09-13 13:46:47 -07001334 mirror::Class* klass = LookupClass(descriptor, class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001335 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001336 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001337 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001338 // Class is not yet loaded.
1339 if (descriptor[0] == '[') {
1340 return CreateArrayClass(descriptor, class_loader);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001341 } else if (class_loader.get() == nullptr) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001342 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1343 if (pair.second != NULL) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001344 SirtRef<mirror::ClassLoader> class_loader(self, nullptr);
1345 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Jesse Wilson47daf872011-11-23 11:42:45 -05001346 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001347 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001348 // First try the boot class path, we check the descriptor first to avoid an unnecessary
1349 // throw of a NoClassDefFoundError.
1350 if (IsInBootClassPath(descriptor)) {
1351 mirror::Class* system_class = FindSystemClass(descriptor);
1352 CHECK(system_class != NULL);
Jesse Wilson47daf872011-11-23 11:42:45 -05001353 return system_class;
1354 }
Ian Rogersbe7149f2013-08-20 09:29:39 -07001355 // Next try the compile time class path.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001356 const std::vector<const DexFile*>* class_path;
1357 {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001358 ScopedObjectAccessUnchecked soa(self);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001359 ScopedLocalRef<jobject> jclass_loader(soa.Env(),
1360 soa.AddLocalReference<jobject>(class_loader.get()));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001361 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1362 }
1363
1364 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001365 if (pair.second != NULL) {
1366 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001367 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001368
1369 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001370 ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1371 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
Mathieu Chartier590fee92013-09-13 13:46:47 -07001372 soa.AddLocalReference<jobject>(class_loader.get()));
Elliott Hughes95572412011-12-13 18:14:20 -08001373 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001374 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001375 {
1376 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001377 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1378 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001379 if (class_name_object.get() == NULL) {
1380 return NULL;
1381 }
1382 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001383 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1384 WellKnownClasses::java_lang_ClassLoader_loadClass,
1385 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001386 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001387 if (soa.Self()->IsExceptionPending()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001388 // If the ClassLoader threw, pass that exception up.
1389 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001390 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001391 // broken loader - throw NPE to be compatible with Dalvik
Ian Rogers62d6c772013-02-27 08:32:07 -08001392 ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1393 class_name_string.c_str()).c_str());
Ian Rogerscab01012012-01-10 17:35:46 -08001394 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001395 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001396 // success, return mirror::Class*
1397 return soa.Decode<mirror::Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001398 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001399 }
1400
Elliott Hughes82914b62012-04-09 15:56:29 -07001401 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001402 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001403}
1404
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001405mirror::Class* ClassLinker::DefineClass(const char* descriptor,
Mathieu Chartier590fee92013-09-13 13:46:47 -07001406 SirtRef<mirror::ClassLoader>& class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001407 const DexFile& dex_file,
1408 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001409 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001410 SirtRef<mirror::Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001411 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001412 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001413 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001414 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001415 klass.reset(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001416 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001417 klass.reset(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001418 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001419 klass.reset(GetClassRoot(kJavaLangString));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001420 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001421 klass.reset(GetClassRoot(kJavaLangDexCache));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001422 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001423 klass.reset(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001424 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001425 klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001426 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001427 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001428 }
1429 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001430 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001431 }
Ian Rogersa436fde2013-08-27 23:34:06 -07001432 if (UNLIKELY(klass.get() == NULL)) {
1433 CHECK(self->IsExceptionPending()); // Expect an OOME.
1434 return NULL;
1435 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001436 klass->SetDexCache(FindDexCache(dex_file));
Mathieu Chartier590fee92013-09-13 13:46:47 -07001437 LoadClass(dex_file, dex_class_def, klass, class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001438 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001439 if (self->IsExceptionPending()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001440 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001441 return NULL;
1442 }
Ian Rogers1f539342012-10-03 21:09:42 -07001443 ObjectLock lock(self, klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001444 klass->SetClinitThreadId(self->GetTid());
Mathieu Chartier590fee92013-09-13 13:46:47 -07001445 // Add the newly loaded class to the loaded classes table.
1446 mirror::Class* existing = InsertClass(descriptor, klass.get(), Hash(descriptor));
1447 if (existing != NULL) {
1448 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
1449 // this thread to block.
1450 return EnsureResolved(self, existing);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001451 }
1452 // Finish loading (if necessary) by finding parents
1453 CHECK(!klass->IsLoaded());
1454 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1455 // Loading failed.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001456 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001457 return NULL;
1458 }
1459 CHECK(klass->IsLoaded());
1460 // Link the class (if necessary)
1461 CHECK(!klass->IsResolved());
Mathieu Chartier590fee92013-09-13 13:46:47 -07001462 // TODO: Use fast jobjects?
1463 SirtRef<mirror::ObjectArray<mirror::Class> > interfaces(self, nullptr);
1464 if (!LinkClass(self, klass, interfaces)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001465 // Linking failed.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001466 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001467 return NULL;
1468 }
1469 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001470
1471 /*
1472 * We send CLASS_PREPARE events to the debugger from here. The
1473 * definition of "preparation" is creating the static fields for a
1474 * class and initializing them to the standard default values, but not
1475 * executing any code (that comes later, during "initialization").
1476 *
1477 * We did the static preparation in LinkClass.
1478 *
1479 * The class has been prepared and resolved but possibly not yet verified
1480 * at this point.
1481 */
1482 Dbg::PostClassPrepare(klass.get());
1483
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001484 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001485}
1486
Brian Carlstrom4873d462011-08-21 15:23:39 -07001487// Precomputes size that will be needed for Class, matching LinkStaticFields
1488size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1489 const DexFile::ClassDef& dex_class_def) {
1490 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001491 size_t num_ref = 0;
1492 size_t num_32 = 0;
1493 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001494 if (class_data != NULL) {
1495 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1496 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001497 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001498 char c = descriptor[0];
1499 if (c == 'L' || c == '[') {
1500 num_ref++;
1501 } else if (c == 'J' || c == 'D') {
1502 num_64++;
1503 } else {
1504 num_32++;
1505 }
1506 }
1507 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001508 // start with generic class data
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001509 size_t size = sizeof(mirror::Class);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001510 // follow with reference fields which must be contiguous at start
1511 size += (num_ref * sizeof(uint32_t));
1512 // if there are 64-bit fields to add, make sure they are aligned
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001513 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
Brian Carlstrom4873d462011-08-21 15:23:39 -07001514 if (num_32 != 0) {
1515 // use an available 32-bit field for padding
1516 num_32--;
1517 }
1518 size += sizeof(uint32_t); // either way, we are adding a word
1519 DCHECK_EQ(size, RoundUp(size, 8));
1520 }
1521 // tack on any 64-bit fields now that alignment is assured
1522 size += (num_64 * sizeof(uint64_t));
1523 // tack on any remaining 32-bit fields
1524 size += (num_32 * sizeof(uint32_t));
1525 return size;
1526}
1527
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001528const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) {
1529 DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
Ian Rogers19846512012-02-24 11:42:47 -08001530 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001531 CHECK(oat_file != NULL) << dex_file.GetLocation();
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001532 uint dex_location_checksum = dex_file.GetLocationChecksum();
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001533 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001534 &dex_location_checksum);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001535 CHECK(oat_dex_file != NULL) << dex_file.GetLocation();
1536 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_idx);
1537 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << class_def_idx;
Ian Rogers19846512012-02-24 11:42:47 -08001538 return oat_class;
1539}
1540
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001541static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint16_t class_def_idx,
1542 uint32_t method_idx) {
1543 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
1544 const byte* class_data = dex_file.GetClassData(class_def);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001545 CHECK(class_data != NULL);
1546 ClassDataItemIterator it(dex_file, class_data);
1547 // Skip fields
1548 while (it.HasNextStaticField()) {
1549 it.Next();
1550 }
1551 while (it.HasNextInstanceField()) {
1552 it.Next();
1553 }
1554 // Process methods
1555 size_t class_def_method_index = 0;
1556 while (it.HasNextDirectMethod()) {
1557 if (it.GetMemberIndex() == method_idx) {
1558 return class_def_method_index;
1559 }
1560 class_def_method_index++;
1561 it.Next();
1562 }
1563 while (it.HasNextVirtualMethod()) {
1564 if (it.GetMemberIndex() == method_idx) {
1565 return class_def_method_index;
1566 }
1567 class_def_method_index++;
1568 it.Next();
1569 }
1570 DCHECK(!it.HasNext());
1571 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1572 return 0;
1573}
1574
Brian Carlstromea46f952013-07-30 01:26:50 -07001575const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::ArtMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001576 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001577 // method for direct methods (or virtual methods made direct).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001578 mirror::Class* declaring_class = method->GetDeclaringClass();
Ian Rogersfb6adba2012-03-04 21:51:51 -08001579 size_t oat_method_index;
1580 if (method->IsStatic() || method->IsDirect()) {
1581 // Simple case where the oat method index was stashed at load time.
1582 oat_method_index = method->GetMethodIndex();
1583 } else {
1584 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1585 // by search for its position in the declared virtual methods.
1586 oat_method_index = declaring_class->NumDirectMethods();
1587 size_t end = declaring_class->NumVirtualMethods();
1588 bool found = false;
1589 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001590 if (declaring_class->GetVirtualMethod(i) == method) {
1591 found = true;
1592 break;
1593 }
Ian Rogersf320b632012-03-13 18:47:47 -07001594 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001595 }
1596 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1597 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001598 UniquePtr<const OatFile::OatClass>
1599 oat_class(GetOatClass(*declaring_class->GetDexCache()->GetDexFile(),
1600 declaring_class->GetDexClassDefIndex()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001601 CHECK(oat_class.get() != NULL);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001602 DCHECK_EQ(oat_method_index,
1603 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001604 method->GetDeclaringClass()->GetDexClassDefIndex(),
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001605 method->GetDexMethodIndex()));
1606
TDYa12785321912012-04-01 15:24:56 -07001607 return oat_class->GetOatMethod(oat_method_index);
1608}
1609
1610// Special case to get oat code without overwriting a trampoline.
Brian Carlstromea46f952013-07-30 01:26:50 -07001611const void* ClassLinker::GetOatCodeFor(const mirror::ArtMethod* method) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001612 CHECK(!method->IsAbstract()) << PrettyMethod(method);
Jeff Hao8df6cea2013-07-29 13:54:48 -07001613 if (method->IsProxyMethod()) {
1614#if !defined(ART_USE_PORTABLE_COMPILER)
1615 return reinterpret_cast<void*>(art_quick_proxy_invoke_handler);
1616#else
1617 return reinterpret_cast<void*>(art_portable_proxy_invoke_handler);
1618#endif
1619 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001620 const void* result = GetOatMethodFor(method).GetCode();
1621 if (result == NULL) {
1622 // No code? You must mean to go into the interpreter.
Ian Rogers848871b2013-08-05 10:56:33 -07001623 result = GetCompiledCodeToInterpreterBridge();
Ian Rogersf3e98552013-03-20 15:49:49 -07001624 }
1625 return result;
TDYa12785321912012-04-01 15:24:56 -07001626}
1627
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001628const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
1629 uint32_t method_idx) {
1630 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, class_def_idx));
1631 CHECK(oat_class.get() != nullptr);
1632 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001633 return oat_class->GetOatMethod(oat_method_idx).GetCode();
1634}
1635
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001636// Returns true if the method must run with interpreter, false otherwise.
Brian Carlstromea46f952013-07-30 01:26:50 -07001637static bool NeedsInterpreter(const mirror::ArtMethod* method, const void* code) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001638 if (code == NULL) {
1639 // No code: need interpreter.
1640 return true;
1641 }
Dragos Sbirlea90af14d2013-08-15 17:50:16 -07001642#ifdef ART_SEA_IR_MODE
1643 ScopedObjectAccess soa(Thread::Current());
1644 if (std::string::npos != PrettyMethod(method).find("fibonacci")) {
1645 LOG(INFO) << "Found " << PrettyMethod(method);
1646 return false;
1647 }
1648#endif
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001649 // If interpreter mode is enabled, every method (except native and proxy) must
1650 // be run with interpreter.
1651 return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
1652 !method->IsNative() && !method->IsProxyMethod();
1653}
1654
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001655void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
Ian Rogers1c829822013-09-30 18:18:50 -07001656 if (klass->NumDirectMethods() == 0) {
1657 return; // No direct methods => no static methods.
Ian Rogers19846512012-02-24 11:42:47 -08001658 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001659 Runtime* runtime = Runtime::Current();
1660 if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
Ian Rogers1c829822013-09-30 18:18:50 -07001661 return; // OAT file unavailable.
Ian Rogers19846512012-02-24 11:42:47 -08001662 }
Ian Rogers1c829822013-09-30 18:18:50 -07001663 ClassHelper kh(klass);
1664 const DexFile& dex_file = kh.GetDexFile();
1665 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1666 CHECK(dex_class_def != nullptr);
1667 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1668 // There should always be class data if there were direct methods.
1669 CHECK(class_data != nullptr) << PrettyDescriptor(klass);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001670 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
Ian Rogers1c829822013-09-30 18:18:50 -07001671 CHECK(oat_class.get() != nullptr);
Ian Rogers19846512012-02-24 11:42:47 -08001672 ClassDataItemIterator it(dex_file, class_data);
1673 // Skip fields
1674 while (it.HasNextStaticField()) {
1675 it.Next();
1676 }
1677 while (it.HasNextInstanceField()) {
1678 it.Next();
1679 }
Ian Rogers1c829822013-09-30 18:18:50 -07001680 // Link the code of methods skipped by LinkCode.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001681 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001682 mirror::ArtMethod* method = klass->GetDirectMethod(method_index);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001683 if (!method->IsStatic()) {
1684 // Only update static methods.
1685 continue;
Ian Rogers19846512012-02-24 11:42:47 -08001686 }
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001687 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1688 const bool enter_interpreter = NeedsInterpreter(method, code);
1689 if (enter_interpreter) {
1690 // Use interpreter entry point.
Ian Rogers848871b2013-08-05 10:56:33 -07001691 code = GetCompiledCodeToInterpreterBridge();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001692 }
1693 runtime->GetInstrumentation()->UpdateMethodsCode(method, code);
Ian Rogers19846512012-02-24 11:42:47 -08001694 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001695 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08001696}
1697
Brian Carlstromea46f952013-07-30 01:26:50 -07001698static void LinkCode(SirtRef<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001699 uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001700 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001701 // Method shouldn't have already been linked.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001702 DCHECK(method->GetEntryPointFromCompiledCode() == NULL);
Brian Carlstrom92827a52011-10-10 15:50:01 -07001703 // Every kind of method should at least get an invoke stub from the oat_method.
1704 // non-abstract methods also get their code pointers.
1705 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstrom265091e2013-01-30 14:08:26 -08001706 oat_method.LinkMethod(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001707
Jeff Hao16743632013-05-08 10:59:04 -07001708 // Install entry point from interpreter.
Jeff Hao790ad902013-05-22 15:02:08 -07001709 Runtime* runtime = Runtime::Current();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001710 bool enter_interpreter = NeedsInterpreter(method.get(), method->GetEntryPointFromCompiledCode());
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001711 if (enter_interpreter) {
Ian Rogers848871b2013-08-05 10:56:33 -07001712 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001713 } else {
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07001714 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001715 }
1716
Brian Carlstrom92827a52011-10-10 15:50:01 -07001717 if (method->IsAbstract()) {
Ian Rogers848871b2013-08-05 10:56:33 -07001718 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001719 return;
1720 }
Ian Rogers19846512012-02-24 11:42:47 -08001721
1722 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001723 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001724 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
1725 // after initializing class (see ClassLinker::InitializeClass method).
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001726 method->SetEntryPointFromCompiledCode(GetResolutionTrampoline(runtime->GetClassLinker()));
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001727 } else if (enter_interpreter) {
1728 // Set entry point from compiled code if there's no code or in interpreter only mode.
Ian Rogers848871b2013-08-05 10:56:33 -07001729 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08001730 }
jeffhao26c0a1a2012-01-17 16:28:33 -08001731
Ian Rogers62d6c772013-02-27 08:32:07 -08001732 if (method->IsNative()) {
1733 // Unregistering restores the dlsym lookup stub.
1734 method->UnregisterNative(Thread::Current());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001735 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001736
Ian Rogers62d6c772013-02-27 08:32:07 -08001737 // Allow instrumentation its chance to hijack code.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001738 runtime->GetInstrumentation()->UpdateMethodsCode(method.get(),
1739 method->GetEntryPointFromCompiledCode());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001740}
1741
Brian Carlstromf615a612011-07-23 12:50:34 -07001742void ClassLinker::LoadClass(const DexFile& dex_file,
1743 const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001744 SirtRef<mirror::Class>& klass,
1745 mirror::ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001746 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001747 CHECK(klass->GetDexCache() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001748 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001749 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001750 CHECK(descriptor != NULL);
1751
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001752 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001753 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001754 // Make sure that none of our runtime-only flags are set.
Brian Carlstrom8e3fb142013-10-09 21:00:27 -07001755 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001756 klass->SetAccessFlags(access_flags);
1757 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001758 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001759 klass->SetStatus(mirror::Class::kStatusIdx, NULL);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001760
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001761 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001762 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001763
Ian Rogers0571d352011-11-03 19:51:38 -07001764 // Load fields fields.
1765 const byte* class_data = dex_file.GetClassData(dex_class_def);
1766 if (class_data == NULL) {
1767 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001768 }
Ian Rogers0571d352011-11-03 19:51:38 -07001769 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001770 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001771 if (it.NumStaticFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001772 mirror::ObjectArray<mirror::ArtField>* statics = AllocArtFieldArray(self, it.NumStaticFields());
1773 if (UNLIKELY(statics == NULL)) {
1774 CHECK(self->IsExceptionPending()); // OOME.
1775 return;
1776 }
1777 klass->SetSFields(statics);
Ian Rogers0571d352011-11-03 19:51:38 -07001778 }
1779 if (it.NumInstanceFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001780 mirror::ObjectArray<mirror::ArtField>* fields =
1781 AllocArtFieldArray(self, it.NumInstanceFields());
1782 if (UNLIKELY(fields == NULL)) {
1783 CHECK(self->IsExceptionPending()); // OOME.
1784 return;
1785 }
1786 klass->SetIFields(fields);
Ian Rogers0571d352011-11-03 19:51:38 -07001787 }
1788 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001789 SirtRef<mirror::ArtField> sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07001790 if (UNLIKELY(sfield.get() == NULL)) {
1791 CHECK(self->IsExceptionPending()); // OOME.
1792 return;
1793 }
Ian Rogers0571d352011-11-03 19:51:38 -07001794 klass->SetStaticField(i, sfield.get());
1795 LoadField(dex_file, it, klass, sfield);
1796 }
1797 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001798 SirtRef<mirror::ArtField> ifield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07001799 if (UNLIKELY(ifield.get() == NULL)) {
1800 CHECK(self->IsExceptionPending()); // OOME.
1801 return;
1802 }
Ian Rogers0571d352011-11-03 19:51:38 -07001803 klass->SetInstanceField(i, ifield.get());
1804 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001805 }
1806
Brian Carlstromf5822582012-03-19 22:34:31 -07001807 UniquePtr<const OatFile::OatClass> oat_class;
1808 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001809 oat_class.reset(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001810 }
Ian Rogers19846512012-02-24 11:42:47 -08001811
Ian Rogers0571d352011-11-03 19:51:38 -07001812 // Load methods.
1813 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001814 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07001815 mirror::ObjectArray<mirror::ArtMethod>* directs =
1816 AllocArtMethodArray(self, it.NumDirectMethods());
1817 if (UNLIKELY(directs == NULL)) {
1818 CHECK(self->IsExceptionPending()); // OOME.
1819 return;
1820 }
1821 klass->SetDirectMethods(directs);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001822 }
Ian Rogers0571d352011-11-03 19:51:38 -07001823 if (it.NumVirtualMethods() != 0) {
1824 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07001825 mirror::ObjectArray<mirror::ArtMethod>* virtuals =
1826 AllocArtMethodArray(self, it.NumVirtualMethods());
1827 if (UNLIKELY(virtuals == NULL)) {
1828 CHECK(self->IsExceptionPending()); // OOME.
1829 return;
1830 }
1831 klass->SetVirtualMethods(virtuals);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001832 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001833 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001834 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001835 SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogersa436fde2013-08-27 23:34:06 -07001836 if (UNLIKELY(method.get() == NULL)) {
1837 CHECK(self->IsExceptionPending()); // OOME.
1838 return;
1839 }
Ian Rogers0571d352011-11-03 19:51:38 -07001840 klass->SetDirectMethod(i, method.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001841 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001842 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001843 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001844 method->SetMethodIndex(class_def_method_index);
1845 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001846 }
1847 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001848 SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogersa436fde2013-08-27 23:34:06 -07001849 if (UNLIKELY(method.get() == NULL)) {
1850 CHECK(self->IsExceptionPending()); // OOME.
1851 return;
1852 }
Ian Rogers0571d352011-11-03 19:51:38 -07001853 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001854 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001855 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001856 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001857 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001858 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001859 }
1860 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001861}
1862
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001863void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Brian Carlstromea46f952013-07-30 01:26:50 -07001864 SirtRef<mirror::Class>& klass, SirtRef<mirror::ArtField>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001865 uint32_t field_idx = it.GetMemberIndex();
1866 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001867 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001868 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001869}
1870
Brian Carlstromea46f952013-07-30 01:26:50 -07001871mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
Ian Rogersa436fde2013-08-27 23:34:06 -07001872 const ClassDataItemIterator& it,
1873 SirtRef<mirror::Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001874 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001875 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07001876 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001877
Brian Carlstromea46f952013-07-30 01:26:50 -07001878 mirror::ArtMethod* dst = AllocArtMethod(self);
Ian Rogersa436fde2013-08-27 23:34:06 -07001879 if (UNLIKELY(dst == NULL)) {
1880 CHECK(self->IsExceptionPending()); // OOME.
1881 return NULL;
1882 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001883 DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001884
Ian Rogers50b35e22012-10-04 10:09:15 -07001885 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07001886 dst->SetDexMethodIndex(dex_method_idx);
1887 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001888 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001889
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001890 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001891 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001892 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001893 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001894
Ian Rogers241b5de2013-10-09 17:58:57 -07001895 uint32_t access_flags = it.GetMemberAccessFlags();
1896
Ian Rogersdfb325e2013-10-30 01:00:44 -07001897 if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07001898 // Set finalizable flag on declaring class.
Ian Rogersdfb325e2013-10-30 01:00:44 -07001899 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
1900 // Void return type.
1901 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1902 klass->SetFinalizable();
1903 } else {
1904 ClassHelper kh(klass.get());
1905 const char* klass_descriptor = kh.GetDescriptor();
1906 // The Enum class declares a "final" finalize() method to prevent subclasses from
1907 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1908 // subclasses, so we exclude it here.
1909 // We also want to avoid setting the flag on Object, where we know that finalize() is
1910 // empty.
1911 if ((strcmp("Ljava/lang/Object;", klass_descriptor) != 0) &&
1912 (strcmp("Ljava/lang/Enum;", klass_descriptor) != 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07001913 klass->SetFinalizable();
Ian Rogers241b5de2013-10-09 17:58:57 -07001914 }
1915 }
1916 }
1917 } else if (method_name[0] == '<') {
1918 // Fix broken access flags for initializers. Bug 11157540.
Ian Rogersdfb325e2013-10-30 01:00:44 -07001919 bool is_init = (strcmp("<init>", method_name) == 0);
1920 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
Ian Rogers241b5de2013-10-09 17:58:57 -07001921 if (UNLIKELY(!is_init && !is_clinit)) {
1922 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
1923 } else {
1924 if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
1925 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
1926 << PrettyDescriptor(klass.get()) << " in dex file " << dex_file.GetLocation();
1927 access_flags |= kAccConstructor;
1928 }
1929 }
1930 }
1931 dst->SetAccessFlags(access_flags);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001932
Ian Rogers50b35e22012-10-04 10:09:15 -07001933 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001934 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07001935}
1936
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001937void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001938 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001939 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Ian Rogersa436fde2013-08-27 23:34:06 -07001940 CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001941 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001942}
1943
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001944void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001945 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001946 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001947 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001948}
1949
Brian Carlstromaded5f72011-10-07 17:15:04 -07001950bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001951 dex_lock_.AssertSharedHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001952 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1953 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001954 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001955 }
1956 }
1957 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001958}
1959
Brian Carlstromaded5f72011-10-07 17:15:04 -07001960bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001961 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001962 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001963}
1964
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001965void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001966 dex_lock_.AssertExclusiveHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001967 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -07001968 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()))
1969 << dex_cache->GetLocation()->ToModifiedUtf8() << " " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001970 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001971 dex_cache->SetDexFile(&dex_file);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001972 dex_caches_dirty_ = true;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001973}
1974
Brian Carlstromaded5f72011-10-07 17:15:04 -07001975void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07001976 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001977 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001978 ReaderMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001979 if (IsDexFileRegisteredLocked(dex_file)) {
1980 return;
1981 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001982 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001983 // Don't alloc while holding the lock, since allocation may need to
1984 // suspend all threads and another thread may need the dex_lock_ to
1985 // get to a suspend point.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001986 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Ian Rogersa436fde2013-08-27 23:34:06 -07001987 CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001988 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001989 WriterMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001990 if (IsDexFileRegisteredLocked(dex_file)) {
1991 return;
1992 }
1993 RegisterDexFileLocked(dex_file, dex_cache);
1994 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001995}
1996
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001997void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001998 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001999 RegisterDexFileLocked(dex_file, dex_cache);
2000}
2001
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002002mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002003 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002004 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002005 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002006 mirror::DexCache* dex_cache = dex_caches_[i];
Mathieu Chartier66f19252012-09-18 08:57:04 -07002007 if (dex_cache->GetDexFile() == &dex_file) {
2008 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002009 }
2010 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002011 // Search matching by location name.
2012 std::string location(dex_file.GetLocation());
2013 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002014 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002015 if (dex_cache->GetDexFile()->GetLocation() == location) {
2016 return dex_cache;
2017 }
2018 }
2019 // Failure, dump diagnostic and abort.
2020 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002021 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002022 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
2023 }
2024 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002025 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002026}
2027
Brian Carlstromea46f952013-07-30 01:26:50 -07002028void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002029 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08002030 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2031 dex_caches_[i]->Fixup(resolution_method);
2032 }
2033}
2034
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002035mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002036 mirror::Class* klass = AllocClass(self, sizeof(mirror::Class));
2037 if (UNLIKELY(klass == NULL)) {
2038 return NULL;
2039 }
2040 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002041}
2042
2043mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002044 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07002045 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002046 Thread* self = Thread::Current();
2047 ObjectLock lock(self, primitive_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002048 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002049 primitive_class->SetPrimitiveType(type);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002050 primitive_class->SetStatus(mirror::Class::kStatusInitialized, self);
2051 const char* descriptor = Primitive::Descriptor(type);
2052 mirror::Class* existing = InsertClass(descriptor, primitive_class, Hash(descriptor));
Ian Rogersc8982582012-09-07 16:53:25 -07002053 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002054 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07002055}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002056
Brian Carlstrombe977852011-07-19 14:54:54 -07002057// Create an array class (i.e. the class object for the array, not the
2058// array itself). "descriptor" looks like "[C" or "[[[[B" or
2059// "[Ljava/lang/String;".
2060//
2061// If "descriptor" refers to an array of primitives, look up the
2062// primitive type's internally-generated class object.
2063//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002064// "class_loader" is the class loader of the class that's referring to
2065// us. It's used to ensure that we're looking for the element type in
2066// the right context. It does NOT become the class loader for the
2067// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07002068//
2069// Returns NULL with an exception raised on failure.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002070mirror::Class* ClassLinker::CreateArrayClass(const char* descriptor,
Mathieu Chartier590fee92013-09-13 13:46:47 -07002071 SirtRef<mirror::ClassLoader>& class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002072 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002073 CHECK_EQ('[', descriptor[0]);
2074 mirror::Class* component_type = FindClass(descriptor + 1, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002075 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002076 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002077 return NULL;
2078 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002079
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002080 // See if the component type is already loaded. Array classes are
2081 // always associated with the class loader of their underlying
2082 // element type -- an array of Strings goes with the loader for
2083 // java/lang/String -- so we need to look for it there. (The
2084 // caller should have checked for the existence of the class
2085 // before calling here, but they did so with *their* class loader,
2086 // not the component type's loader.)
2087 //
2088 // If we find it, the caller adds "loader" to the class' initiating
2089 // loader list, which should prevent us from going through this again.
2090 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002091 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002092 // are the same, because our caller (FindClass) just did the
2093 // lookup. (Even if we get this wrong we still have correct behavior,
2094 // because we effectively do this lookup again when we add the new
2095 // class to the hash table --- necessary because of possible races with
2096 // other threads.)
Mathieu Chartier590fee92013-09-13 13:46:47 -07002097 if (class_loader.get() != component_type->GetClassLoader()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002098 mirror::Class* new_class = LookupClass(descriptor, component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002099 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002100 return new_class;
2101 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002102 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002103
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002104 // Fill out the fields in the Class.
2105 //
2106 // It is possible to execute some methods against arrays, because
2107 // all arrays are subclasses of java_lang_Object_, so we need to set
2108 // up a vtable. We can just point at the one in java_lang_Object_.
2109 //
2110 // Array classes are simple enough that we don't need to do a full
2111 // link step.
Ian Rogers1f539342012-10-03 21:09:42 -07002112 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002113 SirtRef<mirror::Class> new_class(self, NULL);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002114 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002115 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002116 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002117 new_class.reset(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002118 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002119 new_class.reset(GetClassRoot(kObjectArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002120 } else if (strcmp(descriptor, class_roots_descriptors_[kJavaLangStringArrayClass]) == 0) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002121 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002122 } else if (strcmp(descriptor,
2123 class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002124 new_class.reset(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002125 } else if (strcmp(descriptor,
2126 class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002127 new_class.reset(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002128 } else if (strcmp(descriptor, "[C") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002129 new_class.reset(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002130 } else if (strcmp(descriptor, "[I") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002131 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002132 }
2133 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002134 if (new_class.get() == NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002135 new_class.reset(AllocClass(self, sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002136 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002137 return NULL;
2138 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002139 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002140 }
Ian Rogers1f539342012-10-03 21:09:42 -07002141 ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002142 DCHECK(new_class->GetComponentType() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002143 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002144 new_class->SetSuperClass(java_lang_Object);
2145 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002146 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002147 new_class->SetClassLoader(component_type->GetClassLoader());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002148 new_class->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002149 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002150 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002151
2152
2153 // All arrays have java/lang/Cloneable and java/io/Serializable as
2154 // interfaces. We need to set that up here, so that stuff like
2155 // "instanceof" works right.
2156 //
2157 // Note: The GC could run during the call to FindSystemClass,
2158 // so we need to make sure the class object is GC-valid while we're in
2159 // there. Do this by clearing the interface list so the GC will just
2160 // think that the entries are null.
2161
2162
2163 // Use the single, global copies of "interfaces" and "iftable"
2164 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07002165 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002166 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002167
Elliott Hughes00626c22013-06-14 15:04:14 -07002168 // Inherit access flags from the component type.
2169 int access_flags = new_class->GetComponentType()->GetAccessFlags();
2170 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2171 access_flags &= kAccJavaFlagsMask;
2172 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002173 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07002174 access_flags |= kAccAbstract | kAccFinal;
2175 access_flags &= ~kAccInterface;
2176
2177 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002178
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002179 mirror::Class* existing = InsertClass(descriptor, new_class.get(), Hash(descriptor));
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002180 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002181 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002182 }
2183 // Another thread must have loaded the class after we
2184 // started but before we finished. Abandon what we've
2185 // done.
2186 //
2187 // (Yes, this happens.)
2188
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002189 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002190}
2191
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002192mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002193 switch (Primitive::GetType(type)) {
2194 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002195 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002196 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002197 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002198 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002199 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002200 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002201 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002202 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002203 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002204 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002205 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002206 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002207 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002208 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002209 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002210 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002211 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002212 case Primitive::kPrimNot:
2213 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002214 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002215 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002216 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002217 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002218}
2219
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002220mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass,
2221 size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002222 if (VLOG_IS_ON(class_linker)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002223 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08002224 std::string source;
2225 if (dex_cache != NULL) {
2226 source += " from ";
2227 source += dex_cache->GetLocation()->ToModifiedUtf8();
2228 }
2229 LOG(INFO) << "Loaded class " << descriptor << source;
2230 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002231 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers1d54e732013-05-02 21:10:01 -07002232 mirror::Class* existing =
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002233 LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002234 if (existing != NULL) {
2235 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002236 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002237 if (kIsDebugBuild && klass->GetClassLoader() == NULL && dex_cache_image_class_lookup_required_) {
2238 // Check a class loaded with the system class loader matches one in the image if the class
2239 // is in the image.
2240 existing = LookupClassFromImage(descriptor);
2241 if (existing != NULL) {
2242 CHECK(klass == existing);
2243 }
2244 }
Ian Rogers1d54e732013-05-02 21:10:01 -07002245 Runtime::Current()->GetHeap()->VerifyObject(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002246 class_table_.insert(std::make_pair(hash, klass));
Mathieu Chartierc4621982013-09-16 19:43:47 -07002247 class_table_dirty_ = true;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002248 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002249}
2250
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002251bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002252 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002253 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002254 for (auto it = class_table_.lower_bound(hash), end = class_table_.end(); it != end && it->first == hash;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002255 ++it) {
2256 mirror::Class* klass = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002257 ClassHelper kh(klass);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002258 if ((klass->GetClassLoader() == class_loader) &&
2259 (strcmp(descriptor, kh.GetDescriptor()) == 0)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002260 class_table_.erase(it);
Brian Carlstromae826982011-11-09 01:33:42 -08002261 return true;
2262 }
2263 }
2264 return false;
2265}
2266
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002267mirror::Class* ClassLinker::LookupClass(const char* descriptor,
2268 const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002269 size_t hash = Hash(descriptor);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002270 {
2271 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2272 mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
2273 if (result != NULL) {
2274 return result;
2275 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002276 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002277 if (class_loader != NULL || !dex_cache_image_class_lookup_required_) {
2278 return NULL;
2279 } else {
2280 // Lookup failed but need to search dex_caches_.
2281 mirror::Class* result = LookupClassFromImage(descriptor);
2282 if (result != NULL) {
2283 InsertClass(descriptor, result, hash);
2284 } else {
2285 // Searching the image dex files/caches failed, we don't want to get into this situation
2286 // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image
2287 // classes into the class table.
2288 const int32_t kMaxFailedDexCacheLookups = 1000;
2289 if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) {
2290 MoveImageClassesToClassTable();
2291 }
2292 }
2293 return result;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002294 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002295}
2296
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002297mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor,
2298 const mirror::ClassLoader* class_loader,
2299 size_t hash) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002300 auto end = class_table_.end();
2301 for (auto it = class_table_.lower_bound(hash); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002302 mirror::Class* klass = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002303 ClassHelper kh(klass);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002304 if ((klass->GetClassLoader() == class_loader) &&
2305 (strcmp(descriptor, kh.GetDescriptor()) == 0)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002306 if (kIsDebugBuild) {
2307 // Check for duplicates in the table.
2308 for (++it; it != end && it->first == hash; ++it) {
2309 mirror::Class* klass2 = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002310 ClassHelper kh(klass2);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002311 CHECK(!((klass2->GetClassLoader() == class_loader) &&
2312 (strcmp(descriptor, kh.GetDescriptor()) == 0)))
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002313 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
2314 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002315 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002316 }
Ian Rogers5d76c432011-10-31 21:42:49 -07002317 return klass;
2318 }
2319 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002320 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002321}
2322
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002323static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches()
2324 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2325 gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
2326 CHECK(image != NULL);
2327 mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
2328 return root->AsObjectArray<mirror::DexCache>();
2329}
2330
2331void ClassLinker::MoveImageClassesToClassTable() {
2332 Thread* self = Thread::Current();
2333 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2334 if (!dex_cache_image_class_lookup_required_) {
2335 return; // All dex cache classes are already in the class table.
2336 }
2337 const char* old_no_suspend_cause =
2338 self->StartAssertNoThreadSuspension("Moving image classes to class table");
2339 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002340 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
2341 mirror::DexCache* dex_cache = dex_caches->Get(i);
2342 mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes();
2343 for (int32_t j = 0; j < types->GetLength(); j++) {
2344 mirror::Class* klass = types->Get(j);
2345 if (klass != NULL) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002346 ClassHelper kh(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002347 DCHECK(klass->GetClassLoader() == NULL);
2348 const char* descriptor = kh.GetDescriptor();
2349 size_t hash = Hash(descriptor);
2350 mirror::Class* existing = LookupClassFromTableLocked(descriptor, NULL, hash);
2351 if (existing != NULL) {
2352 CHECK(existing == klass) << PrettyClassAndClassLoader(existing) << " != "
2353 << PrettyClassAndClassLoader(klass);
2354 } else {
2355 class_table_.insert(std::make_pair(hash, klass));
2356 }
2357 }
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002358 }
2359 }
Mathieu Chartierc4621982013-09-16 19:43:47 -07002360 class_table_dirty_ = true;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002361 dex_cache_image_class_lookup_required_ = false;
2362 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2363}
2364
2365mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
2366 Thread* self = Thread::Current();
2367 const char* old_no_suspend_cause =
2368 self->StartAssertNoThreadSuspension("Image class lookup");
2369 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
2370 for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
2371 mirror::DexCache* dex_cache = dex_caches->Get(i);
2372 const DexFile* dex_file = dex_cache->GetDexFile();
2373 // First search using the class def map, but don't bother for non-class types.
2374 if (descriptor[0] == 'L') {
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002375 const DexFile::StringId* descriptor_string_id = dex_file->FindStringId(descriptor);
2376 if (descriptor_string_id != NULL) {
2377 const DexFile::TypeId* type_id =
2378 dex_file->FindTypeId(dex_file->GetIndexForStringId(*descriptor_string_id));
2379 if (type_id != NULL) {
2380 mirror::Class* klass = dex_cache->GetResolvedType(dex_file->GetIndexForTypeId(*type_id));
2381 if (klass != NULL) {
2382 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2383 return klass;
2384 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002385 }
2386 }
2387 }
2388 // Now try binary searching the string/type index.
2389 const DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
2390 if (string_id != NULL) {
2391 const DexFile::TypeId* type_id =
2392 dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
2393 if (type_id != NULL) {
2394 uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id);
2395 mirror::Class* klass = dex_cache->GetResolvedType(type_idx);
2396 if (klass != NULL) {
2397 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2398 return klass;
2399 }
2400 }
2401 }
2402 }
2403 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2404 return NULL;
2405}
2406
2407void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) {
2408 result.clear();
2409 if (dex_cache_image_class_lookup_required_) {
2410 MoveImageClassesToClassTable();
2411 }
2412 size_t hash = Hash(descriptor);
2413 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002414 for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
Mathieu Chartier02e25112013-08-14 16:14:24 -07002415 it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002416 mirror::Class* klass = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002417 ClassHelper kh(klass);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002418 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002419 result.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002420 }
2421 }
2422}
2423
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002424void ClassLinker::VerifyClass(mirror::Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002425 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002426 Thread* self = Thread::Current();
2427 ObjectLock lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002428
Ian Rogers9ffb0392012-09-10 11:56:50 -07002429 // Don't attempt to re-verify if already sufficiently verified.
2430 if (klass->IsVerified() ||
2431 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002432 return;
2433 }
2434
Ian Rogers9ffb0392012-09-10 11:56:50 -07002435 // The class might already be erroneous, for example at compile time if we attempted to verify
2436 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002437 if (klass->IsErroneous()) {
2438 ThrowEarlierClassFailure(klass);
2439 return;
2440 }
2441
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002442 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002443 klass->SetStatus(mirror::Class::kStatusVerifying, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002444 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002445 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
2446 << PrettyClass(klass);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002447 CHECK(!Runtime::Current()->IsCompiler());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002448 klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002449 }
jeffhao98eacac2011-09-14 16:11:53 -07002450
Ian Rogers9ffb0392012-09-10 11:56:50 -07002451 // Verify super class.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002452 SirtRef<mirror::Class> super(self, klass->GetSuperClass());
2453 if (super.get() != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002454 // Acquire lock to prevent races on verifying the super class.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002455 ObjectLock lock(self, super.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002456
2457 if (!super->IsVerified() && !super->IsErroneous()) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002458 VerifyClass(super.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002459 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002460 if (!super->IsCompileTimeVerified()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002461 std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
2462 PrettyDescriptor(klass).c_str(),
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002463 PrettyDescriptor(super.get()).c_str()));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002464 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002465 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002466 if (cause.get() != NULL) {
2467 self->ClearException();
2468 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002469 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002470 if (cause.get() != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002471 self->GetException(NULL)->SetCause(cause.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002472 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002473 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002474 return;
2475 }
2476 }
2477
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002478 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002479 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002480 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002481 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002482 if (oat_file_class_status == mirror::Class::kStatusError) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07002483 VLOG(class_linker) << "Skipping runtime verification of erroneous class "
2484 << PrettyDescriptor(klass) << " in "
2485 << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002486 ThrowVerifyError(klass, "Rejecting class %s because it failed compile-time verification",
2487 PrettyDescriptor(klass).c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002488 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhaoec014232012-09-05 10:42:25 -07002489 return;
2490 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002491 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
Ian Rogers62d6c772013-02-27 08:32:07 -08002492 std::string error_msg;
jeffhaof1e6b7c2012-06-05 18:33:30 -07002493 if (!preverified) {
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002494 verifier_failure = verifier::MethodVerifier::VerifyClass(klass,
2495 Runtime::Current()->IsCompiler(),
2496 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07002497 }
2498 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002499 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07002500 VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass)
Ian Rogers529781d2012-07-23 17:24:29 -07002501 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2502 << " because: " << error_msg;
2503 }
Ian Rogers1f539342012-10-03 21:09:42 -07002504 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002505 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002506 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002507 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002508 // Even though there were no verifier failures we need to respect whether the super-class
2509 // was verified or requiring runtime reverification.
2510 if (super.get() == NULL || super->IsVerified()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002511 klass->SetStatus(mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002512 } else {
2513 CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002514 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07002515 // Pretend a soft failure occured so that we don't consider the class verified below.
2516 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002517 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002518 } else {
2519 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2520 // Soft failures at compile time should be retried at runtime. Soft
2521 // failures at runtime will be handled by slow paths in the generated
2522 // code. Set status accordingly.
2523 if (Runtime::Current()->IsCompiler()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002524 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002525 } else {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002526 klass->SetStatus(mirror::Class::kStatusVerified, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002527 }
2528 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002529 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002530 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002531 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2532 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002533 self->AssertNoPendingException();
Ian Rogers62d6c772013-02-27 08:32:07 -08002534 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002535 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002536 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002537 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07002538 // Class is verified so we don't need to do any access check on its methods.
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002539 // Let the interpreter know it by setting the kAccPreverified flag onto each
2540 // method.
2541 // Note: we're going here during compilation and at runtime. When we set the
2542 // kAccPreverified flag when compiling image classes, the flag is recorded
2543 // in the image and is set when loading the image.
2544 klass->SetPreverifiedFlagOnAllMethods();
2545 }
jeffhao98eacac2011-09-14 16:11:53 -07002546}
2547
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002548bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
2549 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002550 // If we're compiling, we can only verify the class using the oat file if
2551 // we are not compiling the image or if the class we're verifying is not part of
2552 // the app. In other words, we will only check for preverification of bootclasspath
2553 // classes.
2554 if (Runtime::Current()->IsCompiler()) {
2555 // Are we compiling the bootclasspath?
2556 if (!Runtime::Current()->UseCompileTimeClassPath()) {
2557 return false;
2558 }
2559 // We are compiling an app (not the image).
2560
2561 // Is this an app class? (I.e. not a bootclasspath class)
2562 if (klass->GetClassLoader() != NULL) {
2563 return false;
2564 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002565 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002566
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002567 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07002568 // Make this work with gtests, which do not set up the image properly.
2569 // TODO: we should clean up gtests to set up the image path properly.
2570 if (Runtime::Current()->IsCompiler() && (oat_file == NULL)) {
2571 return false;
2572 }
2573
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002574 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002575 uint dex_location_checksum = dex_file.GetLocationChecksum();
Ian Rogers8d31bbd2013-10-13 10:44:14 -07002576 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002577 &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002578 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002579 uint16_t class_def_index = klass->GetDexClassDefIndex();
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002580 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002581 CHECK(oat_class.get() != NULL)
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002582 << dex_file.GetLocation() << " " << PrettyClass(klass) << " "
2583 << ClassHelper(klass).GetDescriptor();
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002584 oat_file_class_status = oat_class->GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002585 if (oat_file_class_status == mirror::Class::kStatusVerified ||
2586 oat_file_class_status == mirror::Class::kStatusInitialized) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002587 return true;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002588 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002589 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002590 // Compile time verification failed with a soft error. Compile time verification can fail
2591 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002592 // class ... {
2593 // Foo x;
2594 // .... () {
2595 // if (...) {
2596 // v1 gets assigned a type of resolved class Foo
2597 // } else {
2598 // v1 gets assigned a type of unresolved class Bar
2599 // }
2600 // iput x = v1
2601 // } }
2602 // when we merge v1 following the if-the-else it results in Conflict
2603 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2604 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2605 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2606 // at compile time).
2607 return false;
2608 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002609 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07002610 // Compile time verification failed with a hard error. This is caused by invalid instructions
2611 // in the class. These errors are unrecoverable.
2612 return false;
2613 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002614 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002615 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2616 // not loading the class.
2617 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2618 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002619 return false;
2620 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002621 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002622 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " "
2623 << ClassHelper(klass).GetDescriptor();
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002624
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002625 return false;
2626}
2627
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002628void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002629 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2630 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2631 }
2632 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2633 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2634 }
2635}
2636
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002637void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
Brian Carlstromea46f952013-07-30 01:26:50 -07002638 mirror::ArtMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002639 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2640 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2641 if (code_item == NULL) {
2642 return; // native or abstract method
2643 }
2644 if (code_item->tries_size_ == 0) {
2645 return; // nothing to process
2646 }
2647 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2648 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2649 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2650 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2651 CatchHandlerIterator iterator(handlers_ptr);
2652 for (; iterator.HasNext(); iterator.Next()) {
2653 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2654 // unresolved exception types will be ignored by exception delivery
2655 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002656 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002657 if (exception_type == NULL) {
2658 DCHECK(Thread::Current()->IsExceptionPending());
2659 Thread::Current()->ClearException();
2660 }
2661 }
2662 }
2663 handlers_ptr = iterator.EndDataPointer();
2664 }
2665}
2666
Brian Carlstromea46f952013-07-30 01:26:50 -07002667static void CheckProxyConstructor(mirror::ArtMethod* constructor);
2668static void CheckProxyMethod(mirror::ArtMethod* method,
2669 SirtRef<mirror::ArtMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002670
Mathieu Chartier590fee92013-09-13 13:46:47 -07002671mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccess& soa, jstring name,
2672 jobjectArray interfaces, jobject loader,
2673 jobjectArray methods, jobjectArray throws) {
2674 Thread* self = soa.Self();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002675 SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2676 sizeof(mirror::SynthesizedProxyClass)));
Ian Rogersa436fde2013-08-27 23:34:06 -07002677 if (klass.get() == NULL) {
2678 CHECK(self->IsExceptionPending()); // OOME.
2679 return NULL;
2680 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002681 DCHECK(klass->GetClass() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002682 klass->SetObjectSize(sizeof(mirror::Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002683 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Mathieu Chartier590fee92013-09-13 13:46:47 -07002684 klass->SetClassLoader(soa.Decode<mirror::ClassLoader*>(loader));
Ian Rogersc2b44472011-12-14 21:17:17 -08002685 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Mathieu Chartier590fee92013-09-13 13:46:47 -07002686 klass->SetName(soa.Decode<mirror::String*>(name));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002687 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002688 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002689 klass->SetStatus(mirror::Class::kStatusIdx, self);
Ian Rogersc2b44472011-12-14 21:17:17 -08002690
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002691 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogersa436fde2013-08-27 23:34:06 -07002692 {
2693 mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
2694 if (UNLIKELY(sfields == NULL)) {
2695 CHECK(self->IsExceptionPending()); // OOME.
2696 return NULL;
2697 }
2698 klass->SetSFields(sfields);
2699 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002700 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2701 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Brian Carlstromea46f952013-07-30 01:26:50 -07002702 SirtRef<mirror::ArtField> interfaces_sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002703 if (UNLIKELY(interfaces_sfield.get() == NULL)) {
2704 CHECK(self->IsExceptionPending()); // OOME.
2705 return NULL;
2706 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002707 klass->SetStaticField(0, interfaces_sfield.get());
2708 interfaces_sfield->SetDexFieldIndex(0);
2709 interfaces_sfield->SetDeclaringClass(klass.get());
2710 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2711 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Brian Carlstromea46f952013-07-30 01:26:50 -07002712 SirtRef<mirror::ArtField> throws_sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002713 if (UNLIKELY(throws_sfield.get() == NULL)) {
2714 CHECK(self->IsExceptionPending()); // OOME.
2715 return NULL;
2716 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002717 klass->SetStaticField(1, throws_sfield.get());
2718 throws_sfield->SetDexFieldIndex(1);
2719 throws_sfield->SetDeclaringClass(klass.get());
2720 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002721
Ian Rogers466bb252011-10-14 03:29:56 -07002722 // Proxies have 1 direct method, the constructor
Ian Rogersa436fde2013-08-27 23:34:06 -07002723 {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002724 mirror::ObjectArray<mirror::ArtMethod>* directs = AllocArtMethodArray(self, 1);
Ian Rogersa436fde2013-08-27 23:34:06 -07002725 if (UNLIKELY(directs == NULL)) {
2726 CHECK(self->IsExceptionPending()); // OOME.
2727 return NULL;
2728 }
2729 klass->SetDirectMethods(directs);
2730 mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class);
2731 if (UNLIKELY(constructor == NULL)) {
2732 CHECK(self->IsExceptionPending()); // OOME.
2733 return NULL;
2734 }
2735 klass->SetDirectMethod(0, constructor);
2736 }
Jesse Wilson95caa792011-10-12 18:14:17 -04002737
Mathieu Chartier590fee92013-09-13 13:46:47 -07002738 // Create virtual method using specified prototypes.
2739 size_t num_virtual_methods =
2740 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods)->GetLength();
Ian Rogersa436fde2013-08-27 23:34:06 -07002741 {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002742 mirror::ObjectArray<mirror::ArtMethod>* virtuals = AllocArtMethodArray(self, num_virtual_methods);
Ian Rogersa436fde2013-08-27 23:34:06 -07002743 if (UNLIKELY(virtuals == NULL)) {
2744 CHECK(self->IsExceptionPending()); // OOME.
2745 return NULL;
2746 }
2747 klass->SetVirtualMethods(virtuals);
2748 }
Jesse Wilson95caa792011-10-12 18:14:17 -04002749 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002750 mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
2751 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
2752 SirtRef<mirror::ArtMethod> prototype(self, decoded_methods->Get(i));
Ian Rogersa436fde2013-08-27 23:34:06 -07002753 mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype);
2754 if (UNLIKELY(clone == NULL)) {
2755 CHECK(self->IsExceptionPending()); // OOME.
2756 return NULL;
2757 }
2758 klass->SetVirtualMethod(i, clone);
Jesse Wilson95caa792011-10-12 18:14:17 -04002759 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002760
2761 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002762 klass->SetStatus(mirror::Class::kStatusLoaded, self); // Class is now effectively in the loaded state
Ian Rogers62d6c772013-02-27 08:32:07 -08002763 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08002764
Ian Rogersc8982582012-09-07 16:53:25 -07002765 {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002766 ObjectLock lock(self, klass.get()); // Must hold lock on object when resolved.
2767 // Link the fields and virtual methods, creating vtable and iftables
Mathieu Chartier590fee92013-09-13 13:46:47 -07002768 SirtRef<mirror::ObjectArray<mirror::Class> > sirt_interfaces(
2769 self, soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2770 if (!LinkClass(self, klass, sirt_interfaces)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002771 klass->SetStatus(mirror::Class::kStatusError, self);
2772 return NULL;
2773 }
2774
Mathieu Chartier590fee92013-09-13 13:46:47 -07002775 interfaces_sfield->SetObject(klass.get(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2776 throws_sfield->SetObject(klass.get(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002777 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogersc8982582012-09-07 16:53:25 -07002778 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002779
2780 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002781 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002782 CHECK(klass->GetIFields() == NULL);
2783 CheckProxyConstructor(klass->GetDirectMethod(0));
2784 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002785 mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
2786 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
2787 SirtRef<mirror::ArtMethod> prototype(self, decoded_methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002788 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2789 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002790
Mathieu Chartier590fee92013-09-13 13:46:47 -07002791 mirror::String* decoded_name = soa.Decode<mirror::String*>(name);
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002792 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
Mathieu Chartier590fee92013-09-13 13:46:47 -07002793 decoded_name->ToModifiedUtf8().c_str()));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002794 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2795
2796 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
Mathieu Chartier590fee92013-09-13 13:46:47 -07002797 decoded_name->ToModifiedUtf8().c_str()));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002798 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002799
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002800 mirror::SynthesizedProxyClass* synth_proxy_class =
2801 down_cast<mirror::SynthesizedProxyClass*>(klass.get());
Mathieu Chartier590fee92013-09-13 13:46:47 -07002802 CHECK_EQ(synth_proxy_class->GetInterfaces(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2803 CHECK_EQ(synth_proxy_class->GetThrows(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
Ian Rogersc2b44472011-12-14 21:17:17 -08002804 }
Mathieu Chartier31b9d662013-10-14 11:53:12 -07002805 std::string descriptor(GetDescriptorForProxy(klass.get()));
2806 mirror::Class* existing = InsertClass(descriptor.c_str(), klass.get(), Hash(descriptor.c_str()));
2807 CHECK(existing == nullptr);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002808 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002809}
2810
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002811std::string ClassLinker::GetDescriptorForProxy(const mirror::Class* proxy_class) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002812 DCHECK(proxy_class->IsProxyClass());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002813 mirror::String* name = proxy_class->GetName();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002814 DCHECK(name != NULL);
2815 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2816}
2817
Brian Carlstromea46f952013-07-30 01:26:50 -07002818mirror::ArtMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
2819 const mirror::ArtMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002820 DCHECK(proxy_class->IsProxyClass());
2821 DCHECK(proxy_method->IsProxyMethod());
2822 // Locate the dex cache of the original interface/Object
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002823 mirror::DexCache* dex_cache = NULL;
Ian Rogers16f93672012-02-14 12:29:06 -08002824 {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002825 mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002826 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002827 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2828 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2829 dex_cache = dex_caches_[i];
2830 break;
2831 }
2832 }
2833 }
2834 CHECK(dex_cache != NULL);
2835 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Brian Carlstromea46f952013-07-30 01:26:50 -07002836 mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002837 CHECK(resolved_method != NULL);
2838 return resolved_method;
2839}
2840
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002841
Brian Carlstromea46f952013-07-30 01:26:50 -07002842mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
2843 SirtRef<mirror::Class>& klass,
2844 mirror::Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002845 // Create constructor for Proxy that must initialize h
Brian Carlstromea46f952013-07-30 01:26:50 -07002846 mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002847 proxy_class->GetDirectMethods();
Brian Carlstromea46f952013-07-30 01:26:50 -07002848 CHECK_EQ(proxy_direct_methods->GetLength(), 16);
2849 mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002850 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2851 // code_ too)
Brian Carlstromea46f952013-07-30 01:26:50 -07002852 mirror::ArtMethod* constructor =
2853 down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002854 if (constructor == NULL) {
2855 CHECK(self->IsExceptionPending()); // OOME.
2856 return NULL;
2857 }
Ian Rogers466bb252011-10-14 03:29:56 -07002858 // Make this constructor public and fix the class to be our Proxy version
2859 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002860 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002861 return constructor;
2862}
2863
Brian Carlstromea46f952013-07-30 01:26:50 -07002864static void CheckProxyConstructor(mirror::ArtMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002865 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002866 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002867 MethodHelper mh(constructor);
2868 CHECK_STREQ(mh.GetName(), "<init>");
Ian Rogersd91d6d62013-09-25 20:26:14 -07002869 CHECK_STREQ(mh.GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V");
Ian Rogers466bb252011-10-14 03:29:56 -07002870 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002871}
2872
Brian Carlstromea46f952013-07-30 01:26:50 -07002873mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
Ian Rogersd91d6d62013-09-25 20:26:14 -07002874 SirtRef<mirror::ArtMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002875 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2876 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002877 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2878 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002879 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002880 // as necessary
Brian Carlstromea46f952013-07-30 01:26:50 -07002881 mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002882 if (UNLIKELY(method == NULL)) {
2883 CHECK(self->IsExceptionPending()); // OOME.
2884 return NULL;
2885 }
Ian Rogers466bb252011-10-14 03:29:56 -07002886
2887 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2888 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002889 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002890 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002891
Ian Rogers466bb252011-10-14 03:29:56 -07002892 // At runtime the method looks like a reference and argument saving method, clone the code
2893 // related parameters from this method.
Brian Carlstromea46f952013-07-30 01:26:50 -07002894 mirror::ArtMethod* refs_and_args =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002895 Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07002896 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2897 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2898 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
Ian Rogers848871b2013-08-05 10:56:33 -07002899 method->SetEntryPointFromCompiledCode(GetProxyInvokeHandler());
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07002900 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Ian Rogers16f93672012-02-14 12:29:06 -08002901
Ian Rogersc2b44472011-12-14 21:17:17 -08002902 return method;
2903}
Jesse Wilson95caa792011-10-12 18:14:17 -04002904
Brian Carlstromea46f952013-07-30 01:26:50 -07002905static void CheckProxyMethod(mirror::ArtMethod* method,
2906 SirtRef<mirror::ArtMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002907 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002908 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002909 CHECK(!prototype->IsFinal());
2910 CHECK(method->IsFinal());
2911 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002912
2913 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2914 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2915 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2916 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2917 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2918 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2919 method->GetDexCacheInitializedStaticStorage());
2920 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2921
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002922 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002923 MethodHelper mh2(prototype.get());
2924 CHECK_STREQ(mh.GetName(), mh2.GetName());
2925 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002926 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002927 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002928}
2929
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002930static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics,
2931 bool can_init_parents)
2932 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08002933 if (can_init_statics && can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002934 return true;
2935 }
2936 if (!can_init_statics) {
2937 // Check if there's a class initializer.
Ian Rogersd91d6d62013-09-25 20:26:14 -07002938 mirror::ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002939 if (clinit != NULL) {
2940 return false;
2941 }
2942 // Check if there are encoded static values needing initialization.
2943 if (klass->NumStaticFields() != 0) {
2944 ClassHelper kh(klass);
2945 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
2946 DCHECK(dex_class_def != NULL);
2947 if (dex_class_def->static_values_off_ != 0) {
2948 return false;
2949 }
2950 }
2951 }
2952 if (!klass->IsInterface() && klass->HasSuperClass()) {
2953 mirror::Class* super_class = klass->GetSuperClass();
2954 if (!can_init_parents && !super_class->IsInitialized()) {
2955 return false;
2956 } else {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08002957 if (!CanWeInitializeClass(super_class, can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002958 return false;
2959 }
2960 }
2961 }
2962 return true;
2963}
2964
Mathieu Chartier590fee92013-09-13 13:46:47 -07002965bool ClassLinker::IsInitialized() const {
2966 return init_done_;
2967}
2968
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002969bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
2970 bool can_init_parents) {
2971 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
2972
2973 // Are we already initialized and therefore done?
2974 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
2975 // an initialized class will never change its state.
2976 if (klass->IsInitialized()) {
2977 return true;
2978 }
2979
2980 // Fast fail if initialization requires a full runtime. Not part of the JLS.
2981 if (!CanWeInitializeClass(klass, can_init_statics, can_init_parents)) {
2982 return false;
2983 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002984
Carl Shapirob5573532011-07-12 18:22:59 -07002985 Thread* self = Thread::Current();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002986 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002987 {
Ian Rogers1f539342012-10-03 21:09:42 -07002988 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002989
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002990 // Re-check under the lock in case another thread initialized ahead of us.
2991 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002992 return true;
2993 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002994
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002995 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07002996 if (klass->IsErroneous()) {
2997 ThrowEarlierClassFailure(klass);
2998 return false;
2999 }
3000
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003001 CHECK(klass->IsResolved()) << PrettyClass(klass) << ": state=" << klass->GetStatus();
3002
3003 if (!klass->IsVerified()) {
jeffhao98eacac2011-09-14 16:11:53 -07003004 VerifyClass(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003005 if (!klass->IsVerified()) {
3006 // We failed to verify, expect either the klass to be erroneous or verification failed at
3007 // compile time.
3008 if (klass->IsErroneous()) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07003009 CHECK(self->IsExceptionPending());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003010 } else {
3011 CHECK(Runtime::Current()->IsCompiler());
3012 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07003013 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003014 return false;
3015 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003016 }
3017
Brian Carlstromd1422f82011-09-28 11:37:09 -07003018 // If the class is kStatusInitializing, either this thread is
3019 // initializing higher up the stack or another thread has beat us
3020 // to initializing and we need to wait. Either way, this
3021 // invocation of InitializeClass will not be responsible for
3022 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003023 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07003024 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07003025 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003026 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003027 return true;
3028 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003029 // No. That's fine. Wait for another thread to finish initializing.
3030 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003031 }
3032
3033 if (!ValidateSuperClassDescriptors(klass)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003034 klass->SetStatus(mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003035 return false;
3036 }
3037
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003038 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003039
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003040 // From here out other threads may observe that we're initializing and so changes of state
3041 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07003042 klass->SetClinitThreadId(self->GetTid());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003043 klass->SetStatus(mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003044
3045 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003046 }
3047
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07003048 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003049 if (!klass->IsInterface() && klass->HasSuperClass()) {
3050 mirror::Class* super_class = klass->GetSuperClass();
3051 if (!super_class->IsInitialized()) {
3052 CHECK(!super_class->IsInterface());
3053 CHECK(can_init_parents);
3054 bool super_initialized = InitializeClass(super_class, can_init_statics, true);
3055 if (!super_initialized) {
3056 // The super class was verified ahead of entering initializing, we should only be here if
3057 // the super class became erroneous due to initialization.
3058 CHECK(super_class->IsErroneous() && self->IsExceptionPending())
3059 << "Super class initialization failed for " << PrettyDescriptor(super_class)
3060 << " that has unexpected status " << super_class->GetStatus()
3061 << "\nPending exception:\n"
3062 << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
3063 ObjectLock lock(self, klass);
3064 // Initialization failed because the super-class is erroneous.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003065 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003066 return false;
3067 }
Ian Rogers1bddec32012-02-04 12:27:34 -08003068 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003069 }
3070
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003071 if (klass->NumStaticFields() > 0) {
3072 ClassHelper kh(klass);
3073 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
3074 CHECK(dex_class_def != NULL);
3075 const DexFile& dex_file = kh.GetDexFile();
Mathieu Chartier590fee92013-09-13 13:46:47 -07003076 SirtRef<mirror::ClassLoader> class_loader(self, klass->GetClassLoader());
3077 SirtRef<mirror::DexCache> dex_cache(self, kh.GetDexCache());
3078 EncodedStaticFieldValueIterator it(dex_file, &dex_cache, &class_loader,
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003079 this, *dex_class_def);
3080 if (it.HasNext()) {
3081 CHECK(can_init_statics);
3082 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
3083 SafeMap<uint32_t, mirror::ArtField*> field_map;
3084 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
3085 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
3086 it.ReadValueToField(field_map.Get(i));
3087 }
3088 }
3089 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003090
Ian Rogersd91d6d62013-09-25 20:26:14 -07003091 mirror::ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003092 if (clinit != NULL) {
3093 CHECK(can_init_statics);
3094 if (LIKELY(Runtime::Current()->IsStarted())) {
Jeff Hao5d917302013-02-27 17:57:33 -08003095 JValue result;
Jeff Hao6474d192013-03-26 14:08:09 -07003096 clinit->Invoke(self, NULL, 0, &result, 'V');
Ian Rogers64b6d142012-10-29 16:34:15 -07003097 } else {
Jeff Hao6474d192013-03-26 14:08:09 -07003098 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
Ian Rogers64b6d142012-10-29 16:34:15 -07003099 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003100 }
3101
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003102 // Opportunistically set static method trampolines to their destination.
3103 FixupStaticTrampolines(klass);
Ian Rogers19846512012-02-24 11:42:47 -08003104
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003105 uint64_t t1 = NanoTime();
3106
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003107 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003108 {
Ian Rogers1f539342012-10-03 21:09:42 -07003109 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003110
3111 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003112 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003113 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003114 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003115 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003116 RuntimeStats* global_stats = Runtime::Current()->GetStats();
3117 RuntimeStats* thread_stats = self->GetStats();
3118 ++global_stats->class_init_count;
3119 ++thread_stats->class_init_count;
3120 global_stats->class_init_time_ns += (t1 - t0);
3121 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003122 // Set the class as initialized except if failed to initialize static fields.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003123 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003124 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003125 ClassHelper kh(klass);
3126 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08003127 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003128 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003129 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003130 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003131}
3132
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003133bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003134 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003135 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003136 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003137 CHECK(!klass->IsInitialized());
Ian Rogers05f30572013-02-20 12:13:11 -08003138 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07003139
3140 // When we wake up, repeat the test for init-in-progress. If
3141 // there's an exception pending (only possible if
3142 // "interruptShouldThrow" was set), bail out.
3143 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003144 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003145 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07003146 return false;
3147 }
3148 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003149 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003150 continue;
3151 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003152 if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07003153 // Compile time initialization failed.
3154 return false;
3155 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003156 if (klass->IsErroneous()) {
3157 // The caller wants an exception, but it was thrown in a
3158 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07003159 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003160 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07003161 return false;
3162 }
3163 if (klass->IsInitialized()) {
3164 return true;
3165 }
3166 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
3167 }
3168 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
3169}
3170
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003171bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003172 if (klass->IsInterface()) {
3173 return true;
3174 }
3175 // begin with the methods local to the superclass
3176 if (klass->HasSuperClass() &&
3177 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003178 const mirror::Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08003179 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003180 const mirror::ArtMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08003181 if (method != super->GetVTable()->Get(i) &&
3182 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003183 ThrowLinkageError(klass, "Class %s method %s resolves differently in superclass %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003184 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
3185 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003186 return false;
3187 }
3188 }
3189 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003190 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003191 mirror::Class* interface = klass->GetIfTable()->GetInterface(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003192 if (klass->GetClassLoader() != interface->GetClassLoader()) {
3193 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003194 const mirror::ArtMethod* method = klass->GetIfTable()->GetMethodArray(i)->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08003195 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
3196 method->GetDeclaringClass())) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003197 ThrowLinkageError(klass, "Class %s method %s resolves differently in interface %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003198 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
3199 PrettyMethod(method).c_str(),
3200 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003201 return false;
3202 }
3203 }
3204 }
3205 }
3206 return true;
3207}
3208
Ian Rogers595799e2012-01-11 17:32:51 -08003209// Returns true if classes referenced by the signature of the method are the
3210// same classes in klass1 as they are in klass2.
Brian Carlstromea46f952013-07-30 01:26:50 -07003211bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::ArtMethod* method,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003212 const mirror::Class* klass1,
3213 const mirror::Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07003214 if (klass1 == klass2) {
3215 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07003216 }
Ian Rogers4445a7e2012-10-05 17:19:13 -07003217 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003218 const DexFile::ProtoId& proto_id =
3219 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07003220 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
3221 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003222 if (descriptor == NULL) {
3223 break;
3224 }
3225 if (descriptor[0] == 'L' || descriptor[0] == '[') {
3226 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08003227 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003228 return false;
3229 }
3230 }
3231 }
3232 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003233 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003234 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08003235 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003236 return false;
3237 }
3238 }
3239 return true;
3240}
3241
Ian Rogers595799e2012-01-11 17:32:51 -08003242// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
3243bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003244 const mirror::Class* klass1,
3245 const mirror::Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003246 CHECK(descriptor != NULL);
3247 CHECK(klass1 != NULL);
3248 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07003249 if (klass1 == klass2) {
3250 return true;
3251 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003252 Thread* self = Thread::Current();
3253 SirtRef<mirror::ClassLoader> class_loader1(self, klass1->GetClassLoader());
3254 mirror::Class* found1 = FindClass(descriptor, class_loader1);
Ian Rogers595799e2012-01-11 17:32:51 -08003255 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07003256 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003257 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003258 SirtRef<mirror::ClassLoader> class_loader2(self, klass2->GetClassLoader());
3259 mirror::Class* found2 = FindClass(descriptor, class_loader2);
Ian Rogers595799e2012-01-11 17:32:51 -08003260 if (found2 == NULL) {
3261 Thread::Current()->ClearException();
3262 }
3263 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003264}
3265
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003266bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_init_fields, bool can_init_parents) {
Mathieu Chartier155dfe92012-10-09 14:24:49 -07003267 DCHECK(c != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07003268 if (c->IsInitialized()) {
3269 return true;
3270 }
3271
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003272 bool success = InitializeClass(c, can_init_fields, can_init_parents);
Ian Rogers595799e2012-01-11 17:32:51 -08003273 if (!success) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003274 Thread* self = Thread::Current();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003275 CHECK(self->IsExceptionPending() || !can_init_fields || !can_init_parents) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08003276 }
3277 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07003278}
3279
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003280void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Mathieu Chartier590fee92013-09-13 13:46:47 -07003281 mirror::Class* c,
3282 SafeMap<uint32_t, mirror::ArtField*>& field_map) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003283 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07003284 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003285 Thread* self = Thread::Current();
3286 SirtRef<mirror::DexCache> dex_cache(self, c->GetDexCache());
3287 SirtRef<mirror::ClassLoader> class_loader(self, c->GetClassLoader());
Ian Rogers0571d352011-11-03 19:51:38 -07003288 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003289 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), dex_cache, class_loader, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003290 }
3291}
3292
Mathieu Chartier590fee92013-09-13 13:46:47 -07003293bool ClassLinker::LinkClass(Thread* self, SirtRef<mirror::Class>& klass,
3294 SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003295 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003296 if (!LinkSuperClass(klass)) {
3297 return false;
3298 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003299 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003300 return false;
3301 }
3302 if (!LinkInstanceFields(klass)) {
3303 return false;
3304 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07003305 if (!LinkStaticFields(klass)) {
3306 return false;
3307 }
3308 CreateReferenceInstanceOffsets(klass);
3309 CreateReferenceStaticOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003310 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003311 klass->SetStatus(mirror::Class::kStatusResolved, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003312 return true;
3313}
3314
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003315bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file) {
3316 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003317 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
3318 uint16_t super_class_idx = class_def.superclass_idx_;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003319 if (super_class_idx != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003320 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003321 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003322 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003323 return false;
3324 }
Ian Rogersbe125a92012-01-11 15:19:49 -08003325 // Verify
3326 if (!klass->CanAccess(super_class)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003327 ThrowIllegalAccessError(klass.get(), "Class %s extended by class %s is inaccessible",
3328 PrettyDescriptor(super_class).c_str(),
3329 PrettyDescriptor(klass.get()).c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08003330 return false;
3331 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003332 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003333 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003334 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003335 if (interfaces != NULL) {
3336 for (size_t i = 0; i < interfaces->Size(); i++) {
3337 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003338 mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003339 if (interface == NULL) {
3340 DCHECK(Thread::Current()->IsExceptionPending());
3341 return false;
3342 }
3343 // Verify
3344 if (!klass->CanAccess(interface)) {
3345 // TODO: the RI seemed to ignore this in my testing.
Ian Rogers62d6c772013-02-27 08:32:07 -08003346 ThrowIllegalAccessError(klass.get(), "Interface %s implemented by class %s is inaccessible",
3347 PrettyDescriptor(interface).c_str(),
3348 PrettyDescriptor(klass.get()).c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003349 return false;
3350 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003351 }
3352 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003353 // Mark the class as loaded.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003354 klass->SetStatus(mirror::Class::kStatusLoaded, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003355 return true;
3356}
3357
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003358bool ClassLinker::LinkSuperClass(SirtRef<mirror::Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003359 CHECK(!klass->IsPrimitive());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003360 mirror::Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003361 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003362 if (super != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003363 ThrowClassFormatError(klass.get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003364 return false;
3365 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003366 return true;
3367 }
3368 if (super == NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003369 ThrowLinkageError(klass.get(), "No superclass defined for class %s",
3370 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003371 return false;
3372 }
3373 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003374 if (super->IsFinal() || super->IsInterface()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003375 ThrowIncompatibleClassChangeError(klass.get(), "Superclass %s of %s is %s",
3376 PrettyDescriptor(super).c_str(),
3377 PrettyDescriptor(klass.get()).c_str(),
3378 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003379 return false;
3380 }
3381 if (!klass->CanAccess(super)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003382 ThrowIllegalAccessError(klass.get(), "Superclass %s is inaccessible to class %s",
3383 PrettyDescriptor(super).c_str(),
3384 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003385 return false;
3386 }
Elliott Hughes20cde902011-10-04 17:37:27 -07003387
3388 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3389 if (super->IsFinalizable()) {
3390 klass->SetFinalizable();
3391 }
3392
Elliott Hughes2da50362011-10-10 16:57:08 -07003393 // Inherit reference flags (if any) from the superclass.
3394 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3395 if (reference_flags != 0) {
3396 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3397 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003398 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07003399 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003400 ThrowLinkageError(klass.get(),
3401 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
3402 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003403 return false;
3404 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003405
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003406 if (kIsDebugBuild) {
3407 // Ensure super classes are fully resolved prior to resolving fields..
3408 while (super != NULL) {
3409 CHECK(super->IsResolved());
3410 super = super->GetSuperClass();
3411 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003412 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003413 return true;
3414}
3415
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003416// Populate the class vtable and itable. Compute return type indices.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003417bool ClassLinker::LinkMethods(SirtRef<mirror::Class>& klass,
Mathieu Chartier590fee92013-09-13 13:46:47 -07003418 SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003419 if (klass->IsInterface()) {
3420 // No vtable.
3421 size_t count = klass->NumVirtualMethods();
3422 if (!IsUint(16, count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003423 ThrowClassFormatError(klass.get(), "Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003424 return false;
3425 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003426 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003427 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003428 }
jeffhaobdb76512011-09-07 11:43:16 -07003429 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003430 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003431 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003432 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003433 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003434 }
3435 return true;
3436}
3437
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003438bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003439 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003440 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003441 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3442 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003443 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003444 // TODO: do not assign to the vtable field until it is fully constructed.
Brian Carlstromea46f952013-07-30 01:26:50 -07003445 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003446 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003447 if (UNLIKELY(vtable.get() == NULL)) {
3448 CHECK(self->IsExceptionPending()); // OOME.
3449 return false;
3450 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003451 // See if any of our virtual methods override the superclass.
3452 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003453 mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003454 MethodHelper local_mh(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003455 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003456 for (; j < actual_count; ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003457 mirror::ArtMethod* super_method = vtable->Get(j);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003458 MethodHelper super_mh(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003459 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3460 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3461 if (super_method->IsFinal()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003462 ThrowLinkageError(klass.get(), "Method %s overrides final method in class %s",
Elliott Hughes39717372012-07-13 16:21:23 -07003463 PrettyMethod(local_method).c_str(),
3464 super_mh.GetDeclaringClassDescriptor());
3465 return false;
3466 }
3467 vtable->Set(j, local_method);
3468 local_method->SetMethodIndex(j);
3469 break;
3470 } else {
3471 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3472 << " would have incorrectly overridden the package-private method in "
3473 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003474 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003475 }
3476 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003477 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003478 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003479 vtable->Set(actual_count, local_method);
3480 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003481 actual_count += 1;
3482 }
3483 }
3484 if (!IsUint(16, actual_count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003485 ThrowClassFormatError(klass.get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003486 return false;
3487 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003488 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003489 CHECK_LE(actual_count, max_count);
3490 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003491 vtable.reset(vtable->CopyOf(self, actual_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003492 if (UNLIKELY(vtable.get() == NULL)) {
3493 CHECK(self->IsExceptionPending()); // OOME.
3494 return false;
3495 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003496 }
Ian Rogers30fab402012-01-23 15:43:46 -08003497 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003498 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003499 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003500 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003501 if (!IsUint(16, num_virtual_methods)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003502 ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003503 return false;
3504 }
Brian Carlstromea46f952013-07-30 01:26:50 -07003505 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3506 vtable(self, AllocArtMethodArray(self, num_virtual_methods));
Ian Rogersa436fde2013-08-27 23:34:06 -07003507 if (UNLIKELY(vtable.get() == NULL)) {
3508 CHECK(self->IsExceptionPending()); // OOME.
3509 return false;
3510 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003511 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003512 mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003513 vtable->Set(i, virtual_method);
3514 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003515 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003516 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003517 }
3518 return true;
3519}
3520
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003521bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
Mathieu Chartier590fee92013-09-13 13:46:47 -07003522 SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
Jeff Hao88474b42013-10-23 16:24:40 -07003523 // Set the imt table to be all conflicts by default.
3524 klass->SetImTable(Runtime::Current()->GetDefaultImt());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003525 size_t super_ifcount;
3526 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003527 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003528 } else {
3529 super_ifcount = 0;
3530 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003531 size_t ifcount = super_ifcount;
Mathieu Chartier590fee92013-09-13 13:46:47 -07003532 ClassHelper kh(klass.get());
3533 uint32_t num_interfaces =
3534 interfaces.get() == nullptr ? kh.NumDirectInterfaces() : interfaces->GetLength();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003535 ifcount += num_interfaces;
3536 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003537 mirror::Class* interface =
3538 interfaces.get() == nullptr ? kh.GetDirectInterface(i) : interfaces->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003539 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003540 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003541 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003542 // Class implements no interfaces.
3543 DCHECK_EQ(klass->GetIfTableCount(), 0);
3544 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003545 return true;
3546 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003547 if (ifcount == super_ifcount) {
3548 // Class implements same interfaces as parent, are any of these not marker interfaces?
3549 bool has_non_marker_interface = false;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003550 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Ian Rogers9bc81912012-10-11 21:43:36 -07003551 for (size_t i = 0; i < ifcount; ++i) {
3552 if (super_iftable->GetMethodArrayCount(i) > 0) {
3553 has_non_marker_interface = true;
3554 break;
3555 }
3556 }
3557 if (!has_non_marker_interface) {
3558 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3559 klass->SetIfTable(super_iftable);
3560 return true;
3561 }
3562 }
Ian Rogers1f539342012-10-03 21:09:42 -07003563 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003564 SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
Ian Rogersa436fde2013-08-27 23:34:06 -07003565 if (UNLIKELY(iftable.get() == NULL)) {
3566 CHECK(self->IsExceptionPending()); // OOME.
3567 return false;
3568 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003569 if (super_ifcount != 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003570 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003571 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003572 mirror::Class* super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003573 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003574 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003575 }
3576 // Flatten the interface inheritance hierarchy.
3577 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003578 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003579 mirror::Class* interface =
3580 interfaces.get() == nullptr ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003581 DCHECK(interface != NULL);
3582 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003583 ClassHelper ih(interface);
Ian Rogers62d6c772013-02-27 08:32:07 -08003584 ThrowIncompatibleClassChangeError(klass.get(), "Class %s implements non-interface class %s",
3585 PrettyDescriptor(klass.get()).c_str(),
3586 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003587 return false;
3588 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003589 // Check if interface is already in iftable
3590 bool duplicate = false;
3591 for (size_t j = 0; j < idx; j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003592 mirror::Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003593 if (existing_interface == interface) {
3594 duplicate = true;
3595 break;
3596 }
3597 }
3598 if (!duplicate) {
3599 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003600 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003601 // Add this interface's non-duplicate super-interfaces.
3602 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003603 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003604 bool super_duplicate = false;
3605 for (size_t k = 0; k < idx; k++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003606 mirror::Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003607 if (existing_interface == super_interface) {
3608 super_duplicate = true;
3609 break;
3610 }
3611 }
3612 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003613 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003614 }
3615 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003616 }
3617 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003618 // Shrink iftable in case duplicates were found
3619 if (idx < ifcount) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003620 iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003621 if (UNLIKELY(iftable.get() == NULL)) {
3622 CHECK(self->IsExceptionPending()); // OOME.
3623 return false;
3624 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003625 ifcount = idx;
3626 } else {
3627 CHECK_EQ(idx, ifcount);
3628 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003629 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003630
3631 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003632 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003633 return true;
3634 }
Jeff Hao88474b42013-10-23 16:24:40 -07003635 // Allocate imtable
3636 bool imtable_changed = false;
3637 SirtRef<mirror::ObjectArray<mirror::ArtMethod> > imtable(self, AllocArtMethodArray(self, kImtSize));
3638 if (UNLIKELY(imtable.get() == NULL)) {
3639 CHECK(self->IsExceptionPending()); // OOME.
3640 return false;
3641 }
Brian Carlstromea46f952013-07-30 01:26:50 -07003642 std::vector<mirror::ArtMethod*> miranda_list;
Mathieu Chartier590fee92013-09-13 13:46:47 -07003643 MethodHelper vtable_mh(NULL);
3644 MethodHelper interface_mh(NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003645 for (size_t i = 0; i < ifcount; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003646 mirror::Class* interface = iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003647 size_t num_methods = interface->NumVirtualMethods();
3648 if (num_methods > 0) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003649 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3650 method_array(self, AllocArtMethodArray(self, num_methods));
3651 if (UNLIKELY(method_array.get() == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003652 CHECK(self->IsExceptionPending()); // OOME.
3653 return false;
3654 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003655 iftable->SetMethodArray(i, method_array.get());
3656 SirtRef<mirror::ObjectArray<mirror::ArtMethod> > vtable(self,
3657 klass->GetVTableDuringLinking());
Ian Rogers62d6c772013-02-27 08:32:07 -08003658 for (size_t j = 0; j < num_methods; ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003659 mirror::ArtMethod* interface_method = interface->GetVirtualMethod(j);
Ian Rogers9bc81912012-10-11 21:43:36 -07003660 interface_mh.ChangeMethod(interface_method);
3661 int32_t k;
3662 // For each method listed in the interface's method list, find the
3663 // matching method in our class's method list. We want to favor the
3664 // subclass over the superclass, which just requires walking
3665 // back from the end of the vtable. (This only matters if the
3666 // superclass defines a private method and this class redefines
3667 // it -- otherwise it would use the same vtable slot. In .dex files
3668 // those don't end up in the virtual method table, so it shouldn't
3669 // matter which direction we go. We walk it backward anyway.)
3670 for (k = vtable->GetLength() - 1; k >= 0; --k) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003671 mirror::ArtMethod* vtable_method = vtable->Get(k);
Ian Rogers9bc81912012-10-11 21:43:36 -07003672 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003673 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Elliott Hughes68243612013-02-22 17:16:07 -08003674 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003675 ThrowIllegalAccessError(klass.get(),
3676 "Method '%s' implementing interface method '%s' is not public",
3677 PrettyMethod(vtable_method).c_str(),
3678 PrettyMethod(interface_method).c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07003679 return false;
3680 }
3681 method_array->Set(j, vtable_method);
Jeff Hao88474b42013-10-23 16:24:40 -07003682 // Place method in imt if entry is empty, place conflict otherwise.
3683 uint32_t imt_index = interface_method->GetDexMethodIndex() % kImtSize;
3684 if (imtable->Get(imt_index) == NULL) {
3685 imtable->Set(imt_index, vtable_method);
3686 imtable_changed = true;
3687 } else {
3688 imtable->Set(imt_index, Runtime::Current()->GetImtConflictMethod());
3689 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003690 break;
3691 }
3692 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003693 if (k < 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003694 SirtRef<mirror::ArtMethod> miranda_method(self, NULL);
Ian Rogers9bc81912012-10-11 21:43:36 -07003695 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003696 mirror::ArtMethod* mir_method = miranda_list[mir];
Ian Rogers9bc81912012-10-11 21:43:36 -07003697 vtable_mh.ChangeMethod(mir_method);
3698 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3699 miranda_method.reset(miranda_list[mir]);
3700 break;
3701 }
3702 }
3703 if (miranda_method.get() == NULL) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003704 // Point the interface table at a phantom slot.
Brian Carlstromea46f952013-07-30 01:26:50 -07003705 miranda_method.reset(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003706 if (UNLIKELY(miranda_method.get() == NULL)) {
3707 CHECK(self->IsExceptionPending()); // OOME.
3708 return false;
3709 }
Ian Rogersa436fde2013-08-27 23:34:06 -07003710 // TODO: If a methods move then the miranda_list may hold stale references.
Ian Rogers9bc81912012-10-11 21:43:36 -07003711 miranda_list.push_back(miranda_method.get());
3712 }
3713 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003714 }
3715 }
3716 }
3717 }
Jeff Hao88474b42013-10-23 16:24:40 -07003718 if (imtable_changed) {
3719 // Fill in empty entries in interface method table with conflict.
3720 mirror::ArtMethod* imt_conflict_method = Runtime::Current()->GetImtConflictMethod();
3721 for (size_t i = 0; i < kImtSize; i++) {
3722 if (imtable->Get(i) == NULL) {
3723 imtable->Set(i, imt_conflict_method);
3724 }
3725 }
3726 klass->SetImTable(imtable.get());
3727 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003728 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003729 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003730 int new_method_count = old_method_count + miranda_list.size();
Ian Rogersa436fde2013-08-27 23:34:06 -07003731 mirror::ObjectArray<mirror::ArtMethod>* virtuals;
3732 if (old_method_count == 0) {
3733 virtuals = AllocArtMethodArray(self, new_method_count);
3734 } else {
3735 virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count);
3736 }
3737 if (UNLIKELY(virtuals == NULL)) {
3738 CHECK(self->IsExceptionPending()); // OOME.
3739 return false;
3740 }
3741 klass->SetVirtualMethods(virtuals);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003742
Brian Carlstromea46f952013-07-30 01:26:50 -07003743 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003744 vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003745 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003746 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003747 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003748 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003749 if (UNLIKELY(vtable.get() == NULL)) {
3750 CHECK(self->IsExceptionPending()); // OOME.
3751 return false;
3752 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003753 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003754 mirror::ArtMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003755 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003756 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3757 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3758 klass->SetVirtualMethod(old_method_count + i, method);
3759 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003760 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003761 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003762 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003763 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003764
Brian Carlstromea46f952013-07-30 01:26:50 -07003765 mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003766 for (int i = 0; i < vtable->GetLength(); ++i) {
3767 CHECK(vtable->Get(i) != NULL);
3768 }
3769
3770// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3771
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003772 return true;
3773}
3774
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003775bool ClassLinker::LinkInstanceFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003776 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003777 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003778}
3779
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003780bool ClassLinker::LinkStaticFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003781 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003782 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003783 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003784 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003785 return success;
3786}
3787
Brian Carlstromdbc05252011-09-09 01:59:59 -07003788struct LinkFieldsComparator {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003789 explicit LinkFieldsComparator() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
3790 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003791 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Brian Carlstromea46f952013-07-30 01:26:50 -07003792 bool operator()(const mirror::ArtField* field1, const mirror::ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003793 NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003794 // First come reference fields, then 64-bit, and finally 32-bit
Mathieu Chartier590fee92013-09-13 13:46:47 -07003795 FieldHelper fh1(field1);
3796 Primitive::Type type1 = fh1.GetTypeAsPrimitiveType();
3797 FieldHelper fh2(field2);
3798 Primitive::Type type2 = fh2.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003799 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3800 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3801 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3802 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003803 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3804 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3805 if (order1 != order2) {
3806 return order1 < order2;
3807 }
3808
3809 // same basic group? then sort by string.
Mathieu Chartier590fee92013-09-13 13:46:47 -07003810 const char* name1 = fh1.GetName();
3811 const char* name2 = fh2.GetName();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003812 return strcmp(name1, name2) < 0;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003813 }
3814};
3815
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003816bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003817 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003818 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003819
Brian Carlstromea46f952013-07-30 01:26:50 -07003820 mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003821 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003822
3823 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003824 size_t size;
3825 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003826 if (is_static) {
3827 size = klass->GetClassSize();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003828 field_offset = mirror::Class::FieldsOffset();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003829 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003830 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003831 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003832 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003833 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003834 }
3835 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003836 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003837
Brian Carlstromdbc05252011-09-09 01:59:59 -07003838 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003839
Brian Carlstromdbc05252011-09-09 01:59:59 -07003840 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003841 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromea46f952013-07-30 01:26:50 -07003842 std::deque<mirror::ArtField*> grouped_and_sorted_fields;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003843 for (size_t i = 0; i < num_fields; i++) {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003844 mirror::ArtField* f = fields->Get(i);
3845 CHECK(f != NULL);
3846 grouped_and_sorted_fields.push_back(f);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003847 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003848 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
3849 LinkFieldsComparator());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003850
3851 // References should be at the front.
3852 size_t current_field = 0;
3853 size_t num_reference_fields = 0;
3854 for (; current_field < num_fields; current_field++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003855 mirror::ArtField* field = grouped_and_sorted_fields.front();
Mathieu Chartier590fee92013-09-13 13:46:47 -07003856 FieldHelper fh(field);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003857 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003858 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003859 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003860 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003861 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003862 grouped_and_sorted_fields.pop_front();
3863 num_reference_fields++;
3864 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003865 field->SetOffset(field_offset);
3866 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003867 }
3868
3869 // Now we want to pack all of the double-wide fields together. If
3870 // we're not aligned, though, we want to shuffle one 32-bit field
3871 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003872 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003873 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003874 mirror::ArtField* field = grouped_and_sorted_fields[i];
Mathieu Chartier590fee92013-09-13 13:46:47 -07003875 FieldHelper fh(field);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003876 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003877 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3878 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003879 continue;
3880 }
3881 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003882 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003883 // drop the consumed field
3884 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3885 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003886 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003887 // whether we found a 32-bit field for padding or not, we advance
3888 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003889 }
3890
3891 // Alignment is good, shuffle any double-wide fields forward, and
3892 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003893 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003894 while (!grouped_and_sorted_fields.empty()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003895 mirror::ArtField* field = grouped_and_sorted_fields.front();
Brian Carlstromdbc05252011-09-09 01:59:59 -07003896 grouped_and_sorted_fields.pop_front();
Mathieu Chartier590fee92013-09-13 13:46:47 -07003897 FieldHelper fh(field);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003898 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003899 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003900 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003901 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003902 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003903 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003904 ? sizeof(uint64_t)
3905 : sizeof(uint32_t)));
3906 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003907 }
3908
Elliott Hughesadb460d2011-10-05 17:02:34 -07003909 // 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 -07003910 if (!is_static &&
Mathieu Chartier590fee92013-09-13 13:46:47 -07003911 (strcmp("Ljava/lang/ref/Reference;", ClassHelper(klass.get()).GetDescriptor()) == 0)) {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003912 // We know there are no non-reference fields in the Reference classes, and we know
3913 // that 'referent' is alphabetically last, so this is easy...
3914 CHECK_EQ(num_reference_fields, num_fields);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003915 FieldHelper fh(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003916 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003917 --num_reference_fields;
3918 }
3919
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003920 if (kIsDebugBuild) {
3921 // Make sure that all reference fields appear before
3922 // non-reference fields, and all double-wide fields are aligned.
3923 bool seen_non_ref = false;
3924 for (size_t i = 0; i < num_fields; i++) {
3925 mirror::ArtField* field = fields->Get(i);
3926 if (false) { // enable to debug field layout
3927 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
3928 << " class=" << PrettyClass(klass.get())
3929 << " field=" << PrettyField(field)
3930 << " offset=" << field->GetField32(MemberOffset(mirror::ArtField::OffsetOffset()),
3931 false);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003932 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003933 FieldHelper fh(field);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003934 Primitive::Type type = fh.GetTypeAsPrimitiveType();
3935 bool is_primitive = type != Primitive::kPrimNot;
Mathieu Chartier590fee92013-09-13 13:46:47 -07003936 if ((strcmp("Ljava/lang/ref/Reference;", ClassHelper(klass.get()).GetDescriptor()) == 0)
Ian Rogersdfb325e2013-10-30 01:00:44 -07003937 && (strcmp("referent", fh.GetName()) == 0)) {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003938 is_primitive = true; // We lied above, so we have to expect a lie here.
3939 }
3940 if (is_primitive) {
3941 if (!seen_non_ref) {
3942 seen_non_ref = true;
3943 DCHECK_EQ(num_reference_fields, i);
3944 }
3945 } else {
3946 DCHECK(!seen_non_ref);
3947 }
3948 }
3949 if (!seen_non_ref) {
3950 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003951 }
3952 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003953 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003954 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003955 if (is_static) {
3956 klass->SetNumReferenceStaticFields(num_reference_fields);
3957 klass->SetClassSize(size);
3958 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003959 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003960 if (!klass->IsVariableSize()) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003961 DCHECK_GE(size, sizeof(mirror::Object)) << ClassHelper(klass.get()).GetDescriptor();
Mathieu Chartier79b4f382013-10-23 15:21:37 -07003962 size_t previous_size = klass->GetObjectSize();
3963 if (previous_size != 0) {
3964 // Make sure that we didn't originally have an incorrect size.
3965 CHECK_EQ(previous_size, size);
3966 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003967 klass->SetObjectSize(size);
3968 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003969 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003970 return true;
3971}
3972
3973// Set the bitmap of reference offsets, refOffsets, from the ifields
3974// list.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003975void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003976 uint32_t reference_offsets = 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003977 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003978 if (super_class != NULL) {
3979 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003980 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003981 if (reference_offsets == CLASS_WALK_SUPER) {
3982 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003983 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003984 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003985 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003986 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003987}
3988
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003989void ClassLinker::CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003990 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003991}
3992
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003993void ClassLinker::CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003994 uint32_t reference_offsets) {
3995 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003996 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3997 : klass->NumReferenceInstanceFieldsDuringLinking();
Brian Carlstromea46f952013-07-30 01:26:50 -07003998 const mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003999 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07004000 // All of the fields that contain object references are guaranteed
4001 // to be at the beginning of the fields list.
4002 for (size_t i = 0; i < num_reference_fields; ++i) {
4003 // Note that byte_offset is the offset from the beginning of
4004 // object, not the offset into instance data
Brian Carlstromea46f952013-07-30 01:26:50 -07004005 const mirror::ArtField* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004006 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004007 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
4008 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
4009 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07004010 CHECK_NE(new_bit, 0U);
4011 reference_offsets |= new_bit;
4012 } else {
4013 reference_offsets = CLASS_WALK_SUPER;
4014 break;
4015 }
4016 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004017 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004018 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004019 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004020 } else {
4021 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004022 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004023}
4024
Mathieu Chartier590fee92013-09-13 13:46:47 -07004025mirror::String* ClassLinker::ResolveString(const DexFile& dex_file, uint32_t string_idx,
4026 SirtRef<mirror::DexCache>& dex_cache) {
4027 DCHECK(dex_cache.get() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004028 mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004029 if (resolved != NULL) {
4030 return resolved;
4031 }
Ian Rogersdfb325e2013-10-30 01:00:44 -07004032 uint32_t utf16_length;
4033 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004034 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004035 dex_cache->SetResolvedString(string_idx, string);
4036 return string;
4037}
4038
Mathieu Chartier590fee92013-09-13 13:46:47 -07004039mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
4040 const mirror::Class* referrer) {
4041 Thread* self = Thread::Current();
4042 SirtRef<mirror::DexCache> dex_cache(self, referrer->GetDexCache());
4043 SirtRef<mirror::ClassLoader> class_loader(self, referrer->GetClassLoader());
4044 return ResolveType(dex_file, type_idx, dex_cache, class_loader);
4045}
4046
4047mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
4048 SirtRef<mirror::DexCache>& dex_cache,
4049 SirtRef<mirror::ClassLoader>& class_loader) {
4050 DCHECK(dex_cache.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004051 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004052 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07004053 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07004054 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004055 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05004056 // TODO: we used to throw here if resolved's class loader was not the
4057 // boot class loader. This was to permit different classes with the
4058 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004059 dex_cache->SetResolvedType(type_idx, resolved);
4060 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004061 Thread* self = Thread::Current();
4062 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08004063 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08004064 // Convert a ClassNotFoundException to a NoClassDefFoundError.
4065 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
4066 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
jeffhao8cd6dda2012-02-22 10:15:34 -08004067 Thread::Current()->ClearException();
4068 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Ian Rogers62d6c772013-02-27 08:32:07 -08004069 self->GetException(NULL)->SetCause(cause.get());
jeffhao8cd6dda2012-02-22 10:15:34 -08004070 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004071 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004072 }
Brian Carlstromabcf7ae2013-09-23 22:19:52 -07004073 DCHECK((resolved == NULL) || resolved->IsResolved() || resolved->IsErroneous())
4074 << PrettyDescriptor(resolved) << " " << resolved->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004075 return resolved;
4076}
4077
Brian Carlstromea46f952013-07-30 01:26:50 -07004078mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
Ian Rogersd91d6d62013-09-25 20:26:14 -07004079 uint32_t method_idx,
Mathieu Chartier590fee92013-09-13 13:46:47 -07004080 SirtRef<mirror::DexCache>& dex_cache,
4081 SirtRef<mirror::ClassLoader>& class_loader,
Ian Rogersd91d6d62013-09-25 20:26:14 -07004082 const mirror::ArtMethod* referrer,
4083 InvokeType type) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004084 DCHECK(dex_cache.get() != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07004085 // Check for hit in the dex cache.
Brian Carlstromea46f952013-07-30 01:26:50 -07004086 mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07004087 if (resolved != NULL && !resolved->IsRuntimeMethod()) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004088 return resolved;
4089 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004090 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004091 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004092 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004093 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07004094 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004095 return NULL;
4096 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004097 // Scan using method_idx, this saves string compares but will only hit for matching dex
4098 // caches/files.
4099 switch (type) {
4100 case kDirect: // Fall-through.
4101 case kStatic:
Mathieu Chartier590fee92013-09-13 13:46:47 -07004102 resolved = klass->FindDirectMethod(dex_cache.get(), method_idx);
Ian Rogers08f753d2012-08-24 14:35:25 -07004103 break;
4104 case kInterface:
Mathieu Chartier590fee92013-09-13 13:46:47 -07004105 resolved = klass->FindInterfaceMethod(dex_cache.get(), method_idx);
Ian Rogers4c5b2652012-12-15 21:36:16 -08004106 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07004107 break;
4108 case kSuper: // Fall-through.
4109 case kVirtual:
Mathieu Chartier590fee92013-09-13 13:46:47 -07004110 resolved = klass->FindVirtualMethod(dex_cache.get(), method_idx);
Ian Rogers08f753d2012-08-24 14:35:25 -07004111 break;
4112 default:
4113 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004114 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004115 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07004116 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004117 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07004118 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07004119 switch (type) {
4120 case kDirect: // Fall-through.
4121 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08004122 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004123 break;
4124 case kInterface:
4125 resolved = klass->FindInterfaceMethod(name, signature);
Ian Rogers4c5b2652012-12-15 21:36:16 -08004126 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07004127 break;
4128 case kSuper: // Fall-through.
4129 case kVirtual:
4130 resolved = klass->FindVirtualMethod(name, signature);
4131 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004132 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004133 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004134 if (resolved != NULL) {
4135 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07004136 if (resolved->CheckIncompatibleClassChange(type)) {
4137 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07004138 }
4139 }
4140 if (resolved != NULL) {
4141 // Be a good citizen and update the dex cache to speed subsequent calls.
4142 dex_cache->SetResolvedMethod(method_idx, resolved);
4143 return resolved;
4144 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07004145 // We failed to find the method which means either an access error, an incompatible class
4146 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07004147 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07004148 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07004149 switch (type) {
4150 case kDirect:
4151 case kStatic:
4152 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07004153 break;
4154 case kInterface:
4155 case kVirtual:
4156 case kSuper:
4157 resolved = klass->FindDirectMethod(name, signature);
4158 break;
4159 }
4160
4161 // If we found something, check that it can be accessed by the referrer.
4162 if (resolved != NULL && referrer != NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004163 mirror::Class* methods_class = resolved->GetDeclaringClass();
4164 mirror::Class* referring_class = referrer->GetDeclaringClass();
jeffhaoc0228b82012-08-29 18:15:05 -07004165 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07004166 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
4167 referrer, resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07004168 return NULL;
4169 } else if (!referring_class->CanAccessMember(methods_class,
4170 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07004171 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07004172 return NULL;
4173 }
4174 }
4175
4176 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
4177 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
4178 switch (type) {
4179 case kDirect:
4180 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07004181 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004182 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004183 } else {
4184 resolved = klass->FindInterfaceMethod(name, signature);
4185 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004186 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004187 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004188 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004189 }
4190 }
4191 break;
4192 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07004193 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004194 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004195 } else {
4196 resolved = klass->FindVirtualMethod(name, signature);
4197 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004198 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004199 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004200 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004201 }
4202 }
4203 break;
4204 case kSuper:
Ian Rogers62d6c772013-02-27 08:32:07 -08004205 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004206 break;
4207 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07004208 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004209 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004210 } else {
4211 resolved = klass->FindInterfaceMethod(name, signature);
4212 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004213 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004214 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004215 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004216 }
4217 }
4218 break;
4219 }
4220 DCHECK(Thread::Current()->IsExceptionPending());
4221 return NULL;
4222 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004223}
4224
Mathieu Chartier590fee92013-09-13 13:46:47 -07004225mirror::ArtField* ClassLinker::ResolveField(const DexFile& dex_file, uint32_t field_idx,
4226 SirtRef<mirror::DexCache>& dex_cache,
4227 SirtRef<mirror::ClassLoader>& class_loader,
Brian Carlstrome8104522013-10-15 21:56:36 -07004228 bool is_static) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004229 DCHECK(dex_cache.get() != nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -07004230 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004231 if (resolved != NULL) {
4232 return resolved;
4233 }
4234 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004235 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004236 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08004237 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004238 return NULL;
4239 }
4240
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004241 if (is_static) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004242 resolved = klass->FindStaticField(dex_cache.get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004243 } else {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004244 resolved = klass->FindInstanceField(dex_cache.get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004245 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004246
4247 if (resolved == NULL) {
4248 const char* name = dex_file.GetFieldName(field_id);
4249 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
4250 if (is_static) {
4251 resolved = klass->FindStaticField(name, type);
4252 } else {
4253 resolved = klass->FindInstanceField(name, type);
4254 }
4255 if (resolved == NULL) {
4256 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
4257 return NULL;
4258 }
Ian Rogersb067ac22011-12-13 18:05:09 -08004259 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004260 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08004261 return resolved;
4262}
4263
Brian Carlstromea46f952013-07-30 01:26:50 -07004264mirror::ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004265 uint32_t field_idx,
Mathieu Chartier590fee92013-09-13 13:46:47 -07004266 SirtRef<mirror::DexCache>& dex_cache,
4267 SirtRef<mirror::ClassLoader>& class_loader) {
4268 DCHECK(dex_cache.get() != nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -07004269 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Ian Rogersb067ac22011-12-13 18:05:09 -08004270 if (resolved != NULL) {
4271 return resolved;
4272 }
4273 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004274 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Ian Rogersb067ac22011-12-13 18:05:09 -08004275 if (klass == NULL) {
4276 DCHECK(Thread::Current()->IsExceptionPending());
4277 return NULL;
4278 }
4279
Ian Rogersdfb325e2013-10-30 01:00:44 -07004280 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
4281 StringPiece type(dex_file.StringDataByIdx(
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004282 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
Ian Rogersb067ac22011-12-13 18:05:09 -08004283 resolved = klass->FindField(name, type);
4284 if (resolved != NULL) {
4285 dex_cache->SetResolvedField(field_idx, resolved);
4286 } else {
4287 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004288 }
4289 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07004290}
4291
Brian Carlstromea46f952013-07-30 01:26:50 -07004292const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004293 uint32_t* length) {
4294 mirror::Class* declaring_class = referrer->GetDeclaringClass();
4295 mirror::DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07004296 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07004297 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08004298 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07004299}
4300
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004301void ClassLinker::DumpAllClasses(int flags) {
4302 if (dex_cache_image_class_lookup_required_) {
4303 MoveImageClassesToClassTable();
4304 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004305 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
4306 // 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 -08004307 std::vector<mirror::Class*> all_classes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004308 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004309 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004310 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07004311 all_classes.push_back(it.second);
Ian Rogers5d76c432011-10-31 21:42:49 -07004312 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004313 }
4314
4315 for (size_t i = 0; i < all_classes.size(); ++i) {
4316 all_classes[i]->DumpClass(std::cerr, flags);
4317 }
4318}
4319
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004320void ClassLinker::DumpForSigQuit(std::ostream& os) {
4321 if (dex_cache_image_class_lookup_required_) {
4322 MoveImageClassesToClassTable();
4323 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004324 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004325 os << "Loaded classes: " << class_table_.size() << " allocated classes\n";
Elliott Hughescac6cc72011-11-03 20:31:21 -07004326}
4327
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004328size_t ClassLinker::NumLoadedClasses() {
4329 if (dex_cache_image_class_lookup_required_) {
4330 MoveImageClassesToClassTable();
4331 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004332 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004333 return class_table_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07004334}
4335
Brian Carlstrom47d237a2011-10-18 15:08:33 -07004336pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07004337 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07004338}
4339
4340pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004341 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07004342}
4343
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004344void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004345 DCHECK(!init_done_);
4346
4347 DCHECK(klass != NULL);
4348 DCHECK(klass->GetClassLoader() == NULL);
4349
4350 DCHECK(class_roots_ != NULL);
4351 DCHECK(class_roots_->Get(class_root) == NULL);
4352 class_roots_->Set(class_root, klass);
4353}
4354
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004355} // namespace art