blob: e35b95c1e9c538d43f2c0187289684913e4a85cf [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"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080046#include "mirror/class.h"
47#include "mirror/class-inl.h"
48#include "mirror/class_loader.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070049#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080050#include "mirror/field-inl.h"
51#include "mirror/iftable-inl.h"
52#include "mirror/abstract_method.h"
53#include "mirror/abstract_method-inl.h"
54#include "mirror/object-inl.h"
55#include "mirror/object_array-inl.h"
56#include "mirror/proxy.h"
57#include "mirror/stack_trace_element.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080058#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080059#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070060#include "runtime.h"
Ian Rogers466bb252011-10-14 03:29:56 -070061#include "runtime_support.h"
Ian Rogersc928de92013-02-27 14:30:44 -080062#if defined(ART_USE_PORTABLE_COMPILER)
Brian Carlstrom3693c082013-07-12 09:48:25 -070063#include "runtime_support_llvm.h"
TDYa1275bb86012012-04-11 05:57:28 -070064#endif
Elliott Hughes4d0207c2011-10-03 19:14:34 -070065#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070066#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070067#include "sirt_ref.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070068#include "stack_indirect_reference_table.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070069#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070070#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070071#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080072#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070073#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070074
75namespace art {
76
Jeff Hao0aba0ba2013-06-03 14:49:28 -070077extern "C" void artInterpreterToQuickEntry(Thread* self, MethodHelper& mh,
78 const DexFile::CodeItem* code_item,
79 ShadowFrame* shadow_frame, JValue* result);
Jeff Hao16743632013-05-08 10:59:04 -070080
Ian Rogers00f7d0e2012-07-19 15:28:27 -070081static void ThrowNoClassDefFoundError(const char* fmt, ...)
82 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070083 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070084static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070085 va_list args;
86 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -080087 Thread* self = Thread::Current();
88 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
89 self->ThrowNewExceptionV(throw_location, "Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -080090 va_end(args);
91}
92
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080093static void ThrowEarlierClassFailure(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -070094 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -070095 // The class failed to initialize on a previous attempt, so we want to throw
96 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
97 // failed in verification, in which case v2 5.4.1 says we need to re-throw
98 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -070099 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
100 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
101 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700102
Elliott Hughes5c599942012-06-13 16:45:05 -0700103 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -0800104 Thread* self = Thread::Current();
105 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700106 if (c->GetVerifyErrorClass() != NULL) {
107 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800108 ClassHelper ve_ch(c->GetVerifyErrorClass());
Ian Rogers62d6c772013-02-27 08:32:07 -0800109 self->ThrowNewException(throw_location, ve_ch.GetDescriptor(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700110 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -0800111 self->ThrowNewException(throw_location, "Ljava/lang/NoClassDefFoundError;",
112 PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700113 }
114}
115
Ian Rogers62d6c772013-02-27 08:32:07 -0800116static void WrapExceptionInInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700117 Thread* self = Thread::Current();
118 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700119
120 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
121 CHECK(cause.get() != NULL);
122
123 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700124 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
125 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700126
Elliott Hughesa4f94742012-05-29 16:28:38 -0700127 // We only wrap non-Error exceptions; an Error can just be used as-is.
128 if (!is_error) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800129 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
130 self->ThrowNewWrappedException(throw_location, "Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700131 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700132}
133
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800134static size_t Hash(const char* s) {
135 // This is the java.lang.String hashcode for convenience, not interoperability.
136 size_t hash = 0;
137 for (; *s != '\0'; ++s) {
138 hash = hash * 31 + *s;
139 }
140 return hash;
141}
142
Elliott Hughes418d20f2011-09-22 14:00:39 -0700143const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700144 "Ljava/lang/Class;",
145 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700146 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700147 "[Ljava/lang/Object;",
148 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700149 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700150 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700151 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700152 "Ljava/lang/reflect/Field;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700153 "Ljava/lang/reflect/AbstractMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700154 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700155 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700156 "[Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700157 "[Ljava/lang/reflect/AbstractMethod;",
Ian Rogers4445a7e2012-10-05 17:19:13 -0700158 "[Ljava/lang/reflect/Field;",
159 "[Ljava/lang/reflect/Method;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700160 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800161 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800162 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700163 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700164 "Z",
165 "B",
166 "C",
167 "D",
168 "F",
169 "I",
170 "J",
171 "S",
172 "V",
173 "[Z",
174 "[B",
175 "[C",
176 "[D",
177 "[F",
178 "[I",
179 "[J",
180 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700181 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700182};
183
Brian Carlstroma004aa92012-02-08 18:05:09 -0800184ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
185 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700186 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800187 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800188 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700189 return class_linker.release();
190}
191
Brian Carlstroma004aa92012-02-08 18:05:09 -0800192ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800193 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700194 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700195 return class_linker.release();
196}
197
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800198ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700199 // dex_lock_ is recursive as it may be used in stack dumping.
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700200 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700201 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700202 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700203 init_done_(false),
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700204 is_dirty_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700205 intern_table_(intern_table),
206 portable_resolution_trampoline_(NULL),
207 quick_resolution_trampoline_(NULL) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700208 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700209}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700210
Brian Carlstroma004aa92012-02-08 18:05:09 -0800211void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
212 VLOG(startup) << "ClassLinker::Init";
213 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700214
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700215 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700216
Elliott Hughes30646832011-10-13 16:59:46 -0700217 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700218 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700219 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800220 SirtRef<mirror::Class>
221 java_lang_Class(self,
222 down_cast<mirror::Class*>(heap->AllocObject(self, NULL,
223 sizeof(mirror::ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700224 CHECK(java_lang_Class.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800225 mirror::Class::SetClassClass(java_lang_Class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700226 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800227 java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
228 // AllocClass(mirror::Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700229
Elliott Hughes418d20f2011-09-22 14:00:39 -0700230 // Class[] is used for reflection support.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800231 SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700232 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700233
Ian Rogers23435d02012-09-24 11:23:12 -0700234 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800235 SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700236 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700237 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700238 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800239 java_lang_Object->SetStatus(mirror::Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700240
Ian Rogers23435d02012-09-24 11:23:12 -0700241 // Object[] next to hold class roots.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800242 SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700243 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700244
Ian Rogers23435d02012-09-24 11:23:12 -0700245 // Setup the char class to be used for char[].
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800246 SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700247
Ian Rogers23435d02012-09-24 11:23:12 -0700248 // Setup the char[] class to be used for String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800249 SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700250 char_array_class->SetComponentType(char_class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800251 mirror::CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700252
Ian Rogers23435d02012-09-24 11:23:12 -0700253 // Setup String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800254 SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
255 mirror::String::SetClass(java_lang_String.get());
256 java_lang_String->SetObjectSize(sizeof(mirror::String));
257 java_lang_String->SetStatus(mirror::Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400258
Ian Rogers23435d02012-09-24 11:23:12 -0700259 // Create storage for root classes, save away our work so far (requires descriptors).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800260 class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700261 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700262 SetClassRoot(kJavaLangClass, java_lang_Class.get());
263 SetClassRoot(kJavaLangObject, java_lang_Object.get());
264 SetClassRoot(kClassArrayClass, class_array_class.get());
265 SetClassRoot(kObjectArrayClass, object_array_class.get());
266 SetClassRoot(kCharArrayClass, char_array_class.get());
267 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700268
269 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700270 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
271 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
272 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
273 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
274 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
275 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
276 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
277 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700278
Ian Rogers23435d02012-09-24 11:23:12 -0700279 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700280 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700281
Ian Rogers23435d02012-09-24 11:23:12 -0700282 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800283 SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700284 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800285 mirror::IntArray::SetArrayClass(int_array_class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700286 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700287
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700288 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700289
Ian Rogers52813c92012-10-11 11:50:38 -0700290 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800291 SirtRef<mirror::Class>
292 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700293 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800294 java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCacheClass));
295 java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700296
Mathieu Chartier66f19252012-09-18 08:57:04 -0700297 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800298 SirtRef<mirror::Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
299 sizeof(mirror::FieldClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700300 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800301 java_lang_reflect_Field->SetObjectSize(sizeof(mirror::Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700302 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800303 java_lang_reflect_Field->SetStatus(mirror::Class::kStatusResolved);
304 mirror::Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700305
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800306 SirtRef<mirror::Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
307 sizeof(mirror::AbstractMethodClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700308 CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800309 java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(mirror::AbstractMethod));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700310 SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800311 java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700312
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800313 SirtRef<mirror::Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
314 sizeof(mirror::AbstractMethodClass)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700315 CHECK(java_lang_reflect_Constructor.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800316 java_lang_reflect_Constructor->SetObjectSize(sizeof(mirror::Constructor));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700317 java_lang_reflect_Constructor->SetSuperClass(java_lang_reflect_AbstractMethod.get());
318 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800319 java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700320
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800321 SirtRef<mirror::Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
322 sizeof(mirror::AbstractMethodClass)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700323 CHECK(java_lang_reflect_Method.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800324 java_lang_reflect_Method->SetObjectSize(sizeof(mirror::Method));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700325 java_lang_reflect_Method->SetSuperClass(java_lang_reflect_AbstractMethod.get());
326 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800327 java_lang_reflect_Method->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700328
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800329 mirror::AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(),
330 java_lang_reflect_Method.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700331
332 // Set up array classes for string, field, method
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800333 SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700334 object_array_string->SetComponentType(java_lang_String.get());
335 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
336
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800337 SirtRef<mirror::Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700338 object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
339 SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
340
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800341 SirtRef<mirror::Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700342 object_array_field->SetComponentType(java_lang_reflect_Field.get());
343 SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
344
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800345 SirtRef<mirror::Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700346 object_array_method->SetComponentType(java_lang_reflect_Method.get());
347 SetClassRoot(kJavaLangReflectMethodArrayClass, object_array_method.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700348
Ian Rogers23435d02012-09-24 11:23:12 -0700349 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
350 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
351 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700352 CHECK_NE(0U, boot_class_path.size());
353 for (size_t i = 0; i != boot_class_path.size(); ++i) {
354 const DexFile* dex_file = boot_class_path[i];
355 CHECK(dex_file != NULL);
356 AppendToBootClassPath(*dex_file);
357 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700358
359 // now we can use FindSystemClass
360
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700361 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700362 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700363 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700364
Mathieu Chartier66f19252012-09-18 08:57:04 -0700365 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800366 java_lang_Object->SetStatus(mirror::Class::kStatusNotReady);
367 mirror::Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700368 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800369 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
370 java_lang_String->SetStatus(mirror::Class::kStatusNotReady);
371 mirror::Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700372 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800373 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
374 java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady);
375 mirror::Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700376 CHECK_EQ(java_lang_String.get(), String_class);
377 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800378 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700379
Ian Rogers23435d02012-09-24 11:23:12 -0700380 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700381 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800382 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700383
384 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800385 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700386
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800387 mirror::Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700388 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700389
390 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800391 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700392
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800393 mirror::Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700394 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700395
396 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800397 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700398
399 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800400 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700401
402 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800403 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700404
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800405 mirror::Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700406 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700407
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800408 mirror::Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700409 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700410
Ian Rogers23435d02012-09-24 11:23:12 -0700411 // Setup the single, global copy of "iftable".
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800412 mirror::Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700413 CHECK(java_lang_Cloneable != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800414 mirror::Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700415 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700416 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
417 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700418 array_iftable_->SetInterface(0, java_lang_Cloneable);
419 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700420
Ian Rogers23435d02012-09-24 11:23:12 -0700421 // Sanity check Class[] and Object[]'s interfaces.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800422 ClassHelper kh(class_array_class.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -0700423 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
424 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800425 kh.ChangeClass(object_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700426 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
427 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers23435d02012-09-24 11:23:12 -0700428 // Run Class, Constructor, Field, and Method through FindSystemClass. This initializes their
429 // dex_cache_ fields and register them in classes_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800430 mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700431 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700432
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800433 java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusNotReady);
434 mirror::Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700435 CHECK_EQ(java_lang_reflect_AbstractMethod.get(), Abstract_method_class);
436
437 // Method extends AbstractMethod so must reset after.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800438 java_lang_reflect_Method->SetStatus(mirror::Class::kStatusNotReady);
439 mirror::Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700440 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
441
442 // Constructor extends AbstractMethod so must reset after.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800443 java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusNotReady);
444 mirror::Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700445 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700446
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800447 java_lang_reflect_Field->SetStatus(mirror::Class::kStatusNotReady);
448 mirror::Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700449 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700450
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800451 mirror::Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700452 CHECK_EQ(object_array_string.get(), String_array_class);
453
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800454 mirror::Class* Abstract_method_array_class =
Mathieu Chartier66f19252012-09-18 08:57:04 -0700455 FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
456 CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700457
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800458 mirror::Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700459 CHECK_EQ(object_array_field.get(), Field_array_class);
460
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800461 mirror::Class* Method_array_class =
Ian Rogers4445a7e2012-10-05 17:19:13 -0700462 FindSystemClass(class_roots_descriptors_[kJavaLangReflectMethodArrayClass]);
463 CHECK_EQ(object_array_method.get(), Method_array_class);
464
Ian Rogers23435d02012-09-24 11:23:12 -0700465 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700466
Ian Rogers23435d02012-09-24 11:23:12 -0700467 // Create java.lang.reflect.Proxy root.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800468 mirror::Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
Ian Rogers466bb252011-10-14 03:29:56 -0700469 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
470
Brian Carlstrom1f870082011-08-23 16:02:11 -0700471 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800472 mirror::Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700473 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800474 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700475 java_lang_ref_FinalizerReference->SetAccessFlags(
476 java_lang_ref_FinalizerReference->GetAccessFlags() |
477 kAccClassIsReference | kAccClassIsFinalizerReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800478 mirror::Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700479 java_lang_ref_PhantomReference->SetAccessFlags(
480 java_lang_ref_PhantomReference->GetAccessFlags() |
481 kAccClassIsReference | kAccClassIsPhantomReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800482 mirror::Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700483 java_lang_ref_SoftReference->SetAccessFlags(
484 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800485 mirror::Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700486 java_lang_ref_WeakReference->SetAccessFlags(
487 java_lang_ref_WeakReference->GetAccessFlags() |
488 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700489
Ian Rogers23435d02012-09-24 11:23:12 -0700490 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800491 mirror::Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
492 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700493 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
494
jeffhao8cd6dda2012-02-22 10:15:34 -0800495 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700496 // java.lang.StackTraceElement as a convenience.
Ian Rogers5167c972012-02-03 10:41:20 -0800497 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800498 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800499 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700500 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
501 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800502 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700503
Brian Carlstroma663ea52011-08-19 23:33:41 -0700504 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700505
Brian Carlstroma004aa92012-02-08 18:05:09 -0800506 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700507}
508
509void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800510 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700511
512 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700513 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700514 // as the types of the field can't be resolved prior to the runtime being
515 // fully initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800516 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
517 mirror::Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
518 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700519
Ian Rogers4445a7e2012-10-05 17:19:13 -0700520 const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800521
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800522 mirror::Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800523 FieldHelper fh(pendingNext, this);
524 CHECK_STREQ(fh.GetName(), "pendingNext");
525 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
526 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700527
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800528 mirror::Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800529 fh.ChangeField(queue);
530 CHECK_STREQ(fh.GetName(), "queue");
531 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
532 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700533
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800534 mirror::Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800535 fh.ChangeField(queueNext);
536 CHECK_STREQ(fh.GetName(), "queueNext");
537 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
538 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700539
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800540 mirror::Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800541 fh.ChangeField(referent);
542 CHECK_STREQ(fh.GetName(), "referent");
543 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
544 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700545
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800546 mirror::Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800547 fh.ChangeField(zombie);
548 CHECK_STREQ(fh.GetName(), "zombie");
549 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
550 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700551
Ian Rogers1d54e732013-05-02 21:10:01 -0700552 gc::Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800553 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700554 queue->GetOffset(),
555 queueNext->GetOffset(),
556 pendingNext->GetOffset(),
557 zombie->GetOffset());
558
Brian Carlstroma663ea52011-08-19 23:33:41 -0700559 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700560 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700561 ClassRoot class_root = static_cast<ClassRoot>(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800562 mirror::Class* klass = GetClassRoot(class_root);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700563 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700564 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700565 // note SetClassRoot does additional validation.
566 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700567 }
568
Elliott Hughes92f14b22011-10-06 12:29:54 -0700569 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700570
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700571 // disable the slow paths in FindClass and CreatePrimitiveClass now
572 // that Object, Class, and Object[] are setup
573 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700574
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800575 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700576}
577
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700578void ClassLinker::RunRootClinits() {
579 Thread* self = Thread::Current();
580 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800581 mirror::Class* c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700582 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700583 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700584 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700585 }
586 }
587}
588
Brian Carlstromd601af82012-01-06 10:15:19 -0800589bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
590 int oat_fd,
591 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800592 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700593 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800594 const char* dex2oat = dex2oat_string.c_str();
595
Brian Carlstroma004aa92012-02-08 18:05:09 -0800596 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800597
Ian Rogers1d54e732013-05-02 21:10:01 -0700598 gc::Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800599 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700600 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800601 const char* boot_image_option = boot_image_option_string.c_str();
602
603 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800604 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800605 const char* dex_file_option = dex_file_option_string.c_str();
606
Brian Carlstromd601af82012-01-06 10:15:19 -0800607 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800608 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800609 const char* oat_fd_option = oat_fd_option_string.c_str();
610
Brian Carlstroma004aa92012-02-08 18:05:09 -0800611 std::string oat_location_option_string("--oat-location=");
612 oat_location_option_string += oat_cache_filename;
613 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800614
jeffhao262bf462011-10-20 18:36:32 -0700615 // fork and exec dex2oat
616 pid_t pid = fork();
617 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800618 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800619
620 // change process groups, so we don't get reaped by ProcessManager
621 setpgid(0, 0);
622
jeffhao10037c82012-01-23 15:06:23 -0800623 VLOG(class_linker) << dex2oat
624 << " --runtime-arg -Xms64m"
625 << " --runtime-arg -Xmx64m"
626 << " --runtime-arg -classpath"
627 << " --runtime-arg " << class_path
Brian Carlstrom265091e2013-01-30 14:08:26 -0800628#if !defined(ART_TARGET)
629 << " --host"
630#endif
jeffhao10037c82012-01-23 15:06:23 -0800631 << " " << boot_image_option
632 << " " << dex_file_option
633 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800634 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800635
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800636 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700637 "--runtime-arg", "-Xms64m",
638 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500639 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800640 "--runtime-arg", class_path,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800641#if !defined(ART_TARGET)
642 "--host",
643#endif
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800644 boot_image_option,
645 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800646 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800647 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700648 NULL);
649
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800650 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800651 return false;
jeffhao262bf462011-10-20 18:36:32 -0700652 } else {
653 // wait for dex2oat to finish
654 int status;
655 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
656 if (got_pid != pid) {
657 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800658 return false;
jeffhao262bf462011-10-20 18:36:32 -0700659 }
660 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800661 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
662 return false;
jeffhao262bf462011-10-20 18:36:32 -0700663 }
664 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800665 return true;
jeffhao262bf462011-10-20 18:36:32 -0700666}
667
Brian Carlstrom866c8622012-01-06 16:35:13 -0800668void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700669 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800670 RegisterOatFileLocked(oat_file);
671}
672
673void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700674 dex_lock_.AssertExclusiveHeld(Thread::Current());
675 if (kIsDebugBuild) {
676 for (size_t i = 0; i < oat_files_.size(); ++i) {
677 CHECK_NE(&oat_file, oat_files_[i]) << oat_file.GetLocation();
678 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800679 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800680 oat_files_.push_back(&oat_file);
681}
682
Ian Rogers1d54e732013-05-02 21:10:01 -0700683OatFile* ClassLinker::OpenOat(const gc::space::ImageSpace* space) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700684 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700685 const Runtime* runtime = Runtime::Current();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700686 const ImageHeader& image_header = space->GetImageHeader();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800687 // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
688 // check the down cast
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800689 mirror::String* oat_location =
690 down_cast<mirror::String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700691 std::string oat_filename;
692 oat_filename += runtime->GetHostPrefix();
693 oat_filename += oat_location->ToModifiedUtf8();
Mathieu Chartierd8195f12012-10-05 12:21:28 -0700694 runtime->GetHeap()->UnReserveOatFileAddressRange();
Brian Carlstromf1d34552013-07-12 20:22:23 -0700695 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(),
696 !Runtime::Current()->IsCompiler());
Ian Rogers30fab402012-01-23 15:43:46 -0800697 VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700698 if (oat_file == NULL) {
Brian Carlstroma9f19782011-10-13 00:14:47 -0700699 LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700700 return NULL;
701 }
702 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
703 uint32_t image_oat_checksum = image_header.GetOatChecksum();
704 if (oat_checksum != image_oat_checksum) {
Brian Carlstrom866c8622012-01-06 16:35:13 -0800705 LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
Brian Carlstroma85b8372012-10-18 17:00:32 -0700706 << " to expected oat checksum " << std::hex << image_oat_checksum
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700707 << " in image";
708 return NULL;
709 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800710 RegisterOatFileLocked(*oat_file);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800711 VLOG(startup) << "ClassLinker::OpenOat exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700712 return oat_file;
713}
714
Brian Carlstromae826982011-11-09 01:33:42 -0800715const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700716 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800717 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800718}
719
Brian Carlstroma004aa92012-02-08 18:05:09 -0800720const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800721 for (size_t i = 0; i < oat_files_.size(); i++) {
722 const OatFile* oat_file = oat_files_[i];
723 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800724 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800725 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800726 return oat_file;
727 }
728 }
729 return NULL;
730}
731
Ian Rogerse3359f72013-06-11 15:14:11 -0700732const DexFile* ClassLinker::FindDexFileInOatLocation(const std::string& dex_location,
733 uint32_t dex_location_checksum,
734 const std::string& oat_location) {
Brian Carlstromf1d34552013-07-12 20:22:23 -0700735 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
736 !Runtime::Current()->IsCompiler()));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800737 if (oat_file.get() == NULL) {
738 return NULL;
739 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700740 Runtime* runtime = Runtime::Current();
741 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700742 if (oat_file->GetOatHeader().GetImageFileLocationOatChecksum() != image_header.GetOatChecksum()) {
743 return NULL;
744 }
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800745 if (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
746 != reinterpret_cast<uint32_t>(image_header.GetOatDataBegin())) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700747 return NULL;
748 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800749 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
750 if (oat_dex_file == NULL) {
751 return NULL;
752 }
753 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
754 return NULL;
755 }
Ian Rogerse3359f72013-06-11 15:14:11 -0700756 RegisterOatFileLocked(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800757 return oat_dex_file->OpenDexFile();
758}
759
760const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
761 const std::string& oat_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700762 WriterMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700763 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_location);
764}
765
766const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
767 const std::string& oat_location) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800768 uint32_t dex_location_checksum;
769 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
770 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
771 return NULL;
772 }
773
774 // Check if we already have an up-to-date output file
775 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
776 dex_location_checksum,
777 oat_location);
778 if (dex_file != NULL) {
779 return dex_file;
780 }
781
782 // Generate the output oat file for the dex file
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800783 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
784 if (file.get() == NULL) {
785 LOG(ERROR) << "Failed to create oat file: " << oat_location;
786 return NULL;
787 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700788 if (!GenerateOatFile(dex_location, file->Fd(), oat_location)) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800789 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
790 return NULL;
791 }
Brian Carlstromf1d34552013-07-12 20:22:23 -0700792 const OatFile* oat_file = OatFile::Open(oat_location, oat_location, NULL,
793 !Runtime::Current()->IsCompiler());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800794 if (oat_file == NULL) {
795 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
796 return NULL;
797 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700798 RegisterOatFileLocked(*oat_file);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800799 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
800 if (oat_dex_file == NULL) {
801 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
802 return NULL;
803 }
804 return oat_dex_file->OpenDexFile();
805}
806
Brian Carlstromafe25512012-06-27 17:02:58 -0700807bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
808 const std::string& dex_location,
809 uint32_t dex_location_checksum) {
810 Runtime* runtime = Runtime::Current();
811 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700812 uint32_t image_oat_checksum = image_header.GetOatChecksum();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800813 uint32_t image_oat_data_begin = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
Brian Carlstrom28db0122012-10-18 16:20:41 -0700814 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800815 && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700816
Brian Carlstromafe25512012-06-27 17:02:58 -0700817 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
818 if (oat_dex_file == NULL) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700819 LOG(ERROR) << "oat file " << oat_file->GetLocation()
Brian Carlstromafe25512012-06-27 17:02:58 -0700820 << " does not contain contents for " << dex_location;
821 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
822 for (size_t i = 0; i < oat_dex_files.size(); i++) {
823 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700824 LOG(ERROR) << "oat file " << oat_file->GetLocation()
Brian Carlstromafe25512012-06-27 17:02:58 -0700825 << " contains contents for " << oat_dex_file->GetDexFileLocation();
826 }
827 return false;
828 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700829 bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700830
Brian Carlstromafe25512012-06-27 17:02:58 -0700831 if (image_check && dex_check) {
832 return true;
833 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700834
Brian Carlstromafe25512012-06-27 17:02:58 -0700835 if (!image_check) {
836 std::string image_file(image_header.GetImageRoot(
837 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700838 LOG(WARNING) << "oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700839 << " mismatch ( " << std::hex << oat_file->GetOatHeader().GetImageFileLocationOatChecksum()
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800840 << ", " << oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700841 << ") with " << image_file
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800842 << " (" << image_oat_checksum << ", " << std::hex << image_oat_data_begin << ")";
Brian Carlstromafe25512012-06-27 17:02:58 -0700843 }
844 if (!dex_check) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700845 LOG(WARNING) << "oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700846 << " mismatch ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
847 << ") with " << dex_location
Brian Carlstromafe25512012-06-27 17:02:58 -0700848 << " (" << std::hex << dex_location_checksum << ")";
849 }
850 return false;
851}
852
853const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
854 const std::string& dex_location,
855 uint32_t dex_location_checksum) {
856 bool verified = VerifyOatFileChecksums(oat_file, dex_location, dex_location_checksum);
857 if (!verified) {
858 return NULL;
859 }
860 RegisterOatFileLocked(*oat_file);
861 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700862}
863
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800864const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700865 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800866
Brian Carlstroma004aa92012-02-08 18:05:09 -0800867 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800868 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800869 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800870 }
871
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700872 // Look for an existing file next to dex. for example, for
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700873 // /foo/bar/baz.jar, look for /foo/bar/baz.odex.
874 std::string odex_filename(OatFile::DexFilenameToOdexFilename(dex_location));
875 const OatFile* oat_file = FindOatFileFromOatLocationLocked(odex_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800876 if (oat_file != NULL) {
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700877 uint32_t dex_location_checksum;
878 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
879 // If no classes.dex found in dex_location, it has been stripped, assume oat is up-to-date.
880 // This is the common case in user builds for jar's and apk's in the /system directory.
881 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700882 CHECK(oat_dex_file != NULL) << odex_filename << " " << dex_location;
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700883 RegisterOatFileLocked(*oat_file);
884 return oat_dex_file->OpenDexFile();
885 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700886 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
887 dex_location,
888 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700889 if (dex_file != NULL) {
890 return dex_file;
891 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800892 }
Brian Carlstrom7675e162013-06-10 16:18:04 -0700893 // Look for an existing file in the dalvik-cache, validating the result if found
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700894 // not found in /foo/bar/baz.odex? try /data/dalvik-cache/foo@bar@baz.jar@classes.dex
895 std::string cache_location(GetDalvikCacheFilenameOrDie(dex_location));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700896 oat_file = FindOatFileFromOatLocationLocked(cache_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800897 if (oat_file != NULL) {
898 uint32_t dex_location_checksum;
899 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
900 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
901 return NULL;
902 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700903 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
904 dex_location,
905 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700906 if (dex_file != NULL) {
907 return dex_file;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700908 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800909 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700910 PLOG(FATAL) << "Failed to remove obsolete oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800911 }
jeffhao262bf462011-10-20 18:36:32 -0700912 }
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700913 LOG(INFO) << "Failed to open oat file from " << odex_filename << " or " << cache_location << ".";
Brian Carlstroma004aa92012-02-08 18:05:09 -0800914
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800915 // Try to generate oat file if it wasn't found or was obsolete.
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700916 std::string oat_cache_filename(GetDalvikCacheFilenameOrDie(dex_location));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700917 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700918}
919
Brian Carlstromae826982011-11-09 01:33:42 -0800920const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700921 for (size_t i = 0; i < oat_files_.size(); i++) {
922 const OatFile* oat_file = oat_files_[i];
923 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800924 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700925 return oat_file;
926 }
927 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700928 return NULL;
929}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700930
Brian Carlstromae826982011-11-09 01:33:42 -0800931const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700932 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700933 return FindOatFileFromOatLocationLocked(oat_location);
934}
935
936const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800937 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
938 if (oat_file != NULL) {
939 return oat_file;
940 }
941
Brian Carlstromf1d34552013-07-12 20:22:23 -0700942 oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700943 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800944 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700945 }
946 return oat_file;
947}
948
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700949void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800950 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700951 CHECK(!init_done_);
952
Ian Rogers1d54e732013-05-02 21:10:01 -0700953 gc::Heap* heap = Runtime::Current()->GetHeap();
954 gc::space::ImageSpace* space = heap->GetImageSpace();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700955 OatFile* oat_file = OpenOat(space);
956 CHECK(oat_file != NULL) << "Failed to open oat file for image";
Brian Carlstrom28db0122012-10-18 16:20:41 -0700957 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800958 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
Elliott Hughes74847412012-06-20 18:10:21 -0700959 CHECK(oat_file->GetOatHeader().GetImageFileLocation().empty());
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700960 portable_resolution_trampoline_ = oat_file->GetOatHeader().GetPortableResolutionTrampoline();
961 quick_resolution_trampoline_ = oat_file->GetOatHeader().GetQuickResolutionTrampoline();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800962 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
963 mirror::ObjectArray<mirror::DexCache>* dex_caches =
964 dex_caches_object->AsObjectArray<mirror::DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700965
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800966 mirror::ObjectArray<mirror::Class>* class_roots =
967 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>();
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -0700968 class_roots_ = class_roots;
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700969
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700970 // Special case of setting up the String class early so that we can test arbitrary objects
971 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -0700972 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800973
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700974 CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
975 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers1f539342012-10-03 21:09:42 -0700976 Thread* self = Thread::Current();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700977 for (int i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800978 SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700979 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
980 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800981 CHECK(oat_dex_file != NULL) << oat_file->GetLocation() << " " << dex_file_location;
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700982 const DexFile* dex_file = oat_dex_file->OpenDexFile();
983 if (dex_file == NULL) {
984 LOG(FATAL) << "Failed to open dex file " << dex_file_location
985 << " from within oat file " << oat_file->GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700986 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700987
988 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
989
990 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700991 }
992
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -0700993 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
994 // bitmap walk.
995 mirror::AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
996 GetClassRoot(kJavaLangReflectMethod));
997
Brian Carlstroma663ea52011-08-19 23:33:41 -0700998 // reinit clases_ table
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700999 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001000 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001001 heap->FlushAllocStack();
Mathieu Chartiere0f0cb32012-08-28 11:26:00 -07001002 heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001003 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001004
1005 // reinit class_roots_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001006 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001007 class_roots_ = class_roots;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001008
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001009 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001010 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1011 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001012 // String class root was set above
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001013 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001014 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1015 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1016 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1017 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1018 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1019 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1020 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1021 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1022 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1023 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001024
1025 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001026
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001027 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001028}
1029
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001030void ClassLinker::InitFromImageCallback(mirror::Object* obj, void* arg) {
Brian Carlstroma663ea52011-08-19 23:33:41 -07001031 DCHECK(obj != NULL);
1032 DCHECK(arg != NULL);
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001033 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001034
Elliott Hughesdbb40792011-11-18 17:05:22 -08001035 if (obj->GetClass()->IsStringClass()) {
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001036 class_linker->intern_table_->RegisterStrong(obj->AsString());
Brian Carlstromc74255f2011-09-11 22:47:39 -07001037 return;
1038 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001039 if (obj->IsClass()) {
1040 // restore class to ClassLinker::classes_ table
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001041 mirror::Class* klass = obj->AsClass();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001042 ClassHelper kh(klass, class_linker);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001043 mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001044 DCHECK(existing == NULL) << kh.GetDescriptor();
Brian Carlstroma663ea52011-08-19 23:33:41 -07001045 return;
1046 }
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001047
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001048 // Set entry points to interpreter for methods in interpreter only mode.
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001049 if (obj->IsMethod()) {
1050 mirror::AbstractMethod* method = obj->AsMethod();
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001051 if (Runtime::Current()->GetInstrumentation()->InterpretOnly() && !method->IsNative()) {
1052 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterEntry);
Jeff Haodd75d5d2013-06-07 16:43:14 -07001053 if (method != Runtime::Current()->GetResolutionMethod()) {
1054 method->SetEntryPointFromCompiledCode(GetInterpreterEntryPoint());
1055 }
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001056 }
1057 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001058}
1059
1060// Keep in sync with InitCallback. Anything we visit, we need to
1061// reinit references to when reinitializing a ClassLinker from a
1062// mapped image.
Ian Rogers1d54e732013-05-02 21:10:01 -07001063void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001064 visitor(class_roots_, arg);
Ian Rogers50b35e22012-10-04 10:09:15 -07001065 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001066 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001067 ReaderMutexLock mu(self, dex_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001068 for (size_t i = 0; i < dex_caches_.size(); i++) {
1069 visitor(dex_caches_[i], arg);
1070 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001071 }
1072
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001073 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001074 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001075 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001076 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001077 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001078 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001079
1080 // We deliberately ignore the class roots in the image since we
1081 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001082 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001083
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001084 visitor(array_iftable_, arg);
Ian Rogers1d54e732013-05-02 21:10:01 -07001085 if (clean_dirty) {
1086 is_dirty_ = false;
1087 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001088}
1089
Elliott Hughesa2155262011-11-16 16:26:58 -08001090void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001091 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -08001092 typedef Table::const_iterator It; // TODO: C++0x auto
1093 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
1094 if (!visitor(it->second, arg)) {
1095 return;
1096 }
1097 }
1098 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
1099 if (!visitor(it->second, arg)) {
1100 return;
1101 }
1102 }
1103}
1104
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001105static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1106 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001107 classes->insert(c);
1108 return true;
1109}
1110
1111void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001112 std::set<mirror::Class*> classes;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001113 VisitClasses(GetClassesVisitor, &classes);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001114 typedef std::set<mirror::Class*>::const_iterator It; // TODO: C++0x auto
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001115 for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
1116 if (!visitor(*it, arg)) {
1117 return;
1118 }
1119 }
1120}
1121
1122
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001123ClassLinker::~ClassLinker() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001124 mirror::Class::ResetClass();
1125 mirror::String::ResetClass();
1126 mirror::Field::ResetClass();
1127 mirror::AbstractMethod::ResetClasses();
1128 mirror::BooleanArray::ResetArrayClass();
1129 mirror::ByteArray::ResetArrayClass();
1130 mirror::CharArray::ResetArrayClass();
1131 mirror::DoubleArray::ResetArrayClass();
1132 mirror::FloatArray::ResetArrayClass();
1133 mirror::IntArray::ResetArrayClass();
1134 mirror::LongArray::ResetArrayClass();
1135 mirror::ShortArray::ResetArrayClass();
1136 mirror::Throwable::ResetClass();
1137 mirror::StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001138 STLDeleteElements(&boot_class_path_);
1139 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001140}
1141
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001142mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001143 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001144 mirror::Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
1145 SirtRef<mirror::DexCache> dex_cache(self,
1146 down_cast<mirror::DexCache*>(heap->AllocObject(self, dex_cache_class,
1147 dex_cache_class->GetObjectSize())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001148 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001149 return NULL;
1150 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001151 SirtRef<mirror::String>
1152 location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001153 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001154 return NULL;
1155 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001156 SirtRef<mirror::ObjectArray<mirror::String> >
1157 strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001158 if (strings.get() == NULL) {
1159 return NULL;
1160 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001161 SirtRef<mirror::ObjectArray<mirror::Class> >
1162 types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001163 if (types.get() == NULL) {
1164 return NULL;
1165 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001166 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07001167 methods(self, AllocAbstractMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001168 if (methods.get() == NULL) {
1169 return NULL;
1170 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001171 SirtRef<mirror::ObjectArray<mirror::Field> >
1172 fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001173 if (fields.get() == NULL) {
1174 return NULL;
1175 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001176 SirtRef<mirror::ObjectArray<mirror::StaticStorageBase> >
Ian Rogers50b35e22012-10-04 10:09:15 -07001177 initialized_static_storage(self,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001178 AllocObjectArray<mirror::StaticStorageBase>(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001179 if (initialized_static_storage.get() == NULL) {
1180 return NULL;
1181 }
1182
Mathieu Chartier66f19252012-09-18 08:57:04 -07001183 dex_cache->Init(&dex_file,
1184 location.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001185 strings.get(),
1186 types.get(),
1187 methods.get(),
1188 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001189 initialized_static_storage.get());
1190 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001191}
1192
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001193mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
1194 size_t class_size) {
1195 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07001196 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001197 SirtRef<mirror::Class> klass(self,
Ian Rogers50b35e22012-10-04 10:09:15 -07001198 heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001199 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001200 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001201 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001202}
1203
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001204mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001205 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001206}
1207
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001208mirror::Field* ClassLinker::AllocField(Thread* self) {
1209 return down_cast<mirror::Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001210}
1211
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001212mirror::Method* ClassLinker::AllocMethod(Thread* self) {
1213 return down_cast<mirror::Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001214}
1215
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001216mirror::Constructor* ClassLinker::AllocConstructor(Thread* self) {
1217 return down_cast<mirror::Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001218}
1219
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001220mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
1221 size_t length) {
1222 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(self,
1223 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1224 length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001225}
1226
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001227static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001228 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001229 DCHECK(klass != NULL);
1230 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001231 if (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers1f539342012-10-03 21:09:42 -07001232 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001233 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001234 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001235 ThrowClassCircularityError(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001236 klass->SetStatus(mirror::Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001237 return NULL;
1238 }
1239 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001240 while (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers05f30572013-02-20 12:13:11 -08001241 lock.WaitIgnoringInterrupts();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001242 }
1243 }
1244 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001245 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001246 return NULL;
1247 }
1248 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001249 CHECK(klass->IsResolved()) << PrettyClass(klass);
Ian Rogers62d6c772013-02-27 08:32:07 -08001250 self->AssertNoPendingException();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001251 return klass;
1252}
1253
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001254mirror::Class* ClassLinker::FindSystemClass(const char* descriptor) {
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001255 return FindClass(descriptor, NULL);
1256}
1257
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001258mirror::Class* ClassLinker::FindClass(const char* descriptor, mirror::ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001259 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001260 Thread* self = Thread::Current();
1261 DCHECK(self != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001262 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001263 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001264 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1265 // for primitive classes that aren't backed by dex files.
1266 return FindPrimitiveClass(descriptor[0]);
1267 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001268 // Find the class in the loaded classes table.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001269 mirror::Class* klass = LookupClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001270 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001271 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001272 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001273 // Class is not yet loaded.
1274 if (descriptor[0] == '[') {
1275 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001276
Jesse Wilson47daf872011-11-23 11:42:45 -05001277 } else if (class_loader == NULL) {
1278 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1279 if (pair.second != NULL) {
1280 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1281 }
1282
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001283 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001284 // first try the boot class path
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001285 mirror::Class* system_class = FindSystemClass(descriptor);
Jesse Wilson47daf872011-11-23 11:42:45 -05001286 if (system_class != NULL) {
1287 return system_class;
1288 }
1289 CHECK(self->IsExceptionPending());
1290 self->ClearException();
1291
1292 // next try the compile time class path
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001293 const std::vector<const DexFile*>* class_path;
1294 {
1295 ScopedObjectAccessUnchecked soa(Thread::Current());
1296 ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
1297 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1298 }
1299
1300 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001301 if (pair.second != NULL) {
1302 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001303 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001304
1305 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001306 ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1307 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
1308 soa.AddLocalReference<jobject>(class_loader));
Elliott Hughes95572412011-12-13 18:14:20 -08001309 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001310 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001311 {
1312 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001313 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1314 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001315 if (class_name_object.get() == NULL) {
1316 return NULL;
1317 }
1318 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001319 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1320 WellKnownClasses::java_lang_ClassLoader_loadClass,
1321 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001322 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001323 if (soa.Self()->IsExceptionPending()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001324 // If the ClassLoader threw, pass that exception up.
1325 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001326 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001327 // broken loader - throw NPE to be compatible with Dalvik
Ian Rogers62d6c772013-02-27 08:32:07 -08001328 ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1329 class_name_string.c_str()).c_str());
Ian Rogerscab01012012-01-10 17:35:46 -08001330 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001331 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001332 // success, return mirror::Class*
1333 return soa.Decode<mirror::Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001334 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001335 }
1336
Elliott Hughes82914b62012-04-09 15:56:29 -07001337 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001338 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001339}
1340
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001341mirror::Class* ClassLinker::DefineClass(const StringPiece& descriptor,
1342 mirror::ClassLoader* class_loader,
1343 const DexFile& dex_file,
1344 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001345 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001346 SirtRef<mirror::Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001347 // Load the class from the dex file.
1348 if (!init_done_) {
1349 // finish up init of hand crafted class_roots_
1350 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001351 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001352 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001353 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001354 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001355 klass.reset(GetClassRoot(kJavaLangString));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001356 } else if (descriptor == "Ljava/lang/DexCache;") {
1357 klass.reset(GetClassRoot(kJavaLangDexCache));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001358 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001359 klass.reset(GetClassRoot(kJavaLangReflectField));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001360 } else if (descriptor == "Ljava/lang/reflect/AbstractMethod;") {
1361 klass.reset(GetClassRoot(kJavaLangReflectAbstractMethod));
1362 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
1363 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001364 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001365 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001366 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001367 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001368 }
1369 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001370 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001371 }
1372 klass->SetDexCache(FindDexCache(dex_file));
1373 LoadClass(dex_file, dex_class_def, klass, class_loader);
1374 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001375 if (self->IsExceptionPending()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001376 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001377 return NULL;
1378 }
Ian Rogers1f539342012-10-03 21:09:42 -07001379 ObjectLock lock(self, klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001380 klass->SetClinitThreadId(self->GetTid());
1381 // Add the newly loaded class to the loaded classes table.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001382 SirtRef<mirror::Class> existing(self, InsertClass(descriptor, klass.get(), false));
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001383 if (existing.get() != NULL) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001384 // We failed to insert because we raced with another thread.
Ian Rogers50b35e22012-10-04 10:09:15 -07001385 return EnsureResolved(self, existing.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001386 }
1387 // Finish loading (if necessary) by finding parents
1388 CHECK(!klass->IsLoaded());
1389 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1390 // Loading failed.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001391 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001392 lock.NotifyAll();
1393 return NULL;
1394 }
1395 CHECK(klass->IsLoaded());
1396 // Link the class (if necessary)
1397 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001398 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001399 // Linking failed.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001400 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001401 lock.NotifyAll();
1402 return NULL;
1403 }
1404 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001405
1406 /*
1407 * We send CLASS_PREPARE events to the debugger from here. The
1408 * definition of "preparation" is creating the static fields for a
1409 * class and initializing them to the standard default values, but not
1410 * executing any code (that comes later, during "initialization").
1411 *
1412 * We did the static preparation in LinkClass.
1413 *
1414 * The class has been prepared and resolved but possibly not yet verified
1415 * at this point.
1416 */
1417 Dbg::PostClassPrepare(klass.get());
1418
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001419 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001420}
1421
Brian Carlstrom4873d462011-08-21 15:23:39 -07001422// Precomputes size that will be needed for Class, matching LinkStaticFields
1423size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1424 const DexFile::ClassDef& dex_class_def) {
1425 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001426 size_t num_ref = 0;
1427 size_t num_32 = 0;
1428 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001429 if (class_data != NULL) {
1430 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1431 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001432 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001433 char c = descriptor[0];
1434 if (c == 'L' || c == '[') {
1435 num_ref++;
1436 } else if (c == 'J' || c == 'D') {
1437 num_64++;
1438 } else {
1439 num_32++;
1440 }
1441 }
1442 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001443 // start with generic class data
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001444 size_t size = sizeof(mirror::Class);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001445 // follow with reference fields which must be contiguous at start
1446 size += (num_ref * sizeof(uint32_t));
1447 // if there are 64-bit fields to add, make sure they are aligned
1448 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
1449 if (num_32 != 0) {
1450 // use an available 32-bit field for padding
1451 num_32--;
1452 }
1453 size += sizeof(uint32_t); // either way, we are adding a word
1454 DCHECK_EQ(size, RoundUp(size, 8));
1455 }
1456 // tack on any 64-bit fields now that alignment is assured
1457 size += (num_64 * sizeof(uint64_t));
1458 // tack on any remaining 32-bit fields
1459 size += (num_32 * sizeof(uint32_t));
1460 return size;
1461}
1462
Ian Rogers19846512012-02-24 11:42:47 -08001463const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1464 DCHECK(descriptor != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001465 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1466 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1467 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1468 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1469 uint32_t class_def_index;
1470 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1471 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1472 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1473 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1474 return oat_class;
1475}
1476
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001477static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint32_t method_idx) {
1478 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1479 const DexFile::TypeId& type_id = dex_file.GetTypeId(method_id.class_idx_);
1480 const DexFile::ClassDef* class_def = dex_file.FindClassDef(dex_file.GetTypeDescriptor(type_id));
1481 CHECK(class_def != NULL);
1482 const byte* class_data = dex_file.GetClassData(*class_def);
1483 CHECK(class_data != NULL);
1484 ClassDataItemIterator it(dex_file, class_data);
1485 // Skip fields
1486 while (it.HasNextStaticField()) {
1487 it.Next();
1488 }
1489 while (it.HasNextInstanceField()) {
1490 it.Next();
1491 }
1492 // Process methods
1493 size_t class_def_method_index = 0;
1494 while (it.HasNextDirectMethod()) {
1495 if (it.GetMemberIndex() == method_idx) {
1496 return class_def_method_index;
1497 }
1498 class_def_method_index++;
1499 it.Next();
1500 }
1501 while (it.HasNextVirtualMethod()) {
1502 if (it.GetMemberIndex() == method_idx) {
1503 return class_def_method_index;
1504 }
1505 class_def_method_index++;
1506 it.Next();
1507 }
1508 DCHECK(!it.HasNext());
1509 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1510 return 0;
1511}
1512
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001513const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::AbstractMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001514 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001515 // method for direct methods (or virtual methods made direct).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001516 mirror::Class* declaring_class = method->GetDeclaringClass();
Ian Rogersfb6adba2012-03-04 21:51:51 -08001517 size_t oat_method_index;
1518 if (method->IsStatic() || method->IsDirect()) {
1519 // Simple case where the oat method index was stashed at load time.
1520 oat_method_index = method->GetMethodIndex();
1521 } else {
1522 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1523 // by search for its position in the declared virtual methods.
1524 oat_method_index = declaring_class->NumDirectMethods();
1525 size_t end = declaring_class->NumVirtualMethods();
1526 bool found = false;
1527 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001528 if (declaring_class->GetVirtualMethod(i) == method) {
1529 found = true;
1530 break;
1531 }
Ian Rogersf320b632012-03-13 18:47:47 -07001532 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001533 }
1534 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1535 }
1536 ClassHelper kh(declaring_class);
Ian Rogers19846512012-02-24 11:42:47 -08001537 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001538 CHECK(oat_class.get() != NULL);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001539 DCHECK_EQ(oat_method_index,
1540 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
1541 method->GetDexMethodIndex()));
1542
TDYa12785321912012-04-01 15:24:56 -07001543 return oat_class->GetOatMethod(oat_method_index);
1544}
1545
1546// Special case to get oat code without overwriting a trampoline.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001547const void* ClassLinker::GetOatCodeFor(const mirror::AbstractMethod* method) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001548 CHECK(!method->IsAbstract()) << PrettyMethod(method);
Ian Rogersf3e98552013-03-20 15:49:49 -07001549 const void* result = GetOatMethodFor(method).GetCode();
1550 if (result == NULL) {
1551 // No code? You must mean to go into the interpreter.
1552 result = GetInterpreterEntryPoint();
1553 }
1554 return result;
TDYa12785321912012-04-01 15:24:56 -07001555}
1556
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001557const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx) {
1558 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1559 const char* descriptor = dex_file.GetTypeDescriptor(dex_file.GetTypeId(method_id.class_idx_));
1560 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, method_idx);
1561 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, descriptor));
1562 CHECK(oat_class.get() != NULL);
1563 return oat_class->GetOatMethod(oat_method_idx).GetCode();
1564}
1565
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001566// Returns true if the method must run with interpreter, false otherwise.
1567static bool NeedsInterpreter(const mirror::AbstractMethod* method, const void* code) {
1568 if (code == NULL) {
1569 // No code: need interpreter.
1570 return true;
1571 }
1572 // If interpreter mode is enabled, every method (except native and proxy) must
1573 // be run with interpreter.
1574 return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
1575 !method->IsNative() && !method->IsProxyMethod();
1576}
1577
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001578void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001579 ClassHelper kh(klass);
1580 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1581 CHECK(dex_class_def != NULL);
1582 const DexFile& dex_file = kh.GetDexFile();
1583 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1584 if (class_data == NULL) {
1585 return; // no fields or methods - for example a marker interface
1586 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001587 Runtime* runtime = Runtime::Current();
1588 if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001589 // OAT file unavailable
1590 return;
1591 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001592 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1593 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001594 ClassDataItemIterator it(dex_file, class_data);
1595 // Skip fields
1596 while (it.HasNextStaticField()) {
1597 it.Next();
1598 }
1599 while (it.HasNextInstanceField()) {
1600 it.Next();
1601 }
Ian Rogers19846512012-02-24 11:42:47 -08001602 // Link the code of methods skipped by LinkCode
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001603 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
1604 mirror::AbstractMethod* method = klass->GetDirectMethod(method_index);
1605 if (!method->IsStatic()) {
1606 // Only update static methods.
1607 continue;
Ian Rogers19846512012-02-24 11:42:47 -08001608 }
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001609 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1610 const bool enter_interpreter = NeedsInterpreter(method, code);
1611 if (enter_interpreter) {
1612 // Use interpreter entry point.
1613 code = GetInterpreterEntryPoint();
1614 }
1615 runtime->GetInstrumentation()->UpdateMethodsCode(method, code);
Ian Rogers19846512012-02-24 11:42:47 -08001616 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001617 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08001618}
1619
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001620static void LinkCode(SirtRef<mirror::AbstractMethod>& method, const OatFile::OatClass* oat_class,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001621 uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001622 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001623 // Method shouldn't have already been linked.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001624 DCHECK(method->GetEntryPointFromCompiledCode() == NULL);
Brian Carlstrom92827a52011-10-10 15:50:01 -07001625 // Every kind of method should at least get an invoke stub from the oat_method.
1626 // non-abstract methods also get their code pointers.
1627 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstrom265091e2013-01-30 14:08:26 -08001628 oat_method.LinkMethod(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001629
Jeff Hao16743632013-05-08 10:59:04 -07001630 // Install entry point from interpreter.
Jeff Hao790ad902013-05-22 15:02:08 -07001631 Runtime* runtime = Runtime::Current();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001632 bool enter_interpreter = NeedsInterpreter(method.get(), method->GetEntryPointFromCompiledCode());
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001633 if (enter_interpreter) {
1634 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterEntry);
Jeff Hao16743632013-05-08 10:59:04 -07001635 } else {
1636 method->SetEntryPointFromInterpreter(artInterpreterToQuickEntry);
1637 }
1638
Brian Carlstrom92827a52011-10-10 15:50:01 -07001639 if (method->IsAbstract()) {
Jeff Haoaa4a7932013-05-13 11:28:27 -07001640 method->SetEntryPointFromCompiledCode(GetAbstractMethodErrorStub());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001641 return;
1642 }
Ian Rogers19846512012-02-24 11:42:47 -08001643
1644 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001645 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001646 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
1647 // after initializing class (see ClassLinker::InitializeClass method).
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001648 method->SetEntryPointFromCompiledCode(GetResolutionTrampoline(runtime->GetClassLinker()));
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001649 } else if (enter_interpreter) {
1650 // Set entry point from compiled code if there's no code or in interpreter only mode.
1651 method->SetEntryPointFromCompiledCode(GetInterpreterEntryPoint());
Ian Rogers0d6de042012-02-29 08:50:26 -08001652 }
jeffhao26c0a1a2012-01-17 16:28:33 -08001653
Ian Rogers62d6c772013-02-27 08:32:07 -08001654 if (method->IsNative()) {
1655 // Unregistering restores the dlsym lookup stub.
1656 method->UnregisterNative(Thread::Current());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001657 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001658
Ian Rogers62d6c772013-02-27 08:32:07 -08001659 // Allow instrumentation its chance to hijack code.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001660 runtime->GetInstrumentation()->UpdateMethodsCode(method.get(),
1661 method->GetEntryPointFromCompiledCode());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001662}
1663
Brian Carlstromf615a612011-07-23 12:50:34 -07001664void ClassLinker::LoadClass(const DexFile& dex_file,
1665 const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001666 SirtRef<mirror::Class>& klass,
1667 mirror::ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001668 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001669 CHECK(klass->GetDexCache() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001670 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001671 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001672 CHECK(descriptor != NULL);
1673
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001674 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001675 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001676 // Make sure that none of our runtime-only flags are set.
mikaelpeltier6ffd0962012-10-25 15:37:45 +02001677 // TODO: JACK CLASS ACCESS (HACK TO BE REMOVED)
1678 CHECK_EQ(access_flags & ~(kAccJavaFlagsMask | kAccClassJack), 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001679 klass->SetAccessFlags(access_flags);
1680 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001681 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001682 klass->SetStatus(mirror::Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001683
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001684 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001685
Ian Rogers0571d352011-11-03 19:51:38 -07001686 // Load fields fields.
1687 const byte* class_data = dex_file.GetClassData(dex_class_def);
1688 if (class_data == NULL) {
1689 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001690 }
Ian Rogers0571d352011-11-03 19:51:38 -07001691 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001692 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001693 if (it.NumStaticFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001694 klass->SetSFields(AllocFieldArray(self, it.NumStaticFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001695 }
1696 if (it.NumInstanceFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001697 klass->SetIFields(AllocFieldArray(self, it.NumInstanceFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001698 }
1699 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001700 SirtRef<mirror::Field> sfield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001701 klass->SetStaticField(i, sfield.get());
1702 LoadField(dex_file, it, klass, sfield);
1703 }
1704 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001705 SirtRef<mirror::Field> ifield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001706 klass->SetInstanceField(i, ifield.get());
1707 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001708 }
1709
Brian Carlstromf5822582012-03-19 22:34:31 -07001710 UniquePtr<const OatFile::OatClass> oat_class;
1711 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1712 oat_class.reset(GetOatClass(dex_file, descriptor));
1713 }
Ian Rogers19846512012-02-24 11:42:47 -08001714
Ian Rogers0571d352011-11-03 19:51:38 -07001715 // Load methods.
1716 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001717 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001718 klass->SetDirectMethods(AllocAbstractMethodArray(self, it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001719 }
Ian Rogers0571d352011-11-03 19:51:38 -07001720 if (it.NumVirtualMethods() != 0) {
1721 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001722 klass->SetVirtualMethods(AllocMethodArray(self, it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001723 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001724 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001725 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001726 SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001727 klass->SetDirectMethod(i, method.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001728 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001729 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001730 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001731 method->SetMethodIndex(class_def_method_index);
1732 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001733 }
1734 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001735 SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001736 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001737 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001738 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001739 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001740 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001741 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001742 }
1743 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001744}
1745
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001746void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001747 SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001748 uint32_t field_idx = it.GetMemberIndex();
1749 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001750 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001751 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001752}
1753
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001754mirror::AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
1755 const ClassDataItemIterator& it,
1756 SirtRef<mirror::Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001757 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001758 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001759 StringPiece method_name(dex_file.GetMethodName(method_id));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001760
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001761 mirror::AbstractMethod* dst = NULL;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001762 if (method_name == "<init>") {
Ian Rogers50b35e22012-10-04 10:09:15 -07001763 dst = AllocConstructor(self);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001764 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001765 dst = AllocMethod(self);
Elliott Hughes80609252011-09-23 17:24:51 -07001766 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07001767 DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
1768
Ian Rogers50b35e22012-10-04 10:09:15 -07001769 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07001770 dst->SetDexMethodIndex(dex_method_idx);
1771 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001772
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001773 if (method_name == "finalize") {
1774 // Create the prototype for a signature of "()V"
1775 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1776 if (void_string_id != NULL) {
1777 const DexFile::TypeId* void_type_id =
1778 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1779 if (void_type_id != NULL) {
1780 std::vector<uint16_t> no_args;
1781 const DexFile::ProtoId* finalizer_proto =
1782 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1783 if (finalizer_proto != NULL) {
1784 // We have the prototype in the dex file
1785 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1786 klass->SetFinalizable();
1787 } else {
1788 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1789 // The Enum class declares a "final" finalize() method to prevent subclasses from
1790 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1791 // subclasses, so we exclude it here.
1792 // We also want to avoid setting the flag on Object, where we know that finalize() is
1793 // empty.
1794 if (klass_descriptor != "Ljava/lang/Object;" &&
1795 klass_descriptor != "Ljava/lang/Enum;") {
1796 klass->SetFinalizable();
1797 }
1798 }
1799 }
1800 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001801 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001802 }
Ian Rogers0571d352011-11-03 19:51:38 -07001803 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001804 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001805
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001806 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001807 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001808 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001809 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001810
1811 CHECK(dst->IsMethod());
1812
Ian Rogers50b35e22012-10-04 10:09:15 -07001813 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001814 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07001815}
1816
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001817void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001818 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001819 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001820 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001821}
1822
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001823void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001824 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001825 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001826 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001827}
1828
Brian Carlstromaded5f72011-10-07 17:15:04 -07001829bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001830 dex_lock_.AssertSharedHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001831 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1832 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001833 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001834 }
1835 }
1836 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001837}
1838
Brian Carlstromaded5f72011-10-07 17:15:04 -07001839bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001840 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001841 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001842}
1843
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001844void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001845 dex_lock_.AssertExclusiveHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001846 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001847 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001848 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001849 dex_cache->SetDexFile(&dex_file);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001850 Dirty();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001851}
1852
Brian Carlstromaded5f72011-10-07 17:15:04 -07001853void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07001854 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001855 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001856 ReaderMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001857 if (IsDexFileRegisteredLocked(dex_file)) {
1858 return;
1859 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001860 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001861 // Don't alloc while holding the lock, since allocation may need to
1862 // suspend all threads and another thread may need the dex_lock_ to
1863 // get to a suspend point.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001864 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001865 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001866 WriterMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001867 if (IsDexFileRegisteredLocked(dex_file)) {
1868 return;
1869 }
1870 RegisterDexFileLocked(dex_file, dex_cache);
1871 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001872}
1873
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001874void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001875 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001876 RegisterDexFileLocked(dex_file, dex_cache);
1877}
1878
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001879mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001880 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001881 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07001882 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001883 mirror::DexCache* dex_cache = dex_caches_[i];
Mathieu Chartier66f19252012-09-18 08:57:04 -07001884 if (dex_cache->GetDexFile() == &dex_file) {
1885 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001886 }
1887 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001888 // Search matching by location name.
1889 std::string location(dex_file.GetLocation());
1890 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001891 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001892 if (dex_cache->GetDexFile()->GetLocation() == location) {
1893 return dex_cache;
1894 }
1895 }
1896 // Failure, dump diagnostic and abort.
1897 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001898 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001899 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
1900 }
1901 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001902 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001903}
1904
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001905void ClassLinker::FixupDexCaches(mirror::AbstractMethod* resolution_method) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001906 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08001907 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1908 dex_caches_[i]->Fixup(resolution_method);
1909 }
1910}
1911
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001912mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
1913 return InitializePrimitiveClass(AllocClass(self, sizeof(mirror::Class)), type);
1914}
1915
1916mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001917 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07001918 // Must hold lock on object when initializing.
1919 ObjectLock lock(Thread::Current(), primitive_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001920 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001921 primitive_class->SetPrimitiveType(type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001922 primitive_class->SetStatus(mirror::Class::kStatusInitialized);
1923 mirror::Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
Ian Rogersc8982582012-09-07 16:53:25 -07001924 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001925 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001926}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001927
Brian Carlstrombe977852011-07-19 14:54:54 -07001928// Create an array class (i.e. the class object for the array, not the
1929// array itself). "descriptor" looks like "[C" or "[[[[B" or
1930// "[Ljava/lang/String;".
1931//
1932// If "descriptor" refers to an array of primitives, look up the
1933// primitive type's internally-generated class object.
1934//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001935// "class_loader" is the class loader of the class that's referring to
1936// us. It's used to ensure that we're looking for the element type in
1937// the right context. It does NOT become the class loader for the
1938// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001939//
1940// Returns NULL with an exception raised on failure.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001941mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
1942 mirror::ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001943 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001944
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001945 // Identify the underlying component type
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001946 mirror::Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001947 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001948 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001949 return NULL;
1950 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001951
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001952 // See if the component type is already loaded. Array classes are
1953 // always associated with the class loader of their underlying
1954 // element type -- an array of Strings goes with the loader for
1955 // java/lang/String -- so we need to look for it there. (The
1956 // caller should have checked for the existence of the class
1957 // before calling here, but they did so with *their* class loader,
1958 // not the component type's loader.)
1959 //
1960 // If we find it, the caller adds "loader" to the class' initiating
1961 // loader list, which should prevent us from going through this again.
1962 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001963 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001964 // are the same, because our caller (FindClass) just did the
1965 // lookup. (Even if we get this wrong we still have correct behavior,
1966 // because we effectively do this lookup again when we add the new
1967 // class to the hash table --- necessary because of possible races with
1968 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001969 if (class_loader != component_type->GetClassLoader()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001970 mirror::Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001971 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001972 return new_class;
1973 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001974 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001975
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001976 // Fill out the fields in the Class.
1977 //
1978 // It is possible to execute some methods against arrays, because
1979 // all arrays are subclasses of java_lang_Object_, so we need to set
1980 // up a vtable. We can just point at the one in java_lang_Object_.
1981 //
1982 // Array classes are simple enough that we don't need to do a full
1983 // link step.
Ian Rogers1f539342012-10-03 21:09:42 -07001984 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001985 SirtRef<mirror::Class> new_class(self, NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001986 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001987 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07001988 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001989 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07001990 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001991 new_class.reset(GetClassRoot(kObjectArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001992 } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
1993 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001994 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]) {
1995 new_class.reset(GetClassRoot(kJavaLangReflectAbstractMethodArrayClass));
Ian Rogers4445a7e2012-10-05 17:19:13 -07001996 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectFieldArrayClass]) {
1997 new_class.reset(GetClassRoot(kJavaLangReflectFieldArrayClass));
1998 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectMethodArrayClass]) {
1999 new_class.reset(GetClassRoot(kJavaLangReflectMethodArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002000 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002001 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07002002 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002003 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002004 }
2005 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002006 if (new_class.get() == NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002007 new_class.reset(AllocClass(self, sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002008 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002009 return NULL;
2010 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002011 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002012 }
Ian Rogers1f539342012-10-03 21:09:42 -07002013 ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002014 DCHECK(new_class->GetComponentType() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002015 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002016 new_class->SetSuperClass(java_lang_Object);
2017 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002018 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002019 new_class->SetClassLoader(component_type->GetClassLoader());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002020 new_class->SetStatus(mirror::Class::kStatusInitialized);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002021 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002022 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002023
2024
2025 // All arrays have java/lang/Cloneable and java/io/Serializable as
2026 // interfaces. We need to set that up here, so that stuff like
2027 // "instanceof" works right.
2028 //
2029 // Note: The GC could run during the call to FindSystemClass,
2030 // so we need to make sure the class object is GC-valid while we're in
2031 // there. Do this by clearing the interface list so the GC will just
2032 // think that the entries are null.
2033
2034
2035 // Use the single, global copies of "interfaces" and "iftable"
2036 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07002037 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002038 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002039
Elliott Hughes00626c22013-06-14 15:04:14 -07002040 // Inherit access flags from the component type.
2041 int access_flags = new_class->GetComponentType()->GetAccessFlags();
2042 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2043 access_flags &= kAccJavaFlagsMask;
2044 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002045 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07002046 access_flags |= kAccAbstract | kAccFinal;
2047 access_flags &= ~kAccInterface;
2048
2049 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002050
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002051 mirror::Class* existing = InsertClass(descriptor, new_class.get(), false);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002052 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002053 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002054 }
2055 // Another thread must have loaded the class after we
2056 // started but before we finished. Abandon what we've
2057 // done.
2058 //
2059 // (Yes, this happens.)
2060
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002061 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002062}
2063
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002064mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002065 switch (Primitive::GetType(type)) {
2066 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002067 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002068 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002069 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002070 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002071 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002072 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002073 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002074 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002075 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002076 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002077 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002078 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002079 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002080 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002081 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002082 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002083 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002084 case Primitive::kPrimNot:
2085 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002086 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002087 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002088 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002089 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002090}
2091
Ian Rogers1d54e732013-05-02 21:10:01 -07002092mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::Class* klass,
2093 bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002094 if (VLOG_IS_ON(class_linker)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002095 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08002096 std::string source;
2097 if (dex_cache != NULL) {
2098 source += " from ";
2099 source += dex_cache->GetLocation()->ToModifiedUtf8();
2100 }
2101 LOG(INFO) << "Loaded class " << descriptor << source;
2102 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002103 size_t hash = StringPieceHash()(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002104 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002105 Table& classes = image_class ? image_classes_ : classes_;
Ian Rogers1d54e732013-05-02 21:10:01 -07002106 mirror::Class* existing =
2107 LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002108#ifndef NDEBUG
2109 // Check we don't have the class in the other table in error
2110 Table& other_classes = image_class ? classes_ : image_classes_;
Elliott Hughesf8349362012-06-18 15:00:06 -07002111 CHECK(LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002112#endif
2113 if (existing != NULL) {
2114 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002115 }
Ian Rogers1d54e732013-05-02 21:10:01 -07002116 Runtime::Current()->GetHeap()->VerifyObject(klass);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002117 classes.insert(std::make_pair(hash, klass));
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07002118 Dirty();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002119 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002120}
2121
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002122bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002123 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002124 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08002125 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08002126 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002127 ClassHelper kh;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002128 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
2129 ++it) {
2130 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002131 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002132 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002133 classes_.erase(it);
2134 return true;
2135 }
2136 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002137 for (It it = image_classes_.lower_bound(hash), end = classes_.end();
2138 it != end && it->first == hash; ++it) {
2139 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002140 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002141 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002142 image_classes_.erase(it);
2143 return true;
2144 }
2145 }
2146 return false;
2147}
2148
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002149mirror::Class* ClassLinker::LookupClass(const char* descriptor,
2150 const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002151 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002152 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07002153 // TODO: determine if its better to search classes_ or image_classes_ first
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002154 mirror::Class* klass = NULL;
2155 // Use image class only if the class_loader is null.
2156 if (class_loader == NULL) {
2157 klass = LookupClassLocked(descriptor, class_loader, hash, image_classes_);
2158 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002159 if (klass != NULL) {
2160 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002161 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002162 return LookupClassLocked(descriptor, class_loader, hash, classes_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002163}
2164
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002165mirror::Class* ClassLinker::LookupClassLocked(const char* descriptor,
2166 const mirror::ClassLoader* class_loader,
2167 size_t hash, const Table& classes) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002168 ClassHelper kh(NULL, this);
2169 typedef Table::const_iterator It; // TODO: C++0x auto
2170 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002171 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002172 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002173 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002174#ifndef NDEBUG
2175 for (++it; it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002176 mirror::Class* klass2 = it->second;
Ian Rogersd85016c2012-02-03 18:27:34 -08002177 kh.ChangeClass(klass2);
2178 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002179 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08002180 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002181 }
2182#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07002183 return klass;
2184 }
2185 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002186 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002187}
2188
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002189void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002190 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002191 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002192 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002193 typedef Table::const_iterator It; // TODO: C++0x auto
2194 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002195 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002196 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002197 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002198 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002199 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002200 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002201 }
2202 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002203 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002204 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002205 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002206 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002207 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002208 }
2209 }
2210}
2211
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002212void ClassLinker::VerifyClass(mirror::Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002213 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002214 Thread* self = Thread::Current();
2215 ObjectLock lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002216
Ian Rogers9ffb0392012-09-10 11:56:50 -07002217 // Don't attempt to re-verify if already sufficiently verified.
2218 if (klass->IsVerified() ||
2219 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002220 return;
2221 }
2222
Ian Rogers9ffb0392012-09-10 11:56:50 -07002223 // The class might already be erroneous, for example at compile time if we attempted to verify
2224 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002225 if (klass->IsErroneous()) {
2226 ThrowEarlierClassFailure(klass);
2227 return;
2228 }
2229
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002230 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
2231 klass->SetStatus(mirror::Class::kStatusVerifying);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002232 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002233 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
2234 << PrettyClass(klass);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002235 CHECK(!Runtime::Current()->IsCompiler());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002236 klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002237 }
jeffhao98eacac2011-09-14 16:11:53 -07002238
Ian Rogers9ffb0392012-09-10 11:56:50 -07002239 // Verify super class.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002240 mirror::Class* super = klass->GetSuperClass();
Ian Rogers1c5eb702012-02-01 09:18:34 -08002241 if (super != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002242 // Acquire lock to prevent races on verifying the super class.
Ian Rogers1f539342012-10-03 21:09:42 -07002243 ObjectLock lock(self, super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002244
2245 if (!super->IsVerified() && !super->IsErroneous()) {
2246 Runtime::Current()->GetClassLinker()->VerifyClass(super);
2247 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002248 if (!super->IsCompileTimeVerified()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002249 std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
2250 PrettyDescriptor(klass).c_str(),
2251 PrettyDescriptor(super).c_str()));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002252 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002253 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002254 if (cause.get() != NULL) {
2255 self->ClearException();
2256 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002257 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002258 if (cause.get() != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002259 self->GetException(NULL)->SetCause(cause.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002260 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002261 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002262 return;
2263 }
2264 }
2265
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002266 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002267 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002268 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002269 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002270 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhaoec014232012-09-05 10:42:25 -07002271 LOG(WARNING) << "Skipping runtime verification of erroneous class " << PrettyDescriptor(klass)
2272 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002273 ThrowVerifyError(klass, "Rejecting class %s because it failed compile-time verification",
2274 PrettyDescriptor(klass).c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002275 klass->SetStatus(mirror::Class::kStatusError);
jeffhaoec014232012-09-05 10:42:25 -07002276 return;
2277 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002278 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
Ian Rogers62d6c772013-02-27 08:32:07 -08002279 std::string error_msg;
jeffhaof1e6b7c2012-06-05 18:33:30 -07002280 if (!preverified) {
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002281 verifier_failure = verifier::MethodVerifier::VerifyClass(klass, error_msg,
2282 Runtime::Current()->IsCompiler());
jeffhaof1e6b7c2012-06-05 18:33:30 -07002283 }
2284 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002285 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
2286 LOG(WARNING) << "Soft verification failure in class " << PrettyDescriptor(klass)
2287 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2288 << " because: " << error_msg;
2289 }
Ian Rogers1f539342012-10-03 21:09:42 -07002290 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002291 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002292 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002293 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002294 klass->SetStatus(mirror::Class::kStatusVerified);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002295 } else {
2296 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2297 // Soft failures at compile time should be retried at runtime. Soft
2298 // failures at runtime will be handled by slow paths in the generated
2299 // code. Set status accordingly.
2300 if (Runtime::Current()->IsCompiler()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002301 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002302 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002303 klass->SetStatus(mirror::Class::kStatusVerified);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002304 }
2305 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002306 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002307 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002308 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2309 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002310 self->AssertNoPendingException();
Ian Rogers62d6c772013-02-27 08:32:07 -08002311 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002312 klass->SetStatus(mirror::Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002313 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002314 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
2315 // Class is verified so we don't need to do any access check in its methods.
2316 // Let the interpreter know it by setting the kAccPreverified flag onto each
2317 // method.
2318 // Note: we're going here during compilation and at runtime. When we set the
2319 // kAccPreverified flag when compiling image classes, the flag is recorded
2320 // in the image and is set when loading the image.
2321 klass->SetPreverifiedFlagOnAllMethods();
2322 }
jeffhao98eacac2011-09-14 16:11:53 -07002323}
2324
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002325bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
2326 mirror::Class::Status& oat_file_class_status) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002327 if (!Runtime::Current()->IsStarted()) {
2328 return false;
2329 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002330 if (Runtime::Current()->UseCompileTimeClassPath()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002331 return false;
2332 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002333 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2334 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002335 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002336 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002337 const char* descriptor = ClassHelper(klass).GetDescriptor();
2338 uint32_t class_def_index;
2339 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002340 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002341 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002342 CHECK(oat_class.get() != NULL)
2343 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002344 oat_file_class_status = oat_class->GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002345 if (oat_file_class_status == mirror::Class::kStatusVerified ||
2346 oat_file_class_status == mirror::Class::kStatusInitialized) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002347 return true;
2348 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002349 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002350 // Compile time verification failed with a soft error. Compile time verification can fail
2351 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002352 // class ... {
2353 // Foo x;
2354 // .... () {
2355 // if (...) {
2356 // v1 gets assigned a type of resolved class Foo
2357 // } else {
2358 // v1 gets assigned a type of unresolved class Bar
2359 // }
2360 // iput x = v1
2361 // } }
2362 // when we merge v1 following the if-the-else it results in Conflict
2363 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2364 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2365 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2366 // at compile time).
2367 return false;
2368 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002369 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07002370 // Compile time verification failed with a hard error. This is caused by invalid instructions
2371 // in the class. These errors are unrecoverable.
2372 return false;
2373 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002374 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002375 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2376 // not loading the class.
2377 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2378 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002379 return false;
2380 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002381 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002382 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2383
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002384 return false;
2385}
2386
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002387void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002388 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2389 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2390 }
2391 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2392 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2393 }
2394}
2395
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002396void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
2397 mirror::AbstractMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002398 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2399 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2400 if (code_item == NULL) {
2401 return; // native or abstract method
2402 }
2403 if (code_item->tries_size_ == 0) {
2404 return; // nothing to process
2405 }
2406 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2407 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2408 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2409 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2410 CatchHandlerIterator iterator(handlers_ptr);
2411 for (; iterator.HasNext(); iterator.Next()) {
2412 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2413 // unresolved exception types will be ignored by exception delivery
2414 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002415 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002416 if (exception_type == NULL) {
2417 DCHECK(Thread::Current()->IsExceptionPending());
2418 Thread::Current()->ClearException();
2419 }
2420 }
2421 }
2422 handlers_ptr = iterator.EndDataPointer();
2423 }
2424}
2425
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002426static void CheckProxyConstructor(mirror::AbstractMethod* constructor);
2427static void CheckProxyMethod(mirror::AbstractMethod* method,
2428 SirtRef<mirror::AbstractMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002429
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002430mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
2431 mirror::ObjectArray<mirror::Class>* interfaces,
2432 mirror::ClassLoader* loader,
2433 mirror::ObjectArray<mirror::AbstractMethod>* methods,
2434 mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws) {
Ian Rogers1f539342012-10-03 21:09:42 -07002435 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002436 SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2437 sizeof(mirror::SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002438 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002439 DCHECK(klass->GetClass() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002440 klass->SetObjectSize(sizeof(mirror::Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002441 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002442 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002443 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002444 klass->SetName(name);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002445 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002446 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002447
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002448 klass->SetStatus(mirror::Class::kStatusIdx);
Ian Rogersc2b44472011-12-14 21:17:17 -08002449
2450 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2451
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002452 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogers4445a7e2012-10-05 17:19:13 -07002453 klass->SetSFields(AllocFieldArray(self, 2));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002454 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2455 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002456 SirtRef<mirror::Field> interfaces_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002457 klass->SetStaticField(0, interfaces_sfield.get());
2458 interfaces_sfield->SetDexFieldIndex(0);
2459 interfaces_sfield->SetDeclaringClass(klass.get());
2460 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2461 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002462 SirtRef<mirror::Field> throws_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002463 klass->SetStaticField(1, throws_sfield.get());
2464 throws_sfield->SetDexFieldIndex(1);
2465 throws_sfield->SetDeclaringClass(klass.get());
2466 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002467
Ian Rogers466bb252011-10-14 03:29:56 -07002468 // Proxies have 1 direct method, the constructor
Ian Rogers4445a7e2012-10-05 17:19:13 -07002469 klass->SetDirectMethods(AllocAbstractMethodArray(self, 1));
Ian Rogers50b35e22012-10-04 10:09:15 -07002470 klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002471
Ian Rogers466bb252011-10-14 03:29:56 -07002472 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002473 size_t num_virtual_methods = methods->GetLength();
Ian Rogers4445a7e2012-10-05 17:19:13 -07002474 klass->SetVirtualMethods(AllocMethodArray(self, num_virtual_methods));
Jesse Wilson95caa792011-10-12 18:14:17 -04002475 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002476 SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
Ian Rogers50b35e22012-10-04 10:09:15 -07002477 klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002478 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002479
2480 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002481 klass->SetStatus(mirror::Class::kStatusLoaded); // Class is now effectively in the loaded state
Ian Rogers62d6c772013-02-27 08:32:07 -08002482 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08002483
2484 // Link the fields and virtual methods, creating vtable and iftables
2485 if (!LinkClass(klass, interfaces)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002486 klass->SetStatus(mirror::Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002487 return NULL;
2488 }
Ian Rogersc8982582012-09-07 16:53:25 -07002489 {
Ian Rogers1f539342012-10-03 21:09:42 -07002490 ObjectLock lock(self, klass.get()); // Must hold lock on object when initializing.
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002491 interfaces_sfield->SetObject(klass.get(), interfaces);
2492 throws_sfield->SetObject(klass.get(), throws);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002493 klass->SetStatus(mirror::Class::kStatusInitialized);
Ian Rogersc8982582012-09-07 16:53:25 -07002494 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002495
2496 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002497 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002498 CHECK(klass->GetIFields() == NULL);
2499 CheckProxyConstructor(klass->GetDirectMethod(0));
2500 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002501 SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002502 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2503 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002504
2505 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2506 name->ToModifiedUtf8().c_str()));
2507 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2508
2509 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2510 name->ToModifiedUtf8().c_str()));
2511 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002512
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002513 mirror::SynthesizedProxyClass* synth_proxy_class =
2514 down_cast<mirror::SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002515 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002516 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2517 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002518 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002519}
2520
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002521std::string ClassLinker::GetDescriptorForProxy(const mirror::Class* proxy_class) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002522 DCHECK(proxy_class->IsProxyClass());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002523 mirror::String* name = proxy_class->GetName();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002524 DCHECK(name != NULL);
2525 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2526}
2527
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002528mirror::AbstractMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
2529 const mirror::AbstractMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002530 DCHECK(proxy_class->IsProxyClass());
2531 DCHECK(proxy_method->IsProxyMethod());
2532 // Locate the dex cache of the original interface/Object
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002533 mirror::DexCache* dex_cache = NULL;
Ian Rogers16f93672012-02-14 12:29:06 -08002534 {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002535 mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002536 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002537 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2538 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2539 dex_cache = dex_caches_[i];
2540 break;
2541 }
2542 }
2543 }
2544 CHECK(dex_cache != NULL);
2545 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002546 mirror::AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002547 CHECK(resolved_method != NULL);
2548 return resolved_method;
2549}
2550
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002551
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002552mirror::AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self,
2553 SirtRef<mirror::Class>& klass,
2554 mirror::Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002555 // Create constructor for Proxy that must initialize h
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002556 mirror::ObjectArray<mirror::AbstractMethod>* proxy_direct_methods =
2557 proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002558 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002559 mirror::AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002560 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2561 // code_ too)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002562 mirror::AbstractMethod* constructor =
2563 down_cast<mirror::AbstractMethod*>(proxy_constructor->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002564 // Make this constructor public and fix the class to be our Proxy version
2565 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002566 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002567 return constructor;
2568}
2569
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002570static void CheckProxyConstructor(mirror::AbstractMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002571 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002572 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002573 MethodHelper mh(constructor);
2574 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002575 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002576 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002577}
2578
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002579mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
2580 SirtRef<mirror::AbstractMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002581 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2582 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002583 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2584 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002585 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002586 // as necessary
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002587 mirror::AbstractMethod* method = down_cast<mirror::AbstractMethod*>(prototype->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002588
2589 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2590 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002591 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002592 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002593
Ian Rogers466bb252011-10-14 03:29:56 -07002594 // At runtime the method looks like a reference and argument saving method, clone the code
2595 // related parameters from this method.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002596 mirror::AbstractMethod* refs_and_args =
2597 Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07002598 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2599 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2600 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
Ian Rogersc928de92013-02-27 14:30:44 -08002601#if !defined(ART_USE_PORTABLE_COMPILER)
Jeff Haoaa4a7932013-05-13 11:28:27 -07002602 method->SetEntryPointFromCompiledCode(reinterpret_cast<void*>(art_quick_proxy_invoke_handler));
TDYa1275bb86012012-04-11 05:57:28 -07002603#else
Jeff Haoaa4a7932013-05-13 11:28:27 -07002604 method->SetEntryPointFromCompiledCode(reinterpret_cast<void*>(art_portable_proxy_invoke_handler));
TDYa1275bb86012012-04-11 05:57:28 -07002605#endif
Jeff Hao16743632013-05-08 10:59:04 -07002606 method->SetEntryPointFromInterpreter(artInterpreterToQuickEntry);
Ian Rogers16f93672012-02-14 12:29:06 -08002607
Ian Rogersc2b44472011-12-14 21:17:17 -08002608 return method;
2609}
Jesse Wilson95caa792011-10-12 18:14:17 -04002610
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002611static void CheckProxyMethod(mirror::AbstractMethod* method,
2612 SirtRef<mirror::AbstractMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002613 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002614 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002615 CHECK(!prototype->IsFinal());
2616 CHECK(method->IsFinal());
2617 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002618
2619 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2620 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2621 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2622 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2623 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2624 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2625 method->GetDexCacheInitializedStaticStorage());
2626 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2627
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002628 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002629 MethodHelper mh2(prototype.get());
2630 CHECK_STREQ(mh.GetName(), mh2.GetName());
2631 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002632 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002633 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002634}
2635
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002636bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002637 CHECK(klass->IsResolved() || klass->IsErroneous())
Ian Rogers9ffb0392012-09-10 11:56:50 -07002638 << PrettyClass(klass) << ": state=" << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002639
Carl Shapirob5573532011-07-12 18:22:59 -07002640 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002641
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002642 mirror::AbstractMethod* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002643 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002644 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Ian Rogers1f539342012-10-03 21:09:42 -07002645 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002646
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002647 if (klass->GetStatus() == mirror::Class::kStatusInitialized) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002648 return true;
2649 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002650
Brian Carlstromd1422f82011-09-28 11:37:09 -07002651 if (klass->IsErroneous()) {
2652 ThrowEarlierClassFailure(klass);
2653 return false;
2654 }
2655
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002656 if (klass->GetStatus() == mirror::Class::kStatusResolved ||
2657 klass->GetStatus() == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao98eacac2011-09-14 16:11:53 -07002658 VerifyClass(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002659 if (klass->GetStatus() != mirror::Class::kStatusVerified) {
2660 if (klass->GetStatus() == mirror::Class::kStatusError) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07002661 CHECK(self->IsExceptionPending());
2662 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002663 return false;
2664 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002665 }
2666
Brian Carlstrom25c33252011-09-18 15:58:35 -07002667 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2668 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002669 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002670 // don't bother going to kStatusInitializing. We return false so that
2671 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002672 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2673 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002674 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002675 }
2676
Brian Carlstromd1422f82011-09-28 11:37:09 -07002677 // If the class is kStatusInitializing, either this thread is
2678 // initializing higher up the stack or another thread has beat us
2679 // to initializing and we need to wait. Either way, this
2680 // invocation of InitializeClass will not be responsible for
2681 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002682 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002683 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002684 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002685 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002686 return true;
2687 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002688 // No. That's fine. Wait for another thread to finish initializing.
2689 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002690 }
2691
2692 if (!ValidateSuperClassDescriptors(klass)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002693 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002694 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002695 return false;
2696 }
2697
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002698 DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002699
Elliott Hughesdcc24742011-09-07 14:02:44 -07002700 klass->SetClinitThreadId(self->GetTid());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002701 klass->SetStatus(mirror::Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002702 }
2703
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002704 uint64_t t0 = NanoTime();
2705
Ian Rogers0045a292012-03-31 21:08:41 -07002706 if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002707 // Super class initialization failed, this can be because we can't run
2708 // super-class class initializers in which case we'll be verified.
2709 // Otherwise this class is erroneous.
2710 if (!can_run_clinit) {
2711 CHECK(klass->IsVerified());
2712 } else {
2713 CHECK(klass->IsErroneous());
2714 }
Ian Rogers3d1548d2012-09-24 14:08:03 -07002715 // Signal to any waiting threads that saw this class as initializing.
Ian Rogers1f539342012-10-03 21:09:42 -07002716 ObjectLock lock(self, klass);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002717 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002718 return false;
2719 }
2720
Ian Rogers0045a292012-03-31 21:08:41 -07002721 bool has_static_field_initializers = InitializeStaticFields(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002722
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002723 if (clinit != NULL) {
Ian Rogers64b6d142012-10-29 16:34:15 -07002724 if (Runtime::Current()->IsStarted()) {
Jeff Hao5d917302013-02-27 17:57:33 -08002725 JValue result;
Jeff Hao6474d192013-03-26 14:08:09 -07002726 clinit->Invoke(self, NULL, 0, &result, 'V');
Ian Rogers64b6d142012-10-29 16:34:15 -07002727 } else {
Jeff Hao6474d192013-03-26 14:08:09 -07002728 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
Ian Rogers64b6d142012-10-29 16:34:15 -07002729 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002730 }
2731
Ian Rogers19846512012-02-24 11:42:47 -08002732 FixupStaticTrampolines(klass);
2733
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002734 uint64_t t1 = NanoTime();
2735
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002736 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002737 {
Ian Rogers1f539342012-10-03 21:09:42 -07002738 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002739
2740 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002741 WrapExceptionInInitializer();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002742 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002743 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002744 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002745 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2746 RuntimeStats* thread_stats = self->GetStats();
2747 ++global_stats->class_init_count;
2748 ++thread_stats->class_init_count;
2749 global_stats->class_init_time_ns += (t1 - t0);
2750 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogers0045a292012-03-31 21:08:41 -07002751 // Set the class as initialized except if we can't initialize static fields and static field
2752 // initialization is necessary.
2753 if (!can_init_statics && has_static_field_initializers) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002754 klass->SetStatus(mirror::Class::kStatusVerified); // Don't leave class in initializing state.
Ian Rogers0045a292012-03-31 21:08:41 -07002755 success = false;
2756 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002757 klass->SetStatus(mirror::Class::kStatusInitialized);
Ian Rogers0045a292012-03-31 21:08:41 -07002758 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002759 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002760 ClassHelper kh(klass);
2761 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002762 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002763 }
2764 lock.NotifyAll();
2765 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002766 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002767}
2768
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002769bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002770 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002771 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002772 self->AssertNoPendingException();
Ian Rogers05f30572013-02-20 12:13:11 -08002773 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002774
2775 // When we wake up, repeat the test for init-in-progress. If
2776 // there's an exception pending (only possible if
2777 // "interruptShouldThrow" was set), bail out.
2778 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002779 WrapExceptionInInitializer();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002780 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromd1422f82011-09-28 11:37:09 -07002781 return false;
2782 }
2783 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002784 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002785 continue;
2786 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002787 if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07002788 // Compile time initialization failed.
2789 return false;
2790 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002791 if (klass->IsErroneous()) {
2792 // The caller wants an exception, but it was thrown in a
2793 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002794 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002795 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002796 return false;
2797 }
2798 if (klass->IsInitialized()) {
2799 return true;
2800 }
2801 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2802 }
2803 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2804}
2805
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002806bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002807 if (klass->IsInterface()) {
2808 return true;
2809 }
2810 // begin with the methods local to the superclass
2811 if (klass->HasSuperClass() &&
2812 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002813 const mirror::Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002814 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002815 const mirror::AbstractMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08002816 if (method != super->GetVTable()->Get(i) &&
2817 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002818 ThrowLinkageError(klass, "Class %s method %s resolves differently in superclass %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002819 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2820 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002821 return false;
2822 }
2823 }
2824 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002825 mirror::IfTable* iftable = klass->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002826 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002827 mirror::Class* interface = iftable->GetInterface(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002828 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2829 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002830 const mirror::AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002831 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2832 method->GetDeclaringClass())) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002833 ThrowLinkageError(klass, "Class %s method %s resolves differently in interface %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002834 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2835 PrettyMethod(method).c_str(),
2836 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002837 return false;
2838 }
2839 }
2840 }
2841 }
2842 return true;
2843}
2844
Ian Rogers595799e2012-01-11 17:32:51 -08002845// Returns true if classes referenced by the signature of the method are the
2846// same classes in klass1 as they are in klass2.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002847bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
2848 const mirror::Class* klass1,
2849 const mirror::Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002850 if (klass1 == klass2) {
2851 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002852 }
Ian Rogers4445a7e2012-10-05 17:19:13 -07002853 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002854 const DexFile::ProtoId& proto_id =
2855 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002856 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2857 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002858 if (descriptor == NULL) {
2859 break;
2860 }
2861 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2862 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002863 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002864 return false;
2865 }
2866 }
2867 }
2868 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002869 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002870 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002871 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002872 return false;
2873 }
2874 }
2875 return true;
2876}
2877
Ian Rogers595799e2012-01-11 17:32:51 -08002878// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2879bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002880 const mirror::Class* klass1,
2881 const mirror::Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002882 CHECK(descriptor != NULL);
2883 CHECK(klass1 != NULL);
2884 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002885 if (klass1 == klass2) {
2886 return true;
2887 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002888 mirror::Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002889 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002890 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002891 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002892 mirror::Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002893 if (found2 == NULL) {
2894 Thread::Current()->ClearException();
2895 }
2896 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002897}
2898
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002899bool ClassLinker::InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002900 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002901 if (!klass->IsInterface() && klass->HasSuperClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002902 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers9ffb0392012-09-10 11:56:50 -07002903 if (!super_class->IsInitialized()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002904 CHECK(!super_class->IsInterface());
Ian Rogers1f539342012-10-03 21:09:42 -07002905 // Must hold lock on object when initializing and setting status.
Ian Rogers05f30572013-02-20 12:13:11 -08002906 Thread* self = Thread::Current();
2907 ObjectLock lock(self, klass);
Ian Rogers0045a292012-03-31 21:08:41 -07002908 bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002909 // TODO: check for a pending exception
2910 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002911 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002912 // Don't set status to error when we can't run <clinit>.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002913 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusInitializing) << PrettyClass(klass);
2914 klass->SetStatus(mirror::Class::kStatusVerified);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002915 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002916 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002917 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogers05f30572013-02-20 12:13:11 -08002918 klass->NotifyAll(self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002919 return false;
2920 }
2921 }
2922 }
2923 return true;
2924}
2925
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002926bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields) {
Mathieu Chartier155dfe92012-10-09 14:24:49 -07002927 DCHECK(c != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002928 if (c->IsInitialized()) {
2929 return true;
2930 }
2931
Elliott Hughes5f791332011-09-15 17:45:30 -07002932 Thread* self = Thread::Current();
Elliott Hughes34e06962012-04-09 13:55:55 -07002933 ScopedThreadStateChange tsc(self, kRunnable);
Ian Rogers0045a292012-03-31 21:08:41 -07002934 bool success = InitializeClass(c, can_run_clinit, can_init_fields);
Ian Rogers595799e2012-01-11 17:32:51 -08002935 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002936 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002937 }
2938 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002939}
2940
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002941void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002942 mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map) {
2943 mirror::ClassLoader* cl = c->GetClassLoader();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002944 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002945 ClassDataItemIterator it(dex_file, class_data);
2946 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002947 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002948 }
2949}
2950
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002951bool ClassLinker::InitializeStaticFields(mirror::Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002952 size_t num_static_fields = klass->NumStaticFields();
2953 if (num_static_fields == 0) {
Ian Rogers0045a292012-03-31 21:08:41 -07002954 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002955 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002956 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002957 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002958 if (dex_cache == NULL) {
Ian Rogers0045a292012-03-31 21:08:41 -07002959 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002960 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002961 ClassHelper kh(klass);
2962 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002963 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002964 const DexFile& dex_file = kh.GetDexFile();
Brian Carlstrom88f36542012-10-16 23:24:21 -07002965 EncodedStaticFieldValueIterator it(dex_file, dex_cache, klass->GetClassLoader(),
2966 this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002967
Ian Rogers0571d352011-11-03 19:51:38 -07002968 if (it.HasNext()) {
2969 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002970 SafeMap<uint32_t, mirror::Field*> field_map;
Ian Rogers0571d352011-11-03 19:51:38 -07002971 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
2972 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002973 it.ReadValueToField(field_map.Get(i));
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002974 }
Ian Rogers0045a292012-03-31 21:08:41 -07002975 return true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002976 }
Ian Rogers0045a292012-03-31 21:08:41 -07002977 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002978}
2979
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002980bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
2981 mirror::ObjectArray<mirror::Class>* interfaces) {
2982 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002983 if (!LinkSuperClass(klass)) {
2984 return false;
2985 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002986 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002987 return false;
2988 }
2989 if (!LinkInstanceFields(klass)) {
2990 return false;
2991 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07002992 if (!LinkStaticFields(klass)) {
2993 return false;
2994 }
2995 CreateReferenceInstanceOffsets(klass);
2996 CreateReferenceStaticOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002997 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
2998 klass->SetStatus(mirror::Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002999 return true;
3000}
3001
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003002bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file) {
3003 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003004 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
3005 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08003006 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003007 uint16_t super_class_idx = class_def->superclass_idx_;
3008 if (super_class_idx != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003009 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003010 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003011 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003012 return false;
3013 }
Ian Rogersbe125a92012-01-11 15:19:49 -08003014 // Verify
3015 if (!klass->CanAccess(super_class)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003016 ThrowIllegalAccessError(klass.get(), "Class %s extended by class %s is inaccessible",
3017 PrettyDescriptor(super_class).c_str(),
3018 PrettyDescriptor(klass.get()).c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08003019 return false;
3020 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003021 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003022 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003023 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
3024 if (interfaces != NULL) {
3025 for (size_t i = 0; i < interfaces->Size(); i++) {
3026 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003027 mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003028 if (interface == NULL) {
3029 DCHECK(Thread::Current()->IsExceptionPending());
3030 return false;
3031 }
3032 // Verify
3033 if (!klass->CanAccess(interface)) {
3034 // TODO: the RI seemed to ignore this in my testing.
Ian Rogers62d6c772013-02-27 08:32:07 -08003035 ThrowIllegalAccessError(klass.get(), "Interface %s implemented by class %s is inaccessible",
3036 PrettyDescriptor(interface).c_str(),
3037 PrettyDescriptor(klass.get()).c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003038 return false;
3039 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003040 }
3041 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003042 // Mark the class as loaded.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003043 klass->SetStatus(mirror::Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003044 return true;
3045}
3046
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003047bool ClassLinker::LinkSuperClass(SirtRef<mirror::Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003048 CHECK(!klass->IsPrimitive());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003049 mirror::Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003050 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003051 if (super != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003052 ThrowClassFormatError(klass.get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003053 return false;
3054 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003055 return true;
3056 }
3057 if (super == NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003058 ThrowLinkageError(klass.get(), "No superclass defined for class %s",
3059 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003060 return false;
3061 }
3062 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003063 if (super->IsFinal() || super->IsInterface()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003064 ThrowIncompatibleClassChangeError(klass.get(), "Superclass %s of %s is %s",
3065 PrettyDescriptor(super).c_str(),
3066 PrettyDescriptor(klass.get()).c_str(),
3067 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003068 return false;
3069 }
3070 if (!klass->CanAccess(super)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003071 ThrowIllegalAccessError(klass.get(), "Superclass %s is inaccessible to class %s",
3072 PrettyDescriptor(super).c_str(),
3073 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003074 return false;
3075 }
Elliott Hughes20cde902011-10-04 17:37:27 -07003076
3077 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3078 if (super->IsFinalizable()) {
3079 klass->SetFinalizable();
3080 }
3081
Elliott Hughes2da50362011-10-10 16:57:08 -07003082 // Inherit reference flags (if any) from the superclass.
3083 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3084 if (reference_flags != 0) {
3085 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3086 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003087 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07003088 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003089 ThrowLinkageError(klass.get(),
3090 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
3091 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003092 return false;
3093 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003094
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003095#ifndef NDEBUG
3096 // Ensure super classes are fully resolved prior to resolving fields..
3097 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003098 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003099 super = super->GetSuperClass();
3100 }
3101#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003102 return true;
3103}
3104
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003105// Populate the class vtable and itable. Compute return type indices.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003106bool ClassLinker::LinkMethods(SirtRef<mirror::Class>& klass,
3107 mirror::ObjectArray<mirror::Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003108 if (klass->IsInterface()) {
3109 // No vtable.
3110 size_t count = klass->NumVirtualMethods();
3111 if (!IsUint(16, count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003112 ThrowClassFormatError(klass.get(), "Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003113 return false;
3114 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003115 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003116 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003117 }
jeffhaobdb76512011-09-07 11:43:16 -07003118 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003119 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003120 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003121 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003122 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003123 }
3124 return true;
3125}
3126
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003127bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003128 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003129 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003130 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3131 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003132 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003133 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003134 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003135 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003136 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003137 MethodHelper local_mh(NULL, this);
3138 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003139 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003140 mirror::AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003141 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003142 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003143 for (; j < actual_count; ++j) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003144 mirror::AbstractMethod* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003145 super_mh.ChangeMethod(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003146 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3147 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3148 if (super_method->IsFinal()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003149 ThrowLinkageError(klass.get(), "Method %s overrides final method in class %s",
Elliott Hughes39717372012-07-13 16:21:23 -07003150 PrettyMethod(local_method).c_str(),
3151 super_mh.GetDeclaringClassDescriptor());
3152 return false;
3153 }
3154 vtable->Set(j, local_method);
3155 local_method->SetMethodIndex(j);
3156 break;
3157 } else {
3158 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3159 << " would have incorrectly overridden the package-private method in "
3160 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003161 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003162 }
3163 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003164 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003165 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003166 vtable->Set(actual_count, local_method);
3167 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003168 actual_count += 1;
3169 }
3170 }
3171 if (!IsUint(16, actual_count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003172 ThrowClassFormatError(klass.get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003173 return false;
3174 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003175 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003176 CHECK_LE(actual_count, max_count);
3177 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003178 vtable.reset(vtable->CopyOf(self, actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003179 }
Ian Rogers30fab402012-01-23 15:43:46 -08003180 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003181 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003182 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003183 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003184 if (!IsUint(16, num_virtual_methods)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003185 ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003186 return false;
3187 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003188 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07003189 vtable(self, AllocMethodArray(self, num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003190 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003191 mirror::AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003192 vtable->Set(i, virtual_method);
3193 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003194 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003195 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003196 }
3197 return true;
3198}
3199
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003200bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
3201 mirror::ObjectArray<mirror::Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003202 size_t super_ifcount;
3203 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003204 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003205 } else {
3206 super_ifcount = 0;
3207 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003208 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003209 ClassHelper kh(klass.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -07003210 uint32_t num_interfaces = interfaces == NULL ? kh.NumDirectInterfaces() : interfaces->GetLength();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003211 ifcount += num_interfaces;
3212 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003213 mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003214 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003215 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003216 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003217 // Class implements no interfaces.
3218 DCHECK_EQ(klass->GetIfTableCount(), 0);
3219 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003220 return true;
3221 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003222 if (ifcount == super_ifcount) {
3223 // Class implements same interfaces as parent, are any of these not marker interfaces?
3224 bool has_non_marker_interface = false;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003225 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Ian Rogers9bc81912012-10-11 21:43:36 -07003226 for (size_t i = 0; i < ifcount; ++i) {
3227 if (super_iftable->GetMethodArrayCount(i) > 0) {
3228 has_non_marker_interface = true;
3229 break;
3230 }
3231 }
3232 if (!has_non_marker_interface) {
3233 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3234 klass->SetIfTable(super_iftable);
3235 return true;
3236 }
3237 }
Ian Rogers1f539342012-10-03 21:09:42 -07003238 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003239 SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003240 if (super_ifcount != 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003241 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003242 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003243 mirror::Class* super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003244 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003245 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003246 }
3247 // Flatten the interface inheritance hierarchy.
3248 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003249 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003250 mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003251 DCHECK(interface != NULL);
3252 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003253 ClassHelper ih(interface);
Ian Rogers62d6c772013-02-27 08:32:07 -08003254 ThrowIncompatibleClassChangeError(klass.get(), "Class %s implements non-interface class %s",
3255 PrettyDescriptor(klass.get()).c_str(),
3256 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003257 return false;
3258 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003259 // Check if interface is already in iftable
3260 bool duplicate = false;
3261 for (size_t j = 0; j < idx; j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003262 mirror::Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003263 if (existing_interface == interface) {
3264 duplicate = true;
3265 break;
3266 }
3267 }
3268 if (!duplicate) {
3269 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003270 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003271 // Add this interface's non-duplicate super-interfaces.
3272 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003273 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003274 bool super_duplicate = false;
3275 for (size_t k = 0; k < idx; k++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003276 mirror::Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003277 if (existing_interface == super_interface) {
3278 super_duplicate = true;
3279 break;
3280 }
3281 }
3282 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003283 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003284 }
3285 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003286 }
3287 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003288 // Shrink iftable in case duplicates were found
3289 if (idx < ifcount) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003290 iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
Ian Rogersb52b01a2012-01-12 17:01:38 -08003291 ifcount = idx;
3292 } else {
3293 CHECK_EQ(idx, ifcount);
3294 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003295 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003296
3297 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003298 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003299 return true;
3300 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003301 std::vector<mirror::AbstractMethod*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003302 MethodHelper vtable_mh(NULL, this);
3303 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003304 for (size_t i = 0; i < ifcount; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003305 mirror::Class* interface = iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003306 size_t num_methods = interface->NumVirtualMethods();
3307 if (num_methods > 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003308 mirror::ObjectArray<mirror::AbstractMethod>* method_array =
3309 AllocMethodArray(self, num_methods);
Ian Rogers9bc81912012-10-11 21:43:36 -07003310 iftable->SetMethodArray(i, method_array);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003311 mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
Ian Rogers62d6c772013-02-27 08:32:07 -08003312 for (size_t j = 0; j < num_methods; ++j) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003313 mirror::AbstractMethod* interface_method = interface->GetVirtualMethod(j);
Ian Rogers9bc81912012-10-11 21:43:36 -07003314 interface_mh.ChangeMethod(interface_method);
3315 int32_t k;
3316 // For each method listed in the interface's method list, find the
3317 // matching method in our class's method list. We want to favor the
3318 // subclass over the superclass, which just requires walking
3319 // back from the end of the vtable. (This only matters if the
3320 // superclass defines a private method and this class redefines
3321 // it -- otherwise it would use the same vtable slot. In .dex files
3322 // those don't end up in the virtual method table, so it shouldn't
3323 // matter which direction we go. We walk it backward anyway.)
3324 for (k = vtable->GetLength() - 1; k >= 0; --k) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003325 mirror::AbstractMethod* vtable_method = vtable->Get(k);
Ian Rogers9bc81912012-10-11 21:43:36 -07003326 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003327 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Elliott Hughes68243612013-02-22 17:16:07 -08003328 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003329 ThrowIllegalAccessError(klass.get(),
3330 "Method '%s' implementing interface method '%s' is not public",
3331 PrettyMethod(vtable_method).c_str(),
3332 PrettyMethod(interface_method).c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07003333 return false;
3334 }
3335 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003336 break;
3337 }
3338 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003339 if (k < 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003340 SirtRef<mirror::AbstractMethod> miranda_method(self, NULL);
Ian Rogers9bc81912012-10-11 21:43:36 -07003341 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003342 mirror::AbstractMethod* mir_method = miranda_list[mir];
Ian Rogers9bc81912012-10-11 21:43:36 -07003343 vtable_mh.ChangeMethod(mir_method);
3344 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3345 miranda_method.reset(miranda_list[mir]);
3346 break;
3347 }
3348 }
3349 if (miranda_method.get() == NULL) {
3350 // point the interface table at a phantom slot
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003351 miranda_method.reset(down_cast<mirror::AbstractMethod*>(interface_method->Clone(self)));
Ian Rogers9bc81912012-10-11 21:43:36 -07003352 miranda_list.push_back(miranda_method.get());
3353 }
3354 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003355 }
3356 }
3357 }
3358 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003359 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003360 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003361 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07003362 klass->SetVirtualMethods((old_method_count == 0)
Ian Rogers4445a7e2012-10-05 17:19:13 -07003363 ? AllocMethodArray(self, new_method_count)
Ian Rogers50b35e22012-10-04 10:09:15 -07003364 : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003365
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003366 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
3367 vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003368 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003369 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003370 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003371 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07003372 for (size_t i = 0; i < miranda_list.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003373 mirror::AbstractMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003374 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003375 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3376 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3377 klass->SetVirtualMethod(old_method_count + i, method);
3378 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003379 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003380 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003381 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003382 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003383
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003384 mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003385 for (int i = 0; i < vtable->GetLength(); ++i) {
3386 CHECK(vtable->Get(i) != NULL);
3387 }
3388
3389// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3390
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003391 return true;
3392}
3393
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003394bool ClassLinker::LinkInstanceFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003395 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003396 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003397}
3398
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003399bool ClassLinker::LinkStaticFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003400 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003401 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003402 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003403 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003404 return success;
3405}
3406
Brian Carlstromdbc05252011-09-09 01:59:59 -07003407struct LinkFieldsComparator {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003408 explicit LinkFieldsComparator(FieldHelper* fh)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003409 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003410 : fh_(fh) {}
3411 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003412 bool operator()(const mirror::Field* field1, const mirror::Field* field2)
3413 NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003414 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003415 fh_->ChangeField(field1);
3416 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3417 fh_->ChangeField(field2);
3418 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003419 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3420 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3421 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3422 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003423 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3424 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3425 if (order1 != order2) {
3426 return order1 < order2;
3427 }
3428
3429 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003430 fh_->ChangeField(field1);
3431 StringPiece name1(fh_->GetName());
3432 fh_->ChangeField(field2);
3433 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003434 return name1 < name2;
3435 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003436
3437 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003438};
3439
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003440bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003441 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003442 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003443
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003444 mirror::ObjectArray<mirror::Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003445 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003446
3447 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003448 size_t size;
3449 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003450 if (is_static) {
3451 size = klass->GetClassSize();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003452 field_offset = mirror::Class::FieldsOffset();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003453 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003454 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003455 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003456 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003457 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003458 }
3459 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003460 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003461
Brian Carlstromdbc05252011-09-09 01:59:59 -07003462 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003463
Brian Carlstromdbc05252011-09-09 01:59:59 -07003464 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003465 // minimizes disruption of C++ version such as Class and Method.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003466 std::deque<mirror::Field*> grouped_and_sorted_fields;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003467 for (size_t i = 0; i < num_fields; i++) {
3468 grouped_and_sorted_fields.push_back(fields->Get(i));
3469 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003470 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003471 std::sort(grouped_and_sorted_fields.begin(),
3472 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003473 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003474
3475 // References should be at the front.
3476 size_t current_field = 0;
3477 size_t num_reference_fields = 0;
3478 for (; current_field < num_fields; current_field++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003479 mirror::Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003480 fh.ChangeField(field);
3481 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003482 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003483 if (isPrimitive) {
3484 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003485 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003486 grouped_and_sorted_fields.pop_front();
3487 num_reference_fields++;
3488 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003489 field->SetOffset(field_offset);
3490 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003491 }
3492
3493 // Now we want to pack all of the double-wide fields together. If
3494 // we're not aligned, though, we want to shuffle one 32-bit field
3495 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003496 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003497 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003498 mirror::Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003499 fh.ChangeField(field);
3500 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003501 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3502 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003503 continue;
3504 }
3505 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003506 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003507 // drop the consumed field
3508 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3509 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003510 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003511 // whether we found a 32-bit field for padding or not, we advance
3512 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003513 }
3514
3515 // Alignment is good, shuffle any double-wide fields forward, and
3516 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003517 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003518 while (!grouped_and_sorted_fields.empty()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003519 mirror::Field* field = grouped_and_sorted_fields.front();
Brian Carlstromdbc05252011-09-09 01:59:59 -07003520 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003521 fh.ChangeField(field);
3522 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003523 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003524 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003525 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003526 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003527 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003528 ? sizeof(uint64_t)
3529 : sizeof(uint32_t)));
3530 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003531 }
3532
Elliott Hughesadb460d2011-10-05 17:02:34 -07003533 // 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 -07003534 if (!is_static &&
3535 StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003536 // We know there are no non-reference fields in the Reference classes, and we know
3537 // that 'referent' is alphabetically last, so this is easy...
3538 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003539 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003540 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003541 --num_reference_fields;
3542 }
3543
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003544#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003545 // Make sure that all reference fields appear before
3546 // non-reference fields, and all double-wide fields are aligned.
3547 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003548 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003549 mirror::Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003550 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003551 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003552 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003553 << " field=" << PrettyField(field)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003554 << " offset=" << field->GetField32(MemberOffset(mirror::Field::OffsetOffset()),
3555 false);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003556 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003557 fh.ChangeField(field);
3558 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003559 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers64b6d142012-10-29 16:34:15 -07003560 if (StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;" &&
3561 StringPiece(fh.GetName()) == "referent") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003562 is_primitive = true; // We lied above, so we have to expect a lie here.
3563 }
3564 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003565 if (!seen_non_ref) {
3566 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003567 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003568 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003569 } else {
3570 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003571 }
3572 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003573 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003574 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003575 }
3576#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003577 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003578 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003579 if (is_static) {
3580 klass->SetNumReferenceStaticFields(num_reference_fields);
3581 klass->SetClassSize(size);
3582 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003583 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003584 if (!klass->IsVariableSize()) {
Brian Carlstrom62cd0982013-06-03 11:30:25 -07003585 DCHECK_GE(size, sizeof(mirror::Object)) << ClassHelper(klass.get(), this).GetDescriptor();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003586 klass->SetObjectSize(size);
3587 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003588 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003589 return true;
3590}
3591
3592// Set the bitmap of reference offsets, refOffsets, from the ifields
3593// list.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003594void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003595 uint32_t reference_offsets = 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003596 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003597 if (super_class != NULL) {
3598 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003599 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003600 if (reference_offsets == CLASS_WALK_SUPER) {
3601 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003602 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003603 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003604 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003605 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003606}
3607
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003608void ClassLinker::CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003609 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003610}
3611
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003612void ClassLinker::CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003613 uint32_t reference_offsets) {
3614 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003615 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3616 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003617 const mirror::ObjectArray<mirror::Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003618 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003619 // All of the fields that contain object references are guaranteed
3620 // to be at the beginning of the fields list.
3621 for (size_t i = 0; i < num_reference_fields; ++i) {
3622 // Note that byte_offset is the offset from the beginning of
3623 // object, not the offset into instance data
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003624 const mirror::Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003625 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003626 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3627 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3628 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003629 CHECK_NE(new_bit, 0U);
3630 reference_offsets |= new_bit;
3631 } else {
3632 reference_offsets = CLASS_WALK_SUPER;
3633 break;
3634 }
3635 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003636 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003637 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003638 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003639 } else {
3640 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003641 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003642}
3643
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003644mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
3645 uint32_t string_idx, mirror::DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003646 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003647 mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003648 if (resolved != NULL) {
3649 return resolved;
3650 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003651 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3652 int32_t utf16_length = dex_file.GetStringLength(string_id);
3653 const char* utf8_data = dex_file.GetStringData(string_id);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003654 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003655 dex_cache->SetResolvedString(string_idx, string);
3656 return string;
3657}
3658
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003659mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
3660 uint16_t type_idx,
3661 mirror::DexCache* dex_cache,
3662 mirror::ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003663 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003664 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003665 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003666 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003667 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003668 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003669 // TODO: we used to throw here if resolved's class loader was not the
3670 // boot class loader. This was to permit different classes with the
3671 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003672 dex_cache->SetResolvedType(type_idx, resolved);
3673 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003674 Thread* self = Thread::Current();
3675 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08003676 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08003677 // Convert a ClassNotFoundException to a NoClassDefFoundError.
3678 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
3679 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
jeffhao8cd6dda2012-02-22 10:15:34 -08003680 Thread::Current()->ClearException();
3681 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Ian Rogers62d6c772013-02-27 08:32:07 -08003682 self->GetException(NULL)->SetCause(cause.get());
jeffhao8cd6dda2012-02-22 10:15:34 -08003683 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003684 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003685 }
3686 return resolved;
3687}
3688
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003689mirror::AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
3690 uint32_t method_idx,
3691 mirror::DexCache* dex_cache,
3692 mirror::ClassLoader* class_loader,
3693 const mirror::AbstractMethod* referrer,
3694 InvokeType type) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003695 DCHECK(dex_cache != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07003696 // Check for hit in the dex cache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003697 mirror::AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003698 if (resolved != NULL) {
3699 return resolved;
3700 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003701 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003702 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003703 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003704 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003705 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003706 return NULL;
3707 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003708 // Scan using method_idx, this saves string compares but will only hit for matching dex
3709 // caches/files.
3710 switch (type) {
3711 case kDirect: // Fall-through.
3712 case kStatic:
3713 resolved = klass->FindDirectMethod(dex_cache, method_idx);
3714 break;
3715 case kInterface:
3716 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Ian Rogers4c5b2652012-12-15 21:36:16 -08003717 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07003718 break;
3719 case kSuper: // Fall-through.
3720 case kVirtual:
3721 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
3722 break;
3723 default:
3724 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003725 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003726 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07003727 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003728 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3729 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
Ian Rogers08f753d2012-08-24 14:35:25 -07003730 switch (type) {
3731 case kDirect: // Fall-through.
3732 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08003733 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003734 break;
3735 case kInterface:
3736 resolved = klass->FindInterfaceMethod(name, signature);
Ian Rogers4c5b2652012-12-15 21:36:16 -08003737 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07003738 break;
3739 case kSuper: // Fall-through.
3740 case kVirtual:
3741 resolved = klass->FindVirtualMethod(name, signature);
3742 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003743 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003744 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003745 if (resolved != NULL) {
3746 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07003747 if (resolved->CheckIncompatibleClassChange(type)) {
3748 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07003749 }
3750 }
3751 if (resolved != NULL) {
3752 // Be a good citizen and update the dex cache to speed subsequent calls.
3753 dex_cache->SetResolvedMethod(method_idx, resolved);
3754 return resolved;
3755 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07003756 // We failed to find the method which means either an access error, an incompatible class
3757 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07003758 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3759 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3760 switch (type) {
3761 case kDirect:
3762 case kStatic:
3763 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07003764 break;
3765 case kInterface:
3766 case kVirtual:
3767 case kSuper:
3768 resolved = klass->FindDirectMethod(name, signature);
3769 break;
3770 }
3771
3772 // If we found something, check that it can be accessed by the referrer.
3773 if (resolved != NULL && referrer != NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003774 mirror::Class* methods_class = resolved->GetDeclaringClass();
3775 mirror::Class* referring_class = referrer->GetDeclaringClass();
jeffhaoc0228b82012-08-29 18:15:05 -07003776 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003777 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
3778 referrer, resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07003779 return NULL;
3780 } else if (!referring_class->CanAccessMember(methods_class,
3781 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003782 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07003783 return NULL;
3784 }
3785 }
3786
3787 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
3788 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
3789 switch (type) {
3790 case kDirect:
3791 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07003792 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003793 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003794 } else {
3795 resolved = klass->FindInterfaceMethod(name, signature);
3796 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003797 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003798 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003799 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003800 }
3801 }
3802 break;
3803 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07003804 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003805 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003806 } else {
3807 resolved = klass->FindVirtualMethod(name, signature);
3808 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003809 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003810 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003811 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003812 }
3813 }
3814 break;
3815 case kSuper:
Ian Rogers62d6c772013-02-27 08:32:07 -08003816 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003817 break;
3818 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07003819 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003820 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003821 } else {
3822 resolved = klass->FindInterfaceMethod(name, signature);
3823 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003824 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003825 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003826 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003827 }
3828 }
3829 break;
3830 }
3831 DCHECK(Thread::Current()->IsExceptionPending());
3832 return NULL;
3833 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003834}
3835
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003836mirror::Field* ClassLinker::ResolveField(const DexFile& dex_file,
3837 uint32_t field_idx,
3838 mirror::DexCache* dex_cache,
3839 mirror::ClassLoader* class_loader,
3840 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003841 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003842 mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003843 if (resolved != NULL) {
3844 return resolved;
3845 }
3846 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003847 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003848 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003849 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003850 return NULL;
3851 }
3852
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003853 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003854 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003855 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003856 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003857 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003858
3859 if (resolved == NULL) {
3860 const char* name = dex_file.GetFieldName(field_id);
3861 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3862 if (is_static) {
3863 resolved = klass->FindStaticField(name, type);
3864 } else {
3865 resolved = klass->FindInstanceField(name, type);
3866 }
3867 if (resolved == NULL) {
3868 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3869 return NULL;
3870 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003871 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003872 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003873 return resolved;
3874}
3875
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003876mirror::Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3877 uint32_t field_idx,
3878 mirror::DexCache* dex_cache,
3879 mirror::ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003880 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003881 mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
Ian Rogersb067ac22011-12-13 18:05:09 -08003882 if (resolved != NULL) {
3883 return resolved;
3884 }
3885 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003886 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Ian Rogersb067ac22011-12-13 18:05:09 -08003887 if (klass == NULL) {
3888 DCHECK(Thread::Current()->IsExceptionPending());
3889 return NULL;
3890 }
3891
3892 const char* name = dex_file.GetFieldName(field_id);
3893 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3894 resolved = klass->FindField(name, type);
3895 if (resolved != NULL) {
3896 dex_cache->SetResolvedField(field_idx, resolved);
3897 } else {
3898 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003899 }
3900 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003901}
3902
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003903const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer,
3904 uint32_t* length) {
3905 mirror::Class* declaring_class = referrer->GetDeclaringClass();
3906 mirror::DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07003907 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07003908 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003909 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003910}
3911
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003912void ClassLinker::DumpAllClasses(int flags) const {
3913 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3914 // 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 -08003915 std::vector<mirror::Class*> all_classes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003916 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003917 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003918 typedef Table::const_iterator It; // TODO: C++0x auto
3919 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3920 all_classes.push_back(it->second);
3921 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003922 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3923 all_classes.push_back(it->second);
3924 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003925 }
3926
3927 for (size_t i = 0; i < all_classes.size(); ++i) {
3928 all_classes[i]->DumpClass(std::cerr, flags);
3929 }
3930}
3931
Elliott Hughescac6cc72011-11-03 20:31:21 -07003932void ClassLinker::DumpForSigQuit(std::ostream& os) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003933 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -07003934 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3935 << classes_.size() << " allocated classes\n";
3936}
3937
Elliott Hughese27955c2011-08-26 15:21:24 -07003938size_t ClassLinker::NumLoadedClasses() const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003939 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003940 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003941}
3942
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003943pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07003944 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003945}
3946
3947pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003948 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003949}
3950
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003951void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003952 DCHECK(!init_done_);
3953
3954 DCHECK(klass != NULL);
3955 DCHECK(klass->GetClassLoader() == NULL);
3956
3957 DCHECK(class_roots_ != NULL);
3958 DCHECK(class_roots_->Get(class_root) == NULL);
3959 class_roots_->Set(class_root, klass);
3960}
3961
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003962} // namespace art