blob: 06ae301ce882624fa7fd2cbaf13908fbc6b0cd3a [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
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070030#include "casts.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070031#include "class_loader.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080032#include "debugger.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070033#include "dex_cache.h"
Elliott Hughes90a33692011-08-30 13:27:07 -070034#include "dex_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070035#include "dex_verifier.h"
36#include "heap.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070037#include "intern_table.h"
Ian Rogers0571d352011-11-03 19:51:38 -070038#include "leb128.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070039#include "logging.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070040#include "oat_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070041#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080042#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080043#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070044#include "runtime.h"
Ian Rogers466bb252011-10-14 03:29:56 -070045#include "runtime_support.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -070046#include "ScopedLocalRef.h"
Brian Carlstroma663ea52011-08-19 23:33:41 -070047#include "space.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070048#include "stack_indirect_reference_table.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070049#include "stl_util.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070050#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070051#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070052#include "utils.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070053
54namespace art {
55
Elliott Hughes4a2b4172011-09-20 17:08:25 -070056namespace {
57
Elliott Hughes362f9bc2011-10-17 18:56:41 -070058void ThrowNoClassDefFoundError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
Elliott Hughes4a2b4172011-09-20 17:08:25 -070059void ThrowNoClassDefFoundError(const char* fmt, ...) {
60 va_list args;
61 va_start(args, fmt);
62 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
63 va_end(args);
64}
65
Elliott Hughes362f9bc2011-10-17 18:56:41 -070066void ThrowClassFormatError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
Elliott Hughese555dc02011-09-25 10:46:35 -070067void ThrowClassFormatError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070068 va_list args;
69 va_start(args, fmt);
Elliott Hughese555dc02011-09-25 10:46:35 -070070 Thread::Current()->ThrowNewExceptionV("Ljava/lang/ClassFormatError;", fmt, args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -070071 va_end(args);
72}
73
Elliott Hughes362f9bc2011-10-17 18:56:41 -070074void ThrowLinkageError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
Elliott Hughes4a2b4172011-09-20 17:08:25 -070075void ThrowLinkageError(const char* fmt, ...) {
76 va_list args;
77 va_start(args, fmt);
78 Thread::Current()->ThrowNewExceptionV("Ljava/lang/LinkageError;", fmt, args);
79 va_end(args);
80}
81
Ian Rogers9f1ab122011-12-12 08:52:43 -080082void ThrowNoSuchMethodError(bool is_direct, Class* c, const StringPiece& name,
83 const StringPiece& signature) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080084 ClassHelper kh(c);
Elliott Hughes3b6baaa2011-10-14 19:13:56 -070085 std::ostringstream msg;
Ian Rogersc8b306f2012-02-17 21:34:44 -080086 msg << "no " << (is_direct ? "direct" : "virtual") << " method " << name << signature
Ian Rogers9f1ab122011-12-12 08:52:43 -080087 << " in class " << kh.GetDescriptor() << " or its superclasses";
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080088 std::string location(kh.GetLocation());
89 if (!location.empty()) {
90 msg << " (defined in " << location << ")";
Elliott Hughescc5f9a92011-09-28 19:17:29 -070091 }
Elliott Hughes5cb5ad22011-10-02 12:13:39 -070092 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
Elliott Hughescc5f9a92011-09-28 19:17:29 -070093}
94
Ian Rogersb067ac22011-12-13 18:05:09 -080095void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
Ian Rogers9f1ab122011-12-12 08:52:43 -080096 const StringPiece& name) {
97 ClassHelper kh(c);
98 std::ostringstream msg;
Ian Rogersb067ac22011-12-13 18:05:09 -080099 msg << "no " << scope << "field " << name << " of type " << type
Ian Rogers9f1ab122011-12-12 08:52:43 -0800100 << " in class " << kh.GetDescriptor() << " or its superclasses";
101 std::string location(kh.GetLocation());
102 if (!location.empty()) {
103 msg << " (defined in " << location << ")";
104 }
105 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
106}
107
Ian Rogerscab01012012-01-10 17:35:46 -0800108void ThrowNullPointerException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
109void ThrowNullPointerException(const char* fmt, ...) {
110 va_list args;
111 va_start(args, fmt);
112 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NullPointerException;", fmt, args);
113 va_end(args);
114}
115
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700116void ThrowEarlierClassFailure(Class* c) {
117 /*
118 * The class failed to initialize on a previous attempt, so we want to throw
119 * a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
120 * failed in verification, in which case v2 5.4.1 says we need to re-throw
121 * the previous error.
122 */
123 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
124
Brian Carlstrom4d9716c2012-01-30 01:49:33 -0800125 CHECK(c->IsErroneous()) << PrettyClass(c);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700126 if (c->GetVerifyErrorClass() != NULL) {
127 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800128 ClassHelper ve_ch(c->GetVerifyErrorClass());
129 std::string error_descriptor(ve_ch.GetDescriptor());
130 Thread::Current()->ThrowNewException(error_descriptor.c_str(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700131 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800132 ThrowNoClassDefFoundError("%s", PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700133 }
134}
135
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700136void WrapExceptionInInitializer() {
137 JNIEnv* env = Thread::Current()->GetJniEnv();
138
139 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
140 CHECK(cause.get() != NULL);
141
142 env->ExceptionClear();
143
144 // TODO: add java.lang.Error to JniConstants?
145 ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/Error"));
146 CHECK(error_class.get() != NULL);
147 if (env->IsInstanceOf(cause.get(), error_class.get())) {
148 // We only wrap non-Error exceptions; an Error can just be used as-is.
149 env->Throw(cause.get());
150 return;
151 }
152
153 // TODO: add java.lang.ExceptionInInitializerError to JniConstants?
154 ScopedLocalRef<jclass> eiie_class(env, env->FindClass("java/lang/ExceptionInInitializerError"));
155 CHECK(eiie_class.get() != NULL);
156
157 jmethodID mid = env->GetMethodID(eiie_class.get(), "<init>" , "(Ljava/lang/Throwable;)V");
158 CHECK(mid != NULL);
159
160 ScopedLocalRef<jthrowable> eiie(env,
161 reinterpret_cast<jthrowable>(env->NewObject(eiie_class.get(), mid, cause.get())));
162 env->Throw(eiie.get());
163}
164
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800165static size_t Hash(const char* s) {
166 // This is the java.lang.String hashcode for convenience, not interoperability.
167 size_t hash = 0;
168 for (; *s != '\0'; ++s) {
169 hash = hash * 31 + *s;
170 }
171 return hash;
172}
173
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700174} // namespace
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700175
Elliott Hughes418d20f2011-09-22 14:00:39 -0700176const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700177 "Ljava/lang/Class;",
178 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700179 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700180 "[Ljava/lang/Object;",
181 "Ljava/lang/String;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700182 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700183 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700184 "Ljava/lang/reflect/Field;",
185 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700186 "Ljava/lang/reflect/Proxy;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700187 "Ljava/lang/ClassLoader;",
188 "Ldalvik/system/BaseDexClassLoader;",
189 "Ldalvik/system/PathClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800190 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800191 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700192 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700193 "Z",
194 "B",
195 "C",
196 "D",
197 "F",
198 "I",
199 "J",
200 "S",
201 "V",
202 "[Z",
203 "[B",
204 "[C",
205 "[D",
206 "[F",
207 "[I",
208 "[J",
209 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700210 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700211};
212
Brian Carlstroma004aa92012-02-08 18:05:09 -0800213ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
214 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700215 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800216 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800217 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700218 return class_linker.release();
219}
220
Brian Carlstroma004aa92012-02-08 18:05:09 -0800221ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800222 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700223 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700224 return class_linker.release();
225}
226
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800227ClassLinker::ClassLinker(InternTable* intern_table)
228 : dex_lock_("ClassLinker dex lock"),
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700229 classes_lock_("ClassLinker classes lock"),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700230 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700231 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700232 init_done_(false),
233 intern_table_(intern_table) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700234 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700235}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700236
Brian Carlstroma004aa92012-02-08 18:05:09 -0800237void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
238 VLOG(startup) << "ClassLinker::Init";
239 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700240
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700241 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700242
Elliott Hughes30646832011-10-13 16:59:46 -0700243 // java_lang_Class comes first, it's needed for AllocClass
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800244 Heap* heap = Runtime::Current()->GetHeap();
245 SirtRef<Class> java_lang_Class(down_cast<Class*>(heap->AllocObject(NULL, sizeof(ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700246 CHECK(java_lang_Class.get() != NULL);
247 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700248 java_lang_Class->SetClassSize(sizeof(ClassClass));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700249 // AllocClass(Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700250
Elliott Hughes418d20f2011-09-22 14:00:39 -0700251 // Class[] is used for reflection support.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700252 SirtRef<Class> class_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
253 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700254
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700255 // java_lang_Object comes next so that object_array_class can be created
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700256 SirtRef<Class> java_lang_Object(AllocClass(java_lang_Class.get(), sizeof(Class)));
257 CHECK(java_lang_Object.get() != NULL);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700258 // backfill Object as the super class of Class
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700259 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700260 java_lang_Object->SetStatus(Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700261
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700262 // Object[] next to hold class roots
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700263 SirtRef<Class> object_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
264 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700265
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700266 // Setup the char class to be used for char[]
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700267 SirtRef<Class> char_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700268
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700269 // Setup the char[] class to be used for String
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700270 SirtRef<Class> char_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
271 char_array_class->SetComponentType(char_class.get());
272 CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700273
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700274 // Setup String
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700275 SirtRef<Class> java_lang_String(AllocClass(java_lang_Class.get(), sizeof(StringClass)));
276 String::SetClass(java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700277 java_lang_String->SetObjectSize(sizeof(String));
278 java_lang_String->SetStatus(Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400279
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700280 // Create storage for root classes, save away our work so far (requires
281 // descriptors)
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700282 class_roots_ = ObjectArray<Class>::Alloc(object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700283 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700284 SetClassRoot(kJavaLangClass, java_lang_Class.get());
285 SetClassRoot(kJavaLangObject, java_lang_Object.get());
286 SetClassRoot(kClassArrayClass, class_array_class.get());
287 SetClassRoot(kObjectArrayClass, object_array_class.get());
288 SetClassRoot(kCharArrayClass, char_array_class.get());
289 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700290
291 // Setup the primitive type classes.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700292 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass("Z", Primitive::kPrimBoolean));
293 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass("B", Primitive::kPrimByte));
294 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass("S", Primitive::kPrimShort));
295 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass("I", Primitive::kPrimInt));
296 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass("J", Primitive::kPrimLong));
297 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass("F", Primitive::kPrimFloat));
298 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass("D", Primitive::kPrimDouble));
299 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass("V", Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700300
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700301 // Create array interface entries to populate once we can load system classes
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700302 array_iftable_ = AllocObjectArray<InterfaceEntry>(2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700303
304 // Create int array type for AllocDexCache (done in AppendToBootClassPath)
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700305 SirtRef<Class> int_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700306 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700307 IntArray::SetArrayClass(int_array_class.get());
308 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700309
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700310 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700311
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700312 // setup boot_class_path_ and register class_path now that we can
313 // use AllocObjectArray to create DexCache instances
Brian Carlstroma004aa92012-02-08 18:05:09 -0800314 CHECK_NE(0U, boot_class_path.size());
315 for (size_t i = 0; i != boot_class_path.size(); ++i) {
316 const DexFile* dex_file = boot_class_path[i];
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700317 CHECK(dex_file != NULL);
318 AppendToBootClassPath(*dex_file);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700319 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700320
Elliott Hughes80609252011-09-23 17:24:51 -0700321 // Constructor, Field, and Method are necessary so that FindClass can link members
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700322 SirtRef<Class> java_lang_reflect_Constructor(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700323 CHECK(java_lang_reflect_Constructor.get() != NULL);
Elliott Hughes80609252011-09-23 17:24:51 -0700324 java_lang_reflect_Constructor->SetObjectSize(sizeof(Method));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700325 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
Elliott Hughes80609252011-09-23 17:24:51 -0700326 java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
327
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700328 SirtRef<Class> java_lang_reflect_Field(AllocClass(java_lang_Class.get(), sizeof(FieldClass)));
329 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700330 java_lang_reflect_Field->SetObjectSize(sizeof(Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700331 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700332 java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700333 Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700334
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700335 SirtRef<Class> java_lang_reflect_Method(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700336 CHECK(java_lang_reflect_Method.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700337 java_lang_reflect_Method->SetObjectSize(sizeof(Method));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700338 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700339 java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700340 Method::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700341
342 // now we can use FindSystemClass
343
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700344 // run char class through InitializePrimitiveClass to finish init
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700345 InitializePrimitiveClass(char_class.get(), "C", Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700346 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700347
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700348 // Object and String need to be rerun through FindSystemClass to finish init
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700349 java_lang_Object->SetStatus(Class::kStatusNotReady);
350 Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700351 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700352 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(Object));
353 java_lang_String->SetStatus(Class::kStatusNotReady);
354 Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700355 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700356 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
357
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700358 // Setup the primitive array type classes - can't be done until Object has a vtable
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700359 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
360 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
361
362 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
363 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
364
365 Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700366 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700367
368 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
369 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
370
371 Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700372 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700373
374 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
375 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
376
377 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
378 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
379
380 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
381 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
382
Elliott Hughes418d20f2011-09-22 14:00:39 -0700383 Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700384 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700385
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700386 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700387 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700388
389 // Setup the single, global copies of "interfaces" and "iftable"
390 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
391 CHECK(java_lang_Cloneable != NULL);
392 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
393 CHECK(java_io_Serializable != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700394 // We assume that Cloneable/Serializable don't have superinterfaces --
395 // normally we'd have to crawl up and explicitly list all of the
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700396 // supers as well.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800397 array_iftable_->Set(0, AllocInterfaceEntry(java_lang_Cloneable));
398 array_iftable_->Set(1, AllocInterfaceEntry(java_io_Serializable));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700399
Elliott Hughes418d20f2011-09-22 14:00:39 -0700400 // Sanity check Class[] and Object[]'s interfaces
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800401 ClassHelper kh(class_array_class.get(), this);
402 CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
403 CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
404 kh.ChangeClass(object_array_class.get());
405 CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
406 CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
Elliott Hughes80609252011-09-23 17:24:51 -0700407 // run Class, Constructor, Field, and Method through FindSystemClass.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700408 // this initializes their dex_cache_ fields and register them in classes_.
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700409 Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700410 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700411
Elliott Hughes80609252011-09-23 17:24:51 -0700412 java_lang_reflect_Constructor->SetStatus(Class::kStatusNotReady);
413 Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700414 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700415
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700416 java_lang_reflect_Field->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700417 Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700418 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700419
420 java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700421 Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700422 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700423
Ian Rogers466bb252011-10-14 03:29:56 -0700424 // End of special init trickery, subsequent classes may be loaded via FindSystemClass
425
426 // Create java.lang.reflect.Proxy root
427 Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
428 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
429
Brian Carlstrom1f870082011-08-23 16:02:11 -0700430 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700431 Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
432 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700433 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700434 java_lang_ref_FinalizerReference->SetAccessFlags(
435 java_lang_ref_FinalizerReference->GetAccessFlags() |
436 kAccClassIsReference | kAccClassIsFinalizerReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700437 Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700438 java_lang_ref_PhantomReference->SetAccessFlags(
439 java_lang_ref_PhantomReference->GetAccessFlags() |
440 kAccClassIsReference | kAccClassIsPhantomReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700441 Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700442 java_lang_ref_SoftReference->SetAccessFlags(
443 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700444 Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700445 java_lang_ref_WeakReference->SetAccessFlags(
446 java_lang_ref_WeakReference->GetAccessFlags() |
447 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700448
Brian Carlstromaded5f72011-10-07 17:15:04 -0700449 // Setup the ClassLoaders, verifying the object_size_
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700450 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
Brian Carlstromaded5f72011-10-07 17:15:04 -0700451 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700452 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
453
454 Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
455 CHECK_EQ(dalvik_system_BaseDexClassLoader->GetObjectSize(), sizeof(BaseDexClassLoader));
456 SetClassRoot(kDalvikSystemBaseDexClassLoader, dalvik_system_BaseDexClassLoader);
457
458 Class* dalvik_system_PathClassLoader = FindSystemClass("Ldalvik/system/PathClassLoader;");
459 CHECK_EQ(dalvik_system_PathClassLoader->GetObjectSize(), sizeof(PathClassLoader));
460 SetClassRoot(kDalvikSystemPathClassLoader, dalvik_system_PathClassLoader);
461 PathClassLoader::SetClass(dalvik_system_PathClassLoader);
462
jeffhao8cd6dda2012-02-22 10:15:34 -0800463 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
464 // java.lang.StackTraceElement as a convenience
Ian Rogers5167c972012-02-03 10:41:20 -0800465 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
466 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800467 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700468 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
469 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700470 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700471
Brian Carlstroma663ea52011-08-19 23:33:41 -0700472 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700473
Brian Carlstroma004aa92012-02-08 18:05:09 -0800474 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700475}
476
477void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800478 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700479
480 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700481 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700482 // as the types of the field can't be resolved prior to the runtime being
483 // fully initialized
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700484 Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700485 Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700486 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
487
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800488 Heap* heap = Runtime::Current()->GetHeap();
489 heap->SetWellKnownClasses(java_lang_ref_FinalizerReference, java_lang_ref_ReferenceQueue);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700490
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800491 const DexFile& java_lang_dex = FindDexFile(java_lang_ref_Reference->GetDexCache());
492
Brian Carlstrom16192862011-09-12 17:50:06 -0700493 Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800494 FieldHelper fh(pendingNext, this);
495 CHECK_STREQ(fh.GetName(), "pendingNext");
496 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
497 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700498
499 Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800500 fh.ChangeField(queue);
501 CHECK_STREQ(fh.GetName(), "queue");
502 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
503 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700504
505 Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800506 fh.ChangeField(queueNext);
507 CHECK_STREQ(fh.GetName(), "queueNext");
508 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
509 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700510
511 Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800512 fh.ChangeField(referent);
513 CHECK_STREQ(fh.GetName(), "referent");
514 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
515 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700516
517 Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800518 fh.ChangeField(zombie);
519 CHECK_STREQ(fh.GetName(), "zombie");
520 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
521 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700522
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800523 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700524 queue->GetOffset(),
525 queueNext->GetOffset(),
526 pendingNext->GetOffset(),
527 zombie->GetOffset());
528
Brian Carlstroma663ea52011-08-19 23:33:41 -0700529 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700530 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700531 ClassRoot class_root = static_cast<ClassRoot>(i);
532 Class* klass = GetClassRoot(class_root);
533 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700534 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700535 // note SetClassRoot does additional validation.
536 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700537 }
538
Elliott Hughes92f14b22011-10-06 12:29:54 -0700539 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700540
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700541 // disable the slow paths in FindClass and CreatePrimitiveClass now
542 // that Object, Class, and Object[] are setup
543 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700544
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800545 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700546}
547
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700548void ClassLinker::RunRootClinits() {
549 Thread* self = Thread::Current();
550 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
551 Class* c = GetClassRoot(ClassRoot(i));
552 if (!c->IsArrayClass() && !c->IsPrimitive()) {
553 EnsureInitialized(GetClassRoot(ClassRoot(i)), true);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -0700554 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700555 }
556 }
557}
558
Brian Carlstromd601af82012-01-06 10:15:19 -0800559bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
560 int oat_fd,
561 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800562 std::string dex2oat_string(GetAndroidRoot());
563 dex2oat_string += "/bin/dex2oat";
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800564#ifndef NDEBUG
565 dex2oat_string += 'd';
566#endif
567 const char* dex2oat = dex2oat_string.c_str();
568
Brian Carlstroma004aa92012-02-08 18:05:09 -0800569 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800570
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800571 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800572 std::string boot_image_option_string("--boot-image=");
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800573 boot_image_option_string += heap->GetSpaces()[0]->AsImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800574 const char* boot_image_option = boot_image_option_string.c_str();
575
576 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800577 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800578 const char* dex_file_option = dex_file_option_string.c_str();
579
Brian Carlstromd601af82012-01-06 10:15:19 -0800580 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800581 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800582 const char* oat_fd_option = oat_fd_option_string.c_str();
583
Brian Carlstroma004aa92012-02-08 18:05:09 -0800584 std::string oat_location_option_string("--oat-location=");
585 oat_location_option_string += oat_cache_filename;
586 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800587
jeffhao262bf462011-10-20 18:36:32 -0700588 // fork and exec dex2oat
589 pid_t pid = fork();
590 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800591 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800592
593 // change process groups, so we don't get reaped by ProcessManager
594 setpgid(0, 0);
595
jeffhao10037c82012-01-23 15:06:23 -0800596 VLOG(class_linker) << dex2oat
597 << " --runtime-arg -Xms64m"
598 << " --runtime-arg -Xmx64m"
599 << " --runtime-arg -classpath"
600 << " --runtime-arg " << class_path
601 << " " << boot_image_option
602 << " " << dex_file_option
603 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800604 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800605
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800606 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700607 "--runtime-arg", "-Xms64m",
608 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500609 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800610 "--runtime-arg", class_path,
611 boot_image_option,
612 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800613 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800614 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700615 NULL);
616
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800617 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800618 return false;
jeffhao262bf462011-10-20 18:36:32 -0700619 } else {
620 // wait for dex2oat to finish
621 int status;
622 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
623 if (got_pid != pid) {
624 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800625 return false;
jeffhao262bf462011-10-20 18:36:32 -0700626 }
627 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800628 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
629 return false;
jeffhao262bf462011-10-20 18:36:32 -0700630 }
631 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800632 return true;
jeffhao262bf462011-10-20 18:36:32 -0700633}
634
Brian Carlstrom866c8622012-01-06 16:35:13 -0800635void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
636 MutexLock mu(dex_lock_);
637 RegisterOatFileLocked(oat_file);
638}
639
640void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
641 dex_lock_.AssertHeld();
642 oat_files_.push_back(&oat_file);
643}
644
Ian Rogers30fab402012-01-23 15:43:46 -0800645OatFile* ClassLinker::OpenOat(const ImageSpace* space) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700646 MutexLock mu(dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700647 const Runtime* runtime = Runtime::Current();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700648 const ImageHeader& image_header = space->GetImageHeader();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800649 // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
650 // check the down cast
651 String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700652 std::string oat_filename;
653 oat_filename += runtime->GetHostPrefix();
654 oat_filename += oat_location->ToModifiedUtf8();
Brian Carlstroma004aa92012-02-08 18:05:09 -0800655 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatBegin());
Ian Rogers30fab402012-01-23 15:43:46 -0800656 VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700657 if (oat_file == NULL) {
Brian Carlstroma9f19782011-10-13 00:14:47 -0700658 LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700659 return NULL;
660 }
661 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
662 uint32_t image_oat_checksum = image_header.GetOatChecksum();
663 if (oat_checksum != image_oat_checksum) {
Brian Carlstrom866c8622012-01-06 16:35:13 -0800664 LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700665 << " to expected oat checksum " << std::hex << oat_checksum
666 << " in image";
667 return NULL;
668 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800669 RegisterOatFileLocked(*oat_file);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800670 VLOG(startup) << "ClassLinker::OpenOat exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700671 return oat_file;
672}
673
Brian Carlstromae826982011-11-09 01:33:42 -0800674const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800675 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800676}
677
Brian Carlstroma004aa92012-02-08 18:05:09 -0800678const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800679 for (size_t i = 0; i < oat_files_.size(); i++) {
680 const OatFile* oat_file = oat_files_[i];
681 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800682 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800683 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800684 return oat_file;
685 }
686 }
687 return NULL;
688}
689
Brian Carlstromd601af82012-01-06 10:15:19 -0800690class LockedFd {
691 public:
692 static LockedFd* CreateAndLock(std::string& name, mode_t mode) {
693 int fd = open(name.c_str(), O_CREAT | O_RDWR, mode);
694 if (fd == -1) {
695 PLOG(ERROR) << "Failed to open file '" << name << "'";
696 return NULL;
697 }
698 fchmod(fd, mode);
699
700 LOG(INFO) << "locking file " << name << " (fd=" << fd << ")";
701 // try to lock non-blocking so we can log if we need may need to block
702 int result = flock(fd, LOCK_EX | LOCK_NB);
703 if (result == -1) {
704 LOG(WARNING) << "sleeping while locking file " << name;
705 // retry blocking
706 result = flock(fd, LOCK_EX);
707 }
708 if (result == -1) {
709 PLOG(ERROR) << "Failed to lock file '" << name << "'";
710 close(fd);
711 return NULL;
712 }
713 return new LockedFd(fd);
714 }
715
716 int GetFd() const {
717 return fd_;
718 }
719
720 ~LockedFd() {
721 if (fd_ != -1) {
722 int result = flock(fd_, LOCK_UN);
723 if (result == -1) {
724 PLOG(WARNING) << "flock(" << fd_ << ", LOCK_UN) failed";
725 }
726 close(fd_);
727 }
728 }
729
730 private:
731 explicit LockedFd(int fd) : fd_(fd) {}
732
733 int fd_;
734};
735
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800736static const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
737 uint32_t dex_location_checksum,
738 const std::string& oat_location) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800739 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800740 if (oat_file.get() == NULL) {
741 return NULL;
742 }
743 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
744 if (oat_dex_file == NULL) {
745 return NULL;
746 }
747 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
748 return NULL;
749 }
750 Runtime::Current()->GetClassLinker()->RegisterOatFile(*oat_file.release());
751 return oat_dex_file->OpenDexFile();
752}
753
754const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
755 const std::string& oat_location) {
756 uint32_t dex_location_checksum;
757 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
758 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
759 return NULL;
760 }
761
762 // Check if we already have an up-to-date output file
763 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
764 dex_location_checksum,
765 oat_location);
766 if (dex_file != NULL) {
767 return dex_file;
768 }
769
770 // Generate the output oat file for the dex file
771 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
772 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
773 if (file.get() == NULL) {
774 LOG(ERROR) << "Failed to create oat file: " << oat_location;
775 return NULL;
776 }
777 if (!class_linker->GenerateOatFile(dex_location, file->Fd(), oat_location)) {
778 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
779 return NULL;
780 }
781 // Open the oat from file descriptor we passed to GenerateOatFile
782 if (lseek(file->Fd(), 0, SEEK_SET) != 0) {
783 LOG(ERROR) << "Failed to seek to start of generated oat file: " << oat_location;
784 return NULL;
785 }
786 const OatFile* oat_file = OatFile::Open(*file.get(), oat_location, NULL);
787 if (oat_file == NULL) {
788 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
789 return NULL;
790 }
791 class_linker->RegisterOatFile(*oat_file);
792 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
793 if (oat_dex_file == NULL) {
794 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
795 return NULL;
796 }
797 return oat_dex_file->OpenDexFile();
798}
799
800const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700801 MutexLock mu(dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800802
Brian Carlstroma004aa92012-02-08 18:05:09 -0800803 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800804 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800805 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800806 }
807
Brian Carlstroma004aa92012-02-08 18:05:09 -0800808 // Look for an existing file next to dex, assuming its up-to-date if found
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800809 std::string oat_filename(OatFile::DexFilenameToOatFilename(dex_location));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800810 const OatFile* oat_file = FindOatFileFromOatLocation(oat_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800811 if (oat_file != NULL) {
812 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800813 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
814 return oat_dex_file->OpenDexFile();
815 }
816 // Look for an existing file in the art-cache, validating the result if found
817 // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
818 std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
819 oat_file = FindOatFileFromOatLocation(cache_location);
820 if (oat_file != NULL) {
821 uint32_t dex_location_checksum;
822 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
823 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
824 return NULL;
825 }
826 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
827 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800828 if (dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum()) {
829 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Elliott Hughesed6d78e2011-10-25 17:35:14 -0700830 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800831 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
832 << " checksum ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
833 << ") mismatch with " << dex_location
834 << " (" << std::hex << dex_location_checksum << ")--- regenerating";
835 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
836 PLOG(FATAL) << "Couldn't remove obsolete .oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800837 }
jeffhao262bf462011-10-20 18:36:32 -0700838 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800839 LOG(INFO) << "Failed to open oat file from " << oat_filename << " or " << cache_location << ".";
840
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800841 // Try to generate oat file if it wasn't found or was obsolete.
842 std::string oat_cache_filename(GetArtCacheFilenameOrDie(oat_filename));
843 return FindOrCreateOatFileForDexLocation(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700844}
845
Brian Carlstromae826982011-11-09 01:33:42 -0800846const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700847 for (size_t i = 0; i < oat_files_.size(); i++) {
848 const OatFile* oat_file = oat_files_[i];
849 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800850 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700851 return oat_file;
852 }
853 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700854 return NULL;
855}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700856
Brian Carlstromae826982011-11-09 01:33:42 -0800857const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800858 MutexLock mu(dex_lock_);
859 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
860 if (oat_file != NULL) {
861 return oat_file;
862 }
863
Brian Carlstroma004aa92012-02-08 18:05:09 -0800864 oat_file = OatFile::Open(oat_location, oat_location, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700865 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800866 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700867 }
Brian Carlstromae826982011-11-09 01:33:42 -0800868 CHECK(oat_file != NULL) << oat_location;
jeffhaof6174e82012-01-31 16:14:17 -0800869 RegisterOatFileLocked(*oat_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700870 return oat_file;
871}
872
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700873void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800874 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700875 CHECK(!init_done_);
876
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800877 Heap* heap = Runtime::Current()->GetHeap();
878 const std::vector<Space*>& spaces = heap->GetSpaces();
879 for (size_t i = 0; i < spaces.size(); ++i) {
Ian Rogers30fab402012-01-23 15:43:46 -0800880 if (spaces[i]->IsImageSpace()) {
881 ImageSpace* space = spaces[i]->AsImageSpace();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700882 OatFile* oat_file = OpenOat(space);
883 CHECK(oat_file != NULL) << "Failed to open oat file for image";
884 Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
885 ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
886
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800887 if (i == 0) {
888 // Special case of setting up the String class early so that we can test arbitrary objects
889 // as being Strings or not
Ian Rogers30fab402012-01-23 15:43:46 -0800890 Class* java_lang_String = space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800891 ->AsObjectArray<Class>()->Get(kJavaLangString);
892 String::SetClass(java_lang_String);
893 }
894
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700895 CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
896 static_cast<uint32_t>(dex_caches->GetLength()));
897 for (int i = 0; i < dex_caches->GetLength(); i++) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700898 SirtRef<DexCache> dex_cache(dex_caches->Get(i));
Elliott Hughes95572412011-12-13 18:14:20 -0800899 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Brian Carlstrom89521892011-12-07 22:05:07 -0800900 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
901 const DexFile* dex_file = oat_dex_file->OpenDexFile();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700902 if (dex_file == NULL) {
Brian Carlstrom89521892011-12-07 22:05:07 -0800903 LOG(FATAL) << "Failed to open dex file " << dex_file_location
904 << " from within oat file " << oat_file->GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700905 }
906
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800907 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700908
Brian Carlstromdf143242011-10-10 18:05:34 -0700909 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700910 }
911 }
912 }
913
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800914 HeapBitmap* heap_bitmap = heap->GetLiveBits();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700915 DCHECK(heap_bitmap != NULL);
916
Brian Carlstroma663ea52011-08-19 23:33:41 -0700917 // reinit clases_ table
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700918 heap_bitmap->Walk(InitFromImageCallback, this);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700919
920 // reinit class_roots_
Ian Rogers30fab402012-01-23 15:43:46 -0800921 Object* class_roots_object =
922 spaces[0]->AsImageSpace()->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots);
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700923 class_roots_ = class_roots_object->AsObjectArray<Class>();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700924
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800925 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -0700926 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
927 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800928 // String class root was set above
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700929 Field::SetClass(GetClassRoot(kJavaLangReflectField));
Elliott Hughes80609252011-09-23 17:24:51 -0700930 Method::SetClasses(GetClassRoot(kJavaLangReflectConstructor), GetClassRoot(kJavaLangReflectMethod));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700931 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
932 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
933 CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
934 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
935 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
936 IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
937 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
938 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700939 PathClassLoader::SetClass(GetClassRoot(kDalvikSystemPathClassLoader));
Ian Rogers5167c972012-02-03 10:41:20 -0800940 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700941 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700942
943 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700944
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800945 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700946}
947
Brian Carlstrom78128a62011-09-15 17:21:19 -0700948void ClassLinker::InitFromImageCallback(Object* obj, void* arg) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700949 DCHECK(obj != NULL);
950 DCHECK(arg != NULL);
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700951 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700952
Elliott Hughesdbb40792011-11-18 17:05:22 -0800953 if (obj->GetClass()->IsStringClass()) {
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700954 class_linker->intern_table_->RegisterStrong(obj->AsString());
Brian Carlstromc74255f2011-09-11 22:47:39 -0700955 return;
956 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700957 if (obj->IsClass()) {
958 // restore class to ClassLinker::classes_ table
959 Class* klass = obj->AsClass();
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800960 ClassHelper kh(klass, class_linker);
Brian Carlstrom07bb8552012-01-18 22:10:50 -0800961 Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
962 DCHECK(existing == NULL) << kh.GetDescriptor();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700963 return;
964 }
Brian Carlstroma663ea52011-08-19 23:33:41 -0700965}
966
967// Keep in sync with InitCallback. Anything we visit, we need to
968// reinit references to when reinitializing a ClassLinker from a
969// mapped image.
Elliott Hughes410c0c82011-09-01 17:58:25 -0700970void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
971 visitor(class_roots_, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700972
973 for (size_t i = 0; i < dex_caches_.size(); i++) {
Elliott Hughes410c0c82011-09-01 17:58:25 -0700974 visitor(dex_caches_[i], arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700975 }
976
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700977 {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700978 MutexLock mu(classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700979 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700980 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -0700981 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700982 }
Ian Rogers5d76c432011-10-31 21:42:49 -0700983 // Note. we deliberately ignore the class roots in the image (held in image_classes_)
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700984 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700985
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700986 visitor(array_iftable_, arg);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700987}
988
Elliott Hughesa2155262011-11-16 16:26:58 -0800989void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
990 MutexLock mu(classes_lock_);
991 typedef Table::const_iterator It; // TODO: C++0x auto
992 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
993 if (!visitor(it->second, arg)) {
994 return;
995 }
996 }
997 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
998 if (!visitor(it->second, arg)) {
999 return;
1000 }
1001 }
1002}
1003
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001004ClassLinker::~ClassLinker() {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001005 String::ResetClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001006 Field::ResetClass();
Elliott Hughes80609252011-09-23 17:24:51 -07001007 Method::ResetClasses();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001008 BooleanArray::ResetArrayClass();
1009 ByteArray::ResetArrayClass();
1010 CharArray::ResetArrayClass();
1011 DoubleArray::ResetArrayClass();
1012 FloatArray::ResetArrayClass();
1013 IntArray::ResetArrayClass();
1014 LongArray::ResetArrayClass();
1015 ShortArray::ResetArrayClass();
1016 PathClassLoader::ResetClass();
Ian Rogers5167c972012-02-03 10:41:20 -08001017 Throwable::ResetClass();
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001018 StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001019 STLDeleteElements(&boot_class_path_);
1020 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001021}
1022
1023DexCache* ClassLinker::AllocDexCache(const DexFile& dex_file) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001024 SirtRef<DexCache> dex_cache(down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::LengthAsArray())));
1025 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001026 return NULL;
1027 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001028 SirtRef<String> location(intern_table_->InternStrong(dex_file.GetLocation().c_str()));
1029 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001030 return NULL;
1031 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001032 SirtRef<ObjectArray<String> > strings(AllocObjectArray<String>(dex_file.NumStringIds()));
1033 if (strings.get() == NULL) {
1034 return NULL;
1035 }
1036 SirtRef<ObjectArray<Class> > types(AllocClassArray(dex_file.NumTypeIds()));
1037 if (types.get() == NULL) {
1038 return NULL;
1039 }
1040 SirtRef<ObjectArray<Method> > methods(AllocObjectArray<Method>(dex_file.NumMethodIds()));
1041 if (methods.get() == NULL) {
1042 return NULL;
1043 }
1044 SirtRef<ObjectArray<Field> > fields(AllocObjectArray<Field>(dex_file.NumFieldIds()));
1045 if (fields.get() == NULL) {
1046 return NULL;
1047 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001048 SirtRef<ObjectArray<StaticStorageBase> > initialized_static_storage(AllocObjectArray<StaticStorageBase>(dex_file.NumTypeIds()));
1049 if (initialized_static_storage.get() == NULL) {
1050 return NULL;
1051 }
1052
1053 dex_cache->Init(location.get(),
1054 strings.get(),
1055 types.get(),
1056 methods.get(),
1057 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001058 initialized_static_storage.get());
1059 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001060}
1061
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001062InterfaceEntry* ClassLinker::AllocInterfaceEntry(Class* interface) {
1063 DCHECK(interface->IsInterface());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001064 SirtRef<ObjectArray<Object> > array(AllocObjectArray<Object>(InterfaceEntry::LengthAsArray()));
1065 SirtRef<InterfaceEntry> interface_entry(down_cast<InterfaceEntry*>(array.get()));
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001066 interface_entry->SetInterface(interface);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001067 return interface_entry.get();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001068}
1069
Brian Carlstrom4873d462011-08-21 15:23:39 -07001070Class* ClassLinker::AllocClass(Class* java_lang_Class, size_t class_size) {
1071 DCHECK_GE(class_size, sizeof(Class));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001072 Heap* heap = Runtime::Current()->GetHeap();
1073 SirtRef<Class> klass(heap->AllocObject(java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001074 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001075 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001076 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001077}
1078
Brian Carlstrom4873d462011-08-21 15:23:39 -07001079Class* ClassLinker::AllocClass(size_t class_size) {
1080 return AllocClass(GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001081}
1082
Jesse Wilson35baaab2011-08-10 16:18:03 -04001083Field* ClassLinker::AllocField() {
Brian Carlstrom1f870082011-08-23 16:02:11 -07001084 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject());
Brian Carlstroma0808032011-07-18 00:39:23 -07001085}
1086
1087Method* ClassLinker::AllocMethod() {
Brian Carlstrom1f870082011-08-23 16:02:11 -07001088 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001089}
1090
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001091ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(size_t length) {
1092 return ObjectArray<StackTraceElement>::Alloc(
1093 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1094 length);
1095}
1096
Brian Carlstromaded5f72011-10-07 17:15:04 -07001097Class* EnsureResolved(Class* klass) {
1098 DCHECK(klass != NULL);
1099 // Wait for the class if it has not already been linked.
Carl Shapirob5573532011-07-12 18:22:59 -07001100 Thread* self = Thread::Current();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001101 if (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001102 ObjectLock lock(klass);
1103 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001104 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001105 self->ThrowNewException("Ljava/lang/ClassCircularityError;",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001106 PrettyDescriptor(klass).c_str());
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001107 klass->SetStatus(Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001108 return NULL;
1109 }
1110 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001111 while (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001112 lock.Wait();
1113 }
1114 }
1115 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001116 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001117 return NULL;
1118 }
1119 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001120 CHECK(klass->IsResolved()) << PrettyClass(klass);
1121 CHECK(!self->IsExceptionPending())
1122 << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException());
1123 return klass;
1124}
1125
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001126Class* ClassLinker::FindSystemClass(const char* descriptor) {
1127 return FindClass(descriptor, NULL);
1128}
1129
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001130Class* ClassLinker::FindClass(const char* descriptor, const ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001131 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001132 Thread* self = Thread::Current();
1133 DCHECK(self != NULL);
1134 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001135 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001136 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1137 // for primitive classes that aren't backed by dex files.
1138 return FindPrimitiveClass(descriptor[0]);
1139 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001140 // Find the class in the loaded classes table.
1141 Class* klass = LookupClass(descriptor, class_loader);
1142 if (klass != NULL) {
1143 return EnsureResolved(klass);
1144 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001145 // Class is not yet loaded.
1146 if (descriptor[0] == '[') {
1147 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001148
Jesse Wilson47daf872011-11-23 11:42:45 -05001149 } else if (class_loader == NULL) {
1150 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1151 if (pair.second != NULL) {
1152 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1153 }
1154
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001155 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001156 // first try the boot class path
1157 Class* system_class = FindSystemClass(descriptor);
1158 if (system_class != NULL) {
1159 return system_class;
1160 }
1161 CHECK(self->IsExceptionPending());
1162 self->ClearException();
1163
1164 // next try the compile time class path
Brian Carlstromaded5f72011-10-07 17:15:04 -07001165 const std::vector<const DexFile*>& class_path
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001166 = Runtime::Current()->GetCompileTimeClassPath(class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001167 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001168 if (pair.second != NULL) {
1169 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001170 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001171
1172 } else {
Elliott Hughes95572412011-12-13 18:14:20 -08001173 std::string class_name_string(DescriptorToDot(descriptor));
Elliott Hughes09d4d012012-02-03 17:44:20 -08001174 ScopedThreadStateChange tsc(self, Thread::kNative);
Elliott Hughes748382f2012-01-26 18:07:38 -08001175 JNIEnv* env = self->GetJniEnv();
Jesse Wilson47daf872011-11-23 11:42:45 -05001176 ScopedLocalRef<jclass> c(env, AddLocalReference<jclass>(env, GetClassRoot(kJavaLangClassLoader)));
1177 CHECK(c.get() != NULL);
1178 // TODO: cache method?
1179 jmethodID mid = env->GetMethodID(c.get(), "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
1180 CHECK(mid != NULL);
1181 ScopedLocalRef<jobject> class_name_object(env, env->NewStringUTF(class_name_string.c_str()));
1182 if (class_name_object.get() == NULL) {
1183 return NULL;
1184 }
1185 ScopedLocalRef<jobject> class_loader_object(env, AddLocalReference<jobject>(env, class_loader));
Ian Rogers761bfa82012-01-11 10:14:05 -08001186 ScopedLocalRef<jobject> result(env, env->CallObjectMethod(class_loader_object.get(), mid,
1187 class_name_object.get()));
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001188 if (env->ExceptionCheck()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001189 // If the ClassLoader threw, pass that exception up.
1190 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001191 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001192 // broken loader - throw NPE to be compatible with Dalvik
1193 ThrowNullPointerException("ClassLoader.loadClass returned null for %s",
1194 class_name_string.c_str());
1195 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001196 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08001197 // success, return Class*
Ian Rogers6b0870d2011-12-15 19:38:12 -08001198 return Decode<Class*>(env, result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001199 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001200 }
1201
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001202 ThrowNoClassDefFoundError("Class %s not found", PrintableString(StringPiece(descriptor)).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001203 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001204}
1205
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001206Class* ClassLinker::DefineClass(const StringPiece& descriptor,
Brian Carlstromaded5f72011-10-07 17:15:04 -07001207 const ClassLoader* class_loader,
1208 const DexFile& dex_file,
1209 const DexFile::ClassDef& dex_class_def) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001210 SirtRef<Class> klass(NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001211 // Load the class from the dex file.
1212 if (!init_done_) {
1213 // finish up init of hand crafted class_roots_
1214 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001215 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001216 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001217 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001218 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001219 klass.reset(GetClassRoot(kJavaLangString));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001220 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001221 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001222 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001223 klass.reset(GetClassRoot(kJavaLangReflectField));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001224 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001225 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001226 } else {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001227 klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001228 }
1229 } else {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001230 klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001231 }
1232 klass->SetDexCache(FindDexCache(dex_file));
1233 LoadClass(dex_file, dex_class_def, klass, class_loader);
1234 // Check for a pending exception during load
1235 Thread* self = Thread::Current();
1236 if (self->IsExceptionPending()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001237 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001238 return NULL;
1239 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001240 ObjectLock lock(klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001241 klass->SetClinitThreadId(self->GetTid());
1242 // Add the newly loaded class to the loaded classes table.
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001243 Class* existing = InsertClass(descriptor, klass.get(), false);
1244 if (existing != NULL) {
1245 // We failed to insert because we raced with another thread.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001246 klass->SetClinitThreadId(0);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001247 klass.reset(existing);
1248 return EnsureResolved(klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001249 }
1250 // Finish loading (if necessary) by finding parents
1251 CHECK(!klass->IsLoaded());
1252 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1253 // Loading failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001254 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001255 lock.NotifyAll();
1256 return NULL;
1257 }
1258 CHECK(klass->IsLoaded());
1259 // Link the class (if necessary)
1260 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001261 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001262 // Linking failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001263 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001264 lock.NotifyAll();
1265 return NULL;
1266 }
1267 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001268
1269 /*
1270 * We send CLASS_PREPARE events to the debugger from here. The
1271 * definition of "preparation" is creating the static fields for a
1272 * class and initializing them to the standard default values, but not
1273 * executing any code (that comes later, during "initialization").
1274 *
1275 * We did the static preparation in LinkClass.
1276 *
1277 * The class has been prepared and resolved but possibly not yet verified
1278 * at this point.
1279 */
1280 Dbg::PostClassPrepare(klass.get());
1281
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001282 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001283}
1284
Brian Carlstrom4873d462011-08-21 15:23:39 -07001285// Precomputes size that will be needed for Class, matching LinkStaticFields
1286size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1287 const DexFile::ClassDef& dex_class_def) {
1288 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001289 size_t num_ref = 0;
1290 size_t num_32 = 0;
1291 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001292 if (class_data != NULL) {
1293 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1294 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001295 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001296 char c = descriptor[0];
1297 if (c == 'L' || c == '[') {
1298 num_ref++;
1299 } else if (c == 'J' || c == 'D') {
1300 num_64++;
1301 } else {
1302 num_32++;
1303 }
1304 }
1305 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001306 // start with generic class data
1307 size_t size = sizeof(Class);
1308 // follow with reference fields which must be contiguous at start
1309 size += (num_ref * sizeof(uint32_t));
1310 // if there are 64-bit fields to add, make sure they are aligned
1311 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
1312 if (num_32 != 0) {
1313 // use an available 32-bit field for padding
1314 num_32--;
1315 }
1316 size += sizeof(uint32_t); // either way, we are adding a word
1317 DCHECK_EQ(size, RoundUp(size, 8));
1318 }
1319 // tack on any 64-bit fields now that alignment is assured
1320 size += (num_64 * sizeof(uint64_t));
1321 // tack on any remaining 32-bit fields
1322 size += (num_32 * sizeof(uint32_t));
1323 return size;
1324}
1325
Ian Rogers19846512012-02-24 11:42:47 -08001326const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1327 DCHECK(descriptor != NULL);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001328 if (!Runtime::Current()->IsStarted() || Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001329 return NULL;
1330 }
1331 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1332 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1333 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1334 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1335 uint32_t class_def_index;
1336 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1337 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1338 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1339 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1340 return oat_class;
1341}
1342
1343const void* ClassLinker::GetOatCodeFor(const Method* method) {
1344 // Special case to get oat code without overwriting a trampoline.
1345 CHECK(method->GetDeclaringClass()->IsInitializing());
1346 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001347 // method for direct methods (or virtual methods made direct).
1348 Class* declaring_class = method->GetDeclaringClass();
1349 size_t oat_method_index;
1350 if (method->IsStatic() || method->IsDirect()) {
1351 // Simple case where the oat method index was stashed at load time.
1352 oat_method_index = method->GetMethodIndex();
1353 } else {
1354 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1355 // by search for its position in the declared virtual methods.
1356 oat_method_index = declaring_class->NumDirectMethods();
1357 size_t end = declaring_class->NumVirtualMethods();
1358 bool found = false;
1359 for (size_t i = 0; i < end; i++) {
1360 oat_method_index++;
1361 if (declaring_class->GetVirtualMethod(i) == method) {
1362 found = true;
1363 break;
1364 }
1365 }
1366 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1367 }
1368 ClassHelper kh(declaring_class);
Ian Rogers19846512012-02-24 11:42:47 -08001369 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
Ian Rogersfb6adba2012-03-04 21:51:51 -08001370 return oat_class->GetOatMethod(oat_method_index).GetCode();
Ian Rogers19846512012-02-24 11:42:47 -08001371}
1372
1373void ClassLinker::FixupStaticTrampolines(Class* klass) {
1374 ClassHelper kh(klass);
1375 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1376 CHECK(dex_class_def != NULL);
1377 const DexFile& dex_file = kh.GetDexFile();
1378 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1379 if (class_data == NULL) {
1380 return; // no fields or methods - for example a marker interface
1381 }
1382 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1383 if (oat_class.get() == NULL) {
1384 // OAT file unavailable
1385 return;
1386 }
1387 ClassDataItemIterator it(dex_file, class_data);
1388 // Skip fields
1389 while (it.HasNextStaticField()) {
1390 it.Next();
1391 }
1392 while (it.HasNextInstanceField()) {
1393 it.Next();
1394 }
1395 size_t method_index = 0;
1396 // Link the code of methods skipped by LinkCode
1397 const void* trampoline = Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData();
1398 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1399 Method* method = klass->GetDirectMethod(i);
1400 if (method->GetCode() == trampoline) {
1401 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1402 CHECK(code != NULL);
1403 method->SetCode(code);
1404 }
1405 method_index++;
1406 }
1407}
1408
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001409void LinkCode(SirtRef<Method>& method, const OatFile::OatClass* oat_class, uint32_t method_index) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001410 // Every kind of method should at least get an invoke stub from the oat_method.
1411 // non-abstract methods also get their code pointers.
1412 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstromae826982011-11-09 01:33:42 -08001413 oat_method.LinkMethodPointers(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001414
Ian Rogers19846512012-02-24 11:42:47 -08001415 Runtime* runtime = Runtime::Current();
Brian Carlstrom92827a52011-10-10 15:50:01 -07001416 if (method->IsAbstract()) {
Ian Rogers19846512012-02-24 11:42:47 -08001417 method->SetCode(runtime->GetAbstractMethodErrorStubArray()->GetData());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001418 return;
1419 }
Ian Rogers19846512012-02-24 11:42:47 -08001420
1421 if (method->IsStatic() && !method->IsConstructor()) {
1422 // For static methods excluding the class initializer, install the trampoline
1423 method->SetCode(runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData());
Ian Rogers0d6de042012-02-29 08:50:26 -08001424 }
1425 if (method->IsNative()) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001426 // unregistering restores the dlsym lookup stub
Ian Rogers19846512012-02-24 11:42:47 -08001427 method->UnregisterNative(Thread::Current());
jeffhao26c0a1a2012-01-17 16:28:33 -08001428 }
1429
1430 if (Runtime::Current()->IsMethodTracingActive()) {
1431#if defined(__arm__)
1432 Trace* tracer = Runtime::Current()->GetTracer();
1433 void* trace_stub = reinterpret_cast<void*>(art_trace_entry_from_code);
1434 tracer->SaveAndUpdateCode(method.get(), trace_stub);
1435#else
1436 UNIMPLEMENTED(WARNING);
1437#endif
Brian Carlstrom92827a52011-10-10 15:50:01 -07001438 }
1439}
1440
Brian Carlstromf615a612011-07-23 12:50:34 -07001441void ClassLinker::LoadClass(const DexFile& dex_file,
1442 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001443 SirtRef<Class>& klass,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001444 const ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001445 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001446 CHECK(klass->GetDexCache() != NULL);
1447 CHECK_EQ(Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001448 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001449 CHECK(descriptor != NULL);
1450
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001451 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001452 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001453 // Make sure that none of our runtime-only flags are set.
1454 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001455 klass->SetAccessFlags(access_flags);
1456 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001457 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001458 klass->SetStatus(Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001459
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001460 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001461
Ian Rogers0571d352011-11-03 19:51:38 -07001462 // Load fields fields.
1463 const byte* class_data = dex_file.GetClassData(dex_class_def);
1464 if (class_data == NULL) {
1465 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001466 }
Ian Rogers0571d352011-11-03 19:51:38 -07001467 ClassDataItemIterator it(dex_file, class_data);
1468 if (it.NumStaticFields() != 0) {
1469 klass->SetSFields(AllocObjectArray<Field>(it.NumStaticFields()));
1470 }
1471 if (it.NumInstanceFields() != 0) {
1472 klass->SetIFields(AllocObjectArray<Field>(it.NumInstanceFields()));
1473 }
1474 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
1475 SirtRef<Field> sfield(AllocField());
1476 klass->SetStaticField(i, sfield.get());
1477 LoadField(dex_file, it, klass, sfield);
1478 }
1479 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
1480 SirtRef<Field> ifield(AllocField());
1481 klass->SetInstanceField(i, ifield.get());
1482 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001483 }
1484
Ian Rogers19846512012-02-24 11:42:47 -08001485 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, descriptor));
1486
Ian Rogers0571d352011-11-03 19:51:38 -07001487 // Load methods.
1488 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001489 // TODO: append direct methods to class object
Ian Rogers0571d352011-11-03 19:51:38 -07001490 klass->SetDirectMethods(AllocObjectArray<Method>(it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001491 }
Ian Rogers0571d352011-11-03 19:51:38 -07001492 if (it.NumVirtualMethods() != 0) {
1493 // TODO: append direct methods to class object
1494 klass->SetVirtualMethods(AllocObjectArray<Method>(it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001495 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001496 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001497 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1498 SirtRef<Method> method(AllocMethod());
1499 klass->SetDirectMethod(i, method.get());
1500 LoadMethod(dex_file, it, klass, method);
1501 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001502 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001503 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001504 method->SetMethodIndex(class_def_method_index);
1505 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001506 }
1507 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
1508 SirtRef<Method> method(AllocMethod());
1509 klass->SetVirtualMethod(i, method.get());
1510 LoadMethod(dex_file, it, klass, method);
Ian Rogersfb6adba2012-03-04 21:51:51 -08001511 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001512 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001513 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001514 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001515 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001516 }
1517 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001518}
1519
Ian Rogers0571d352011-11-03 19:51:38 -07001520void ClassLinker::LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
1521 SirtRef<Class>& klass, SirtRef<Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001522 uint32_t field_idx = it.GetMemberIndex();
1523 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001524 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001525 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001526}
1527
Ian Rogers0571d352011-11-03 19:51:38 -07001528void ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
1529 SirtRef<Class>& klass, SirtRef<Method>& dst) {
Ian Rogers19846512012-02-24 11:42:47 -08001530 uint32_t dex_method_idx = it.GetMemberIndex();
1531 dst->SetDexMethodIndex(dex_method_idx);
1532 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001533 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001534
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001535
1536 StringPiece method_name(dex_file.GetMethodName(method_id));
1537 if (method_name == "<init>") {
Elliott Hughes80609252011-09-23 17:24:51 -07001538 dst->SetClass(GetClassRoot(kJavaLangReflectConstructor));
1539 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001540
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001541 if (method_name == "finalize") {
1542 // Create the prototype for a signature of "()V"
1543 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1544 if (void_string_id != NULL) {
1545 const DexFile::TypeId* void_type_id =
1546 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1547 if (void_type_id != NULL) {
1548 std::vector<uint16_t> no_args;
1549 const DexFile::ProtoId* finalizer_proto =
1550 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1551 if (finalizer_proto != NULL) {
1552 // We have the prototype in the dex file
1553 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1554 klass->SetFinalizable();
1555 } else {
1556 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1557 // The Enum class declares a "final" finalize() method to prevent subclasses from
1558 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1559 // subclasses, so we exclude it here.
1560 // We also want to avoid setting the flag on Object, where we know that finalize() is
1561 // empty.
1562 if (klass_descriptor != "Ljava/lang/Object;" &&
1563 klass_descriptor != "Ljava/lang/Enum;") {
1564 klass->SetFinalizable();
1565 }
1566 }
1567 }
1568 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001569 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001570 }
Ian Rogers0571d352011-11-03 19:51:38 -07001571 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001572 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001573
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001574 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001575 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001576 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001577 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001578}
1579
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001580void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001581 SirtRef<DexCache> dex_cache(AllocDexCache(dex_file));
1582 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001583}
1584
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001585void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
1586 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001587 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001588 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001589}
1590
Brian Carlstromaded5f72011-10-07 17:15:04 -07001591bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001592 dex_lock_.AssertHeld();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001593 for (size_t i = 0; i != dex_files_.size(); ++i) {
1594 if (dex_files_[i] == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001595 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001596 }
1597 }
1598 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001599}
1600
Brian Carlstromaded5f72011-10-07 17:15:04 -07001601bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001602 MutexLock mu(dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001603 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001604}
1605
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001606void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001607 dex_lock_.AssertHeld();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001608 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001609 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001610 dex_files_.push_back(&dex_file);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001611 dex_caches_.push_back(dex_cache.get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001612}
1613
Brian Carlstromaded5f72011-10-07 17:15:04 -07001614void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001615 {
1616 MutexLock mu(dex_lock_);
1617 if (IsDexFileRegisteredLocked(dex_file)) {
1618 return;
1619 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001620 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001621 // Don't alloc while holding the lock, since allocation may need to
1622 // suspend all threads and another thread may need the dex_lock_ to
1623 // get to a suspend point.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001624 SirtRef<DexCache> dex_cache(AllocDexCache(dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001625 {
1626 MutexLock mu(dex_lock_);
1627 if (IsDexFileRegisteredLocked(dex_file)) {
1628 return;
1629 }
1630 RegisterDexFileLocked(dex_file, dex_cache);
1631 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001632}
1633
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001634void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001635 MutexLock mu(dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001636 RegisterDexFileLocked(dex_file, dex_cache);
1637}
1638
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001639const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
Ian Rogers466bb252011-10-14 03:29:56 -07001640 CHECK(dex_cache != NULL);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001641 MutexLock mu(dex_lock_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001642 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1643 if (dex_caches_[i] == dex_cache) {
Ian Rogers19846512012-02-24 11:42:47 -08001644 return *dex_files_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001645 }
1646 }
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001647 CHECK(false) << "Failed to find DexFile for DexCache " << dex_cache->GetLocation()->ToModifiedUtf8();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001648 return *dex_files_[-1];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001649}
1650
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001651DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001652 MutexLock mu(dex_lock_);
Brian Carlstromf615a612011-07-23 12:50:34 -07001653 for (size_t i = 0; i != dex_files_.size(); ++i) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001654 if (dex_files_[i] == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001655 return dex_caches_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001656 }
1657 }
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001658 CHECK(false) << "Failed to find DexCache for DexFile " << dex_file.GetLocation();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001659 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001660}
1661
Ian Rogers19846512012-02-24 11:42:47 -08001662void ClassLinker::FixupDexCaches(Method* resolution_method) const {
1663 MutexLock mu(dex_lock_);
1664 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1665 dex_caches_[i]->Fixup(resolution_method);
1666 }
1667}
1668
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001669Class* ClassLinker::InitializePrimitiveClass(Class* primitive_class,
1670 const char* descriptor,
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001671 Primitive::Type type) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001672 // TODO: deduce one argument from the other
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001673 CHECK(primitive_class != NULL);
1674 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001675 primitive_class->SetPrimitiveType(type);
1676 primitive_class->SetStatus(Class::kStatusInitialized);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001677 Class* existing = InsertClass(descriptor, primitive_class, false);
1678 CHECK(existing == NULL) << "InitPrimitiveClass(" << descriptor << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001679 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001680}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001681
Brian Carlstrombe977852011-07-19 14:54:54 -07001682// Create an array class (i.e. the class object for the array, not the
1683// array itself). "descriptor" looks like "[C" or "[[[[B" or
1684// "[Ljava/lang/String;".
1685//
1686// If "descriptor" refers to an array of primitives, look up the
1687// primitive type's internally-generated class object.
1688//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001689// "class_loader" is the class loader of the class that's referring to
1690// us. It's used to ensure that we're looking for the element type in
1691// the right context. It does NOT become the class loader for the
1692// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001693//
1694// Returns NULL with an exception raised on failure.
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001695Class* ClassLinker::CreateArrayClass(const std::string& descriptor, const ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001696 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001697
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001698 // Identify the underlying component type
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001699 Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001700 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001701 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001702 return NULL;
1703 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001704
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001705 // See if the component type is already loaded. Array classes are
1706 // always associated with the class loader of their underlying
1707 // element type -- an array of Strings goes with the loader for
1708 // java/lang/String -- so we need to look for it there. (The
1709 // caller should have checked for the existence of the class
1710 // before calling here, but they did so with *their* class loader,
1711 // not the component type's loader.)
1712 //
1713 // If we find it, the caller adds "loader" to the class' initiating
1714 // loader list, which should prevent us from going through this again.
1715 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001716 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001717 // are the same, because our caller (FindClass) just did the
1718 // lookup. (Even if we get this wrong we still have correct behavior,
1719 // because we effectively do this lookup again when we add the new
1720 // class to the hash table --- necessary because of possible races with
1721 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001722 if (class_loader != component_type->GetClassLoader()) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001723 Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001724 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001725 return new_class;
1726 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001727 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001728
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001729 // Fill out the fields in the Class.
1730 //
1731 // It is possible to execute some methods against arrays, because
1732 // all arrays are subclasses of java_lang_Object_, so we need to set
1733 // up a vtable. We can just point at the one in java_lang_Object_.
1734 //
1735 // Array classes are simple enough that we don't need to do a full
1736 // link step.
1737
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001738 SirtRef<Class> new_class(NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001739 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001740 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07001741 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001742 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07001743 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001744 new_class.reset(GetClassRoot(kObjectArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001745 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001746 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001747 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001748 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001749 }
1750 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001751 if (new_class.get() == NULL) {
1752 new_class.reset(AllocClass(sizeof(Class)));
1753 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001754 return NULL;
1755 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001756 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001757 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001758 DCHECK(new_class->GetComponentType() != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001759 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001760 new_class->SetSuperClass(java_lang_Object);
1761 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001762 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001763 new_class->SetClassLoader(component_type->GetClassLoader());
1764 new_class->SetStatus(Class::kStatusInitialized);
1765 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001766 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001767
1768
1769 // All arrays have java/lang/Cloneable and java/io/Serializable as
1770 // interfaces. We need to set that up here, so that stuff like
1771 // "instanceof" works right.
1772 //
1773 // Note: The GC could run during the call to FindSystemClass,
1774 // so we need to make sure the class object is GC-valid while we're in
1775 // there. Do this by clearing the interface list so the GC will just
1776 // think that the entries are null.
1777
1778
1779 // Use the single, global copies of "interfaces" and "iftable"
1780 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07001781 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001782 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001783
1784 // Inherit access flags from the component type. Arrays can't be
1785 // used as a superclass or interface, so we want to add "final"
1786 // and remove "interface".
1787 //
1788 // Don't inherit any non-standard flags (e.g., kAccFinal)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001789 // from component_type. We assume that the array class does not
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001790 // override finalize().
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001791 new_class->SetAccessFlags(((new_class->GetComponentType()->GetAccessFlags() &
1792 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001793
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001794 Class* existing = InsertClass(descriptor, new_class.get(), false);
1795 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001796 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001797 }
1798 // Another thread must have loaded the class after we
1799 // started but before we finished. Abandon what we've
1800 // done.
1801 //
1802 // (Yes, this happens.)
1803
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001804 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001805}
1806
1807Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001808 switch (Primitive::GetType(type)) {
1809 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001810 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001811 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001812 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001813 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001814 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001815 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001816 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001817 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001818 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001819 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001820 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001821 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001822 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001823 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001824 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001825 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001826 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001827 case Primitive::kPrimNot:
1828 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07001829 }
Elliott Hughesbd935992011-08-22 11:59:34 -07001830 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001831 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07001832 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001833}
1834
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001835Class* ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass, bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001836 if (VLOG_IS_ON(class_linker)) {
Brian Carlstromae826982011-11-09 01:33:42 -08001837 DexCache* dex_cache = klass->GetDexCache();
1838 std::string source;
1839 if (dex_cache != NULL) {
1840 source += " from ";
1841 source += dex_cache->GetLocation()->ToModifiedUtf8();
1842 }
1843 LOG(INFO) << "Loaded class " << descriptor << source;
1844 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001845 size_t hash = StringPieceHash()(descriptor);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001846 MutexLock mu(classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001847 Table& classes = image_class ? image_classes_ : classes_;
1848 Class* existing = LookupClass(descriptor.data(), klass->GetClassLoader(), hash, classes);
1849#ifndef NDEBUG
1850 // Check we don't have the class in the other table in error
1851 Table& other_classes = image_class ? classes_ : image_classes_;
1852 CHECK(LookupClass(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
1853#endif
1854 if (existing != NULL) {
1855 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07001856 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001857 classes.insert(std::make_pair(hash, klass));
1858 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001859}
1860
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001861bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
1862 size_t hash = Hash(descriptor);
Brian Carlstromae826982011-11-09 01:33:42 -08001863 MutexLock mu(classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08001864 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08001865 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001866 ClassHelper kh;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001867 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08001868 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001869 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001870 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08001871 classes_.erase(it);
1872 return true;
1873 }
1874 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001875 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08001876 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001877 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001878 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08001879 image_classes_.erase(it);
1880 return true;
1881 }
1882 }
1883 return false;
1884}
1885
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001886Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
1887 size_t hash = Hash(descriptor);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001888 MutexLock mu(classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07001889 // TODO: determine if its better to search classes_ or image_classes_ first
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001890 Class* klass = LookupClass(descriptor, class_loader, hash, classes_);
1891 if (klass != NULL) {
1892 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001893 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001894 return LookupClass(descriptor, class_loader, hash, image_classes_);
1895}
1896
1897Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader,
1898 size_t hash, const Table& classes) {
1899 ClassHelper kh(NULL, this);
1900 typedef Table::const_iterator It; // TODO: C++0x auto
1901 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers5d76c432011-10-31 21:42:49 -07001902 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001903 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001904 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001905#ifndef NDEBUG
1906 for (++it; it != end && it->first == hash; ++it) {
Ian Rogersd85016c2012-02-03 18:27:34 -08001907 Class* klass2 = it->second;
1908 kh.ChangeClass(klass2);
1909 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001910 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08001911 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001912 }
1913#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07001914 return klass;
1915 }
1916 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001917 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001918}
1919
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001920void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001921 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001922 size_t hash = Hash(descriptor);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001923 MutexLock mu(classes_lock_);
1924 typedef Table::const_iterator It; // TODO: C++0x auto
1925 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001926 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001927 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001928 Class* klass = it->second;
1929 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001930 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001931 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001932 }
1933 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001934 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001935 Class* klass = it->second;
1936 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001937 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001938 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001939 }
1940 }
1941}
1942
Ian Rogersc20a83e2012-01-18 18:15:32 -08001943#ifndef NDEBUG
1944static void CheckMethodsHaveGcMaps(Class* klass) {
1945 if (!Runtime::Current()->IsStarted()) {
1946 return;
1947 }
1948 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
1949 Method* method = klass->GetDirectMethod(i);
1950 if (!method->IsNative() && !method->IsAbstract()) {
1951 CHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
1952 }
1953 }
1954 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
1955 Method* method = klass->GetVirtualMethod(i);
1956 if (!method->IsNative() && !method->IsAbstract()) {
1957 CHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
1958 }
1959 }
1960}
1961#else
1962static void CheckMethodsHaveGcMaps(Class* klass) {
1963}
1964#endif
1965
jeffhao98eacac2011-09-14 16:11:53 -07001966void ClassLinker::VerifyClass(Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08001967 // TODO: assert that the monitor on the Class is held
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001968 ObjectLock lock(klass);
1969
jeffhao98eacac2011-09-14 16:11:53 -07001970 if (klass->IsVerified()) {
1971 return;
1972 }
1973
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08001974 // The class might already be erroneous if we attempted to verify a subclass
1975 if (klass->IsErroneous()) {
1976 ThrowEarlierClassFailure(klass);
1977 return;
1978 }
1979
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001980 CHECK_EQ(klass->GetStatus(), Class::kStatusResolved) << PrettyClass(klass);
jeffhao98eacac2011-09-14 16:11:53 -07001981 klass->SetStatus(Class::kStatusVerifying);
jeffhao98eacac2011-09-14 16:11:53 -07001982
Ian Rogers1c5eb702012-02-01 09:18:34 -08001983 // Verify super class
1984 Class* super = klass->GetSuperClass();
1985 std::string error_msg;
1986 if (super != NULL) {
1987 // Acquire lock to prevent races on verifying the super class
1988 ObjectLock lock(super);
1989
1990 if (!super->IsVerified() && !super->IsErroneous()) {
1991 Runtime::Current()->GetClassLinker()->VerifyClass(super);
1992 }
1993 if (!super->IsVerified()) {
1994 error_msg = "Rejecting class ";
1995 error_msg += PrettyDescriptor(klass);
1996 error_msg += " that attempts to sub-class erroneous class ";
1997 error_msg += PrettyDescriptor(super);
1998 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
1999 Thread* self = Thread::Current();
2000 SirtRef<Throwable> cause(self->GetException());
2001 if (cause.get() != NULL) {
2002 self->ClearException();
2003 }
2004 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2005 if (cause.get() != NULL) {
2006 self->GetException()->SetCause(cause.get());
2007 }
2008 CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
2009 klass->SetStatus(Class::kStatusError);
2010 return;
2011 }
2012 }
2013
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002014 // Try to use verification information from oat file, otherwise do runtime verification
2015 const DexFile& dex_file = FindDexFile(klass->GetDexCache());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002016 if (VerifyClassUsingOatFile(dex_file, klass) ||
2017 verifier::DexVerifier::VerifyClass(klass, error_msg)) {
Ian Rogersc4762272012-02-01 15:55:55 -08002018 DCHECK(!Thread::Current()->IsExceptionPending());
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002019 // Make sure all classes referenced by catch blocks are resolved
2020 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002021 klass->SetStatus(Class::kStatusVerified);
Ian Rogersc20a83e2012-01-18 18:15:32 -08002022 // Sanity check that a verified class has GC maps on all methods
2023 CheckMethodsHaveGcMaps(klass);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002024 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002025 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002026 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2027 << " because: " << error_msg;
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002028 Thread* self = Thread::Current();
Ian Rogersc4762272012-02-01 15:55:55 -08002029 CHECK(!self->IsExceptionPending());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002030 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2031 CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002032 klass->SetStatus(Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002033 }
jeffhao98eacac2011-09-14 16:11:53 -07002034}
2035
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002036bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass) {
2037 if (!Runtime::Current()->IsStarted()) {
2038 return false;
2039 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002040 if (Runtime::Current()->UseCompileTimeClassPath()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002041 return false;
2042 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002043 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2044 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002045 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002046 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002047 const char* descriptor = ClassHelper(klass).GetDescriptor();
2048 uint32_t class_def_index;
2049 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002050 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002051 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002052 CHECK(oat_class.get() != NULL)
2053 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002054 Class::Status status = oat_class->GetStatus();
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002055 if (status == Class::kStatusVerified || status == Class::kStatusInitialized) {
2056 return true;
2057 }
Ian Rogersc4762272012-02-01 15:55:55 -08002058 if (status == Class::kStatusError) {
2059 // Compile time verification failed. Compile time verification can fail because we have
2060 // incomplete type information. Consider the following:
2061 // class ... {
2062 // Foo x;
2063 // .... () {
2064 // if (...) {
2065 // v1 gets assigned a type of resolved class Foo
2066 // } else {
2067 // v1 gets assigned a type of unresolved class Bar
2068 // }
2069 // iput x = v1
2070 // } }
2071 // when we merge v1 following the if-the-else it results in Conflict
2072 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2073 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2074 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2075 // at compile time).
2076 return false;
2077 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002078 if (status == Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002079 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2080 // not loading the class.
2081 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2082 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002083 return false;
2084 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002085 LOG(FATAL) << "Unexpected class status: " << status
2086 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2087
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002088 return false;
2089}
2090
2091void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
2092 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2093 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2094 }
2095 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2096 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2097 }
2098}
2099
2100void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* method) {
2101 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2102 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2103 if (code_item == NULL) {
2104 return; // native or abstract method
2105 }
2106 if (code_item->tries_size_ == 0) {
2107 return; // nothing to process
2108 }
2109 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2110 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2111 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2112 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2113 CatchHandlerIterator iterator(handlers_ptr);
2114 for (; iterator.HasNext(); iterator.Next()) {
2115 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2116 // unresolved exception types will be ignored by exception delivery
2117 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
2118 Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
2119 if (exception_type == NULL) {
2120 DCHECK(Thread::Current()->IsExceptionPending());
2121 Thread::Current()->ClearException();
2122 }
2123 }
2124 }
2125 handlers_ptr = iterator.EndDataPointer();
2126 }
2127}
2128
Ian Rogersc2b44472011-12-14 21:17:17 -08002129static void CheckProxyConstructor(Method* constructor);
2130static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype);
2131
Jesse Wilson95caa792011-10-12 18:14:17 -04002132Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002133 ClassLoader* loader, ObjectArray<Method>* methods,
2134 ObjectArray<ObjectArray<Class> >* throws) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002135 SirtRef<Class> klass(AllocClass(GetClassRoot(kJavaLangClass), sizeof(SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002136 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002137 DCHECK(klass->GetClass() != NULL);
Jesse Wilson95caa792011-10-12 18:14:17 -04002138 klass->SetObjectSize(sizeof(Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002139 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002140 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002141 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002142 klass->SetName(name);
Ian Rogers466bb252011-10-14 03:29:56 -07002143 Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002144 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002145
2146 klass->SetStatus(Class::kStatusIdx);
2147
2148 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2149
2150 // Create static field that holds throws, instance fields are inherited
2151 klass->SetSFields(AllocObjectArray<Field>(1));
2152 SirtRef<Field> sfield(AllocField());
2153 klass->SetStaticField(0, sfield.get());
2154 sfield->SetDexFieldIndex(-1);
2155 sfield->SetDeclaringClass(klass.get());
2156 sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002157
Ian Rogers466bb252011-10-14 03:29:56 -07002158 // Proxies have 1 direct method, the constructor
Jesse Wilson95caa792011-10-12 18:14:17 -04002159 klass->SetDirectMethods(AllocObjectArray<Method>(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002160 klass->SetDirectMethod(0, CreateProxyConstructor(klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002161
Ian Rogers466bb252011-10-14 03:29:56 -07002162 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002163 size_t num_virtual_methods = methods->GetLength();
2164 klass->SetVirtualMethods(AllocObjectArray<Method>(num_virtual_methods));
2165 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002166 SirtRef<Method> prototype(methods->Get(i));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002167 klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002168 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002169
2170 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
2171 klass->SetStatus(Class::kStatusLoaded); // Class is now effectively in the loaded state
2172 DCHECK(!Thread::Current()->IsExceptionPending());
2173
2174 // Link the fields and virtual methods, creating vtable and iftables
2175 if (!LinkClass(klass, interfaces)) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002176 klass->SetStatus(Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002177 return NULL;
2178 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002179 sfield->SetObject(NULL, throws); // initialize throws field
2180 klass->SetStatus(Class::kStatusInitialized);
2181
2182 // sanity checks
2183#ifndef NDEBUG
2184 bool debug = true;
2185#else
2186 bool debug = false;
2187#endif
2188 if (debug) {
2189 CHECK(klass->GetIFields() == NULL);
2190 CheckProxyConstructor(klass->GetDirectMethod(0));
2191 for (size_t i = 0; i < num_virtual_methods; ++i) {
2192 SirtRef<Method> prototype(methods->Get(i));
2193 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2194 }
Brian Carlstrom89521892011-12-07 22:05:07 -08002195 std::string throws_field_name("java.lang.Class[][] ");
Ian Rogersc2b44472011-12-14 21:17:17 -08002196 throws_field_name += name->ToModifiedUtf8();
2197 throws_field_name += ".throws";
2198 CHECK(PrettyField(klass->GetStaticField(0)) == throws_field_name);
2199
2200 SynthesizedProxyClass* synth_proxy_class = down_cast<SynthesizedProxyClass*>(klass.get());
2201 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2202 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002203 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002204}
2205
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002206std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
2207 DCHECK(proxy_class->IsProxyClass());
2208 String* name = proxy_class->GetName();
2209 DCHECK(name != NULL);
2210 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2211}
2212
Ian Rogers16f93672012-02-14 12:29:06 -08002213Method* ClassLinker::FindMethodForProxy(const Class* proxy_class, const Method* proxy_method) {
2214 DCHECK(proxy_class->IsProxyClass());
2215 DCHECK(proxy_method->IsProxyMethod());
2216 // Locate the dex cache of the original interface/Object
2217 DexCache* dex_cache = NULL;
2218 {
2219 ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
2220 MutexLock mu(dex_lock_);
2221 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2222 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2223 dex_cache = dex_caches_[i];
2224 break;
2225 }
2226 }
2227 }
2228 CHECK(dex_cache != NULL);
2229 uint32_t method_idx = proxy_method->GetDexMethodIndex();
2230 Method* resolved_method = dex_cache->GetResolvedMethod(method_idx);
2231 CHECK(resolved_method != NULL);
2232 return resolved_method;
2233}
2234
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002235
2236Method* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002237 // Create constructor for Proxy that must initialize h
Ian Rogers466bb252011-10-14 03:29:56 -07002238 ObjectArray<Method>* proxy_direct_methods = proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002239 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Ian Rogers466bb252011-10-14 03:29:56 -07002240 Method* proxy_constructor = proxy_direct_methods->Get(2);
2241 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2242 // code_ too)
2243 Method* constructor = down_cast<Method*>(proxy_constructor->Clone());
2244 // Make this constructor public and fix the class to be our Proxy version
2245 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002246 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002247 return constructor;
2248}
2249
2250static void CheckProxyConstructor(Method* constructor) {
Ian Rogers466bb252011-10-14 03:29:56 -07002251 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002252 MethodHelper mh(constructor);
2253 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002254 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002255 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002256}
2257
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002258Method* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype) {
2259 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2260 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002261 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2262 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002263 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002264 // as necessary
2265 Method* method = down_cast<Method*>(prototype->Clone());
2266
2267 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2268 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002269 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002270 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002271
Ian Rogers466bb252011-10-14 03:29:56 -07002272 // At runtime the method looks like a reference and argument saving method, clone the code
2273 // related parameters from this method.
2274 Method* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
2275 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2276 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2277 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
2278 method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
Ian Rogers16f93672012-02-14 12:29:06 -08002279
Ian Rogersc2b44472011-12-14 21:17:17 -08002280 return method;
2281}
Jesse Wilson95caa792011-10-12 18:14:17 -04002282
Ian Rogersc2b44472011-12-14 21:17:17 -08002283static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype) {
Ian Rogers466bb252011-10-14 03:29:56 -07002284 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002285 CHECK(!prototype->IsFinal());
2286 CHECK(method->IsFinal());
2287 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002288
2289 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2290 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2291 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2292 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2293 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2294 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2295 method->GetDexCacheInitializedStaticStorage());
2296 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2297
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002298 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002299 MethodHelper mh2(prototype.get());
2300 CHECK_STREQ(mh.GetName(), mh2.GetName());
2301 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002302 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002303 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002304}
2305
Brian Carlstrom25c33252011-09-18 15:58:35 -07002306bool ClassLinker::InitializeClass(Class* klass, bool can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002307 CHECK(klass->IsResolved() || klass->IsErroneous())
2308 << PrettyClass(klass) << " is " << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002309
Carl Shapirob5573532011-07-12 18:22:59 -07002310 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002311
Brian Carlstrom25c33252011-09-18 15:58:35 -07002312 Method* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002313 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002314 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002315 ObjectLock lock(klass);
2316
Brian Carlstromd1422f82011-09-28 11:37:09 -07002317 if (klass->GetStatus() == Class::kStatusInitialized) {
2318 return true;
2319 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002320
Brian Carlstromd1422f82011-09-28 11:37:09 -07002321 if (klass->IsErroneous()) {
2322 ThrowEarlierClassFailure(klass);
2323 return false;
2324 }
2325
2326 if (klass->GetStatus() == Class::kStatusResolved) {
jeffhao98eacac2011-09-14 16:11:53 -07002327 VerifyClass(klass);
2328 if (klass->GetStatus() != Class::kStatusVerified) {
Ian Rogers595799e2012-01-11 17:32:51 -08002329 CHECK(self->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002330 return false;
2331 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002332 }
2333
Brian Carlstrom25c33252011-09-18 15:58:35 -07002334 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2335 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002336 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002337 // don't bother going to kStatusInitializing. We return false so that
2338 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002339 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2340 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002341 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002342 }
2343
Brian Carlstromd1422f82011-09-28 11:37:09 -07002344 // If the class is kStatusInitializing, either this thread is
2345 // initializing higher up the stack or another thread has beat us
2346 // to initializing and we need to wait. Either way, this
2347 // invocation of InitializeClass will not be responsible for
2348 // running <clinit> and will return.
2349 if (klass->GetStatus() == Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002350 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002351 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002352 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002353 return true;
2354 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002355 // No. That's fine. Wait for another thread to finish initializing.
2356 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002357 }
2358
2359 if (!ValidateSuperClassDescriptors(klass)) {
2360 klass->SetStatus(Class::kStatusError);
2361 return false;
2362 }
2363
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002364 DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002365
Elliott Hughesdcc24742011-09-07 14:02:44 -07002366 klass->SetClinitThreadId(self->GetTid());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002367 klass->SetStatus(Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002368 }
2369
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002370 uint64_t t0 = NanoTime();
2371
Brian Carlstrom25c33252011-09-18 15:58:35 -07002372 if (!InitializeSuperClass(klass, can_run_clinit)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002373 // Super class initialization failed, this can be because we can't run
2374 // super-class class initializers in which case we'll be verified.
2375 // Otherwise this class is erroneous.
2376 if (!can_run_clinit) {
2377 CHECK(klass->IsVerified());
2378 } else {
2379 CHECK(klass->IsErroneous());
2380 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002381 return false;
2382 }
2383
2384 InitializeStaticFields(klass);
2385
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002386 if (clinit != NULL) {
Elliott Hughesf5ecf062011-09-06 17:37:59 -07002387 clinit->Invoke(self, NULL, NULL, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002388 }
2389
Ian Rogers19846512012-02-24 11:42:47 -08002390 FixupStaticTrampolines(klass);
2391
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002392 uint64_t t1 = NanoTime();
2393
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002394 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002395 {
2396 ObjectLock lock(klass);
2397
2398 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002399 WrapExceptionInInitializer();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002400 klass->SetStatus(Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002401 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002402 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002403 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2404 RuntimeStats* thread_stats = self->GetStats();
2405 ++global_stats->class_init_count;
2406 ++thread_stats->class_init_count;
2407 global_stats->class_init_time_ns += (t1 - t0);
2408 thread_stats->class_init_time_ns += (t1 - t0);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002409 klass->SetStatus(Class::kStatusInitialized);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002410 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002411 ClassHelper kh(klass);
2412 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002413 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002414 }
2415 lock.NotifyAll();
2416 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002417 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002418}
2419
Brian Carlstromd1422f82011-09-28 11:37:09 -07002420bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock) {
2421 while (true) {
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002422 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002423 lock.Wait();
2424
2425 // When we wake up, repeat the test for init-in-progress. If
2426 // there's an exception pending (only possible if
2427 // "interruptShouldThrow" was set), bail out.
2428 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002429 WrapExceptionInInitializer();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002430 klass->SetStatus(Class::kStatusError);
2431 return false;
2432 }
2433 // Spurious wakeup? Go back to waiting.
2434 if (klass->GetStatus() == Class::kStatusInitializing) {
2435 continue;
2436 }
2437 if (klass->IsErroneous()) {
2438 // The caller wants an exception, but it was thrown in a
2439 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002440 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002441 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002442 return false;
2443 }
2444 if (klass->IsInitialized()) {
2445 return true;
2446 }
2447 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2448 }
2449 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2450}
2451
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002452bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
2453 if (klass->IsInterface()) {
2454 return true;
2455 }
2456 // begin with the methods local to the superclass
2457 if (klass->HasSuperClass() &&
2458 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
2459 const Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002460 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
2461 const Method* method = klass->GetVTable()->Get(i);
2462 if (method != super->GetVTable()->Get(i) &&
2463 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002464 ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
2465 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2466 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002467 return false;
2468 }
2469 }
2470 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002471 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
2472 InterfaceEntry* interface_entry = klass->GetIfTable()->Get(i);
2473 Class* interface = interface_entry->GetInterface();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002474 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2475 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002476 const Method* method = interface_entry->GetMethodArray()->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002477 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2478 method->GetDeclaringClass())) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002479 ThrowLinkageError("Class %s method %s resolves differently in interface %s",
2480 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2481 PrettyMethod(method).c_str(),
2482 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002483 return false;
2484 }
2485 }
2486 }
2487 }
2488 return true;
2489}
2490
Ian Rogers595799e2012-01-11 17:32:51 -08002491// Returns true if classes referenced by the signature of the method are the
2492// same classes in klass1 as they are in klass2.
2493bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const Method* method,
2494 const Class* klass1,
2495 const Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002496 if (klass1 == klass2) {
2497 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002498 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07002499 const DexFile& dex_file = FindDexFile(method->GetDeclaringClass()->GetDexCache());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002500 const DexFile::ProtoId& proto_id =
2501 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002502 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2503 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002504 if (descriptor == NULL) {
2505 break;
2506 }
2507 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2508 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002509 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002510 return false;
2511 }
2512 }
2513 }
2514 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002515 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002516 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002517 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002518 return false;
2519 }
2520 }
2521 return true;
2522}
2523
Ian Rogers595799e2012-01-11 17:32:51 -08002524// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2525bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
2526 const Class* klass1,
2527 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002528 CHECK(descriptor != NULL);
2529 CHECK(klass1 != NULL);
2530 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002531 if (klass1 == klass2) {
2532 return true;
2533 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002534 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002535 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002536 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002537 }
Ian Rogers595799e2012-01-11 17:32:51 -08002538 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
2539 if (found2 == NULL) {
2540 Thread::Current()->ClearException();
2541 }
2542 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002543}
2544
Brian Carlstrom25c33252011-09-18 15:58:35 -07002545bool ClassLinker::InitializeSuperClass(Class* klass, bool can_run_clinit) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002546 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002547 if (!klass->IsInterface() && klass->HasSuperClass()) {
2548 Class* super_class = klass->GetSuperClass();
2549 if (super_class->GetStatus() != Class::kStatusInitialized) {
2550 CHECK(!super_class->IsInterface());
Elliott Hughes5f791332011-09-15 17:45:30 -07002551 Thread* self = Thread::Current();
2552 klass->MonitorEnter(self);
Brian Carlstrom25c33252011-09-18 15:58:35 -07002553 bool super_initialized = InitializeClass(super_class, can_run_clinit);
Elliott Hughes5f791332011-09-15 17:45:30 -07002554 klass->MonitorExit(self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002555 // TODO: check for a pending exception
2556 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002557 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002558 // Don't set status to error when we can't run <clinit>.
2559 CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
2560 klass->SetStatus(Class::kStatusVerified);
2561 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002562 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002563 klass->SetStatus(Class::kStatusError);
2564 klass->NotifyAll();
2565 return false;
2566 }
2567 }
2568 }
2569 return true;
2570}
2571
Brian Carlstrom25c33252011-09-18 15:58:35 -07002572bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit) {
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002573 CHECK(c != NULL);
2574 if (c->IsInitialized()) {
2575 return true;
2576 }
2577
Elliott Hughes5f791332011-09-15 17:45:30 -07002578 Thread* self = Thread::Current();
Elliott Hughes4681c802011-09-25 18:04:37 -07002579 ScopedThreadStateChange tsc(self, Thread::kRunnable);
Ian Rogers595799e2012-01-11 17:32:51 -08002580 bool success = InitializeClass(c, can_run_clinit);
2581 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002582 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002583 }
2584 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002585}
2586
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002587void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Ian Rogers0571d352011-11-03 19:51:38 -07002588 Class* c, std::map<uint32_t, Field*>& field_map) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002589 const ClassLoader* cl = c->GetClassLoader();
2590 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002591 ClassDataItemIterator it(dex_file, class_data);
2592 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
2593 field_map[i] = ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002594 }
2595}
2596
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002597void ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002598 size_t num_static_fields = klass->NumStaticFields();
2599 if (num_static_fields == 0) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002600 return;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002601 }
Brian Carlstromf615a612011-07-23 12:50:34 -07002602 DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002603 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002604 if (dex_cache == NULL) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002605 return;
2606 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002607 ClassHelper kh(klass);
2608 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002609 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002610 const DexFile& dex_file = kh.GetDexFile();
Ian Rogers0571d352011-11-03 19:51:38 -07002611 EncodedStaticFieldValueIterator it(dex_file, dex_cache, this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002612
Ian Rogers0571d352011-11-03 19:51:38 -07002613 if (it.HasNext()) {
2614 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
2615 std::map<uint32_t, Field*> field_map;
2616 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
2617 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
2618 it.ReadValueToField(field_map[i]);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002619 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002620 }
2621}
2622
Ian Rogersc2b44472011-12-14 21:17:17 -08002623bool ClassLinker::LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002624 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002625 if (!LinkSuperClass(klass)) {
2626 return false;
2627 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002628 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002629 return false;
2630 }
2631 if (!LinkInstanceFields(klass)) {
2632 return false;
2633 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07002634 if (!LinkStaticFields(klass)) {
2635 return false;
2636 }
2637 CreateReferenceInstanceOffsets(klass);
2638 CreateReferenceStaticOffsets(klass);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002639 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
2640 klass->SetStatus(Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002641 return true;
2642}
2643
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002644bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002645 CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002646 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
2647 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08002648 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002649 uint16_t super_class_idx = class_def->superclass_idx_;
2650 if (super_class_idx != DexFile::kDexNoIndex16) {
2651 Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002652 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07002653 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002654 return false;
2655 }
Ian Rogersbe125a92012-01-11 15:19:49 -08002656 // Verify
2657 if (!klass->CanAccess(super_class)) {
2658 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2659 "Class %s extended by class %s is inaccessible",
2660 PrettyDescriptor(super_class).c_str(),
2661 PrettyDescriptor(klass.get()).c_str());
2662 return false;
2663 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002664 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002665 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002666 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
2667 if (interfaces != NULL) {
2668 for (size_t i = 0; i < interfaces->Size(); i++) {
2669 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
2670 Class* interface = ResolveType(dex_file, idx, klass.get());
2671 if (interface == NULL) {
2672 DCHECK(Thread::Current()->IsExceptionPending());
2673 return false;
2674 }
2675 // Verify
2676 if (!klass->CanAccess(interface)) {
2677 // TODO: the RI seemed to ignore this in my testing.
2678 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2679 "Interface %s implemented by class %s is inaccessible",
2680 PrettyDescriptor(interface).c_str(),
2681 PrettyDescriptor(klass.get()).c_str());
2682 return false;
2683 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002684 }
2685 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002686 // Mark the class as loaded.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002687 klass->SetStatus(Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002688 return true;
2689}
2690
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002691bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002692 CHECK(!klass->IsPrimitive());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002693 Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002694 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002695 if (super != NULL) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002696 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002697 "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002698 return false;
2699 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002700 return true;
2701 }
2702 if (super == NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002703 ThrowLinkageError("No superclass defined for class %s", PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002704 return false;
2705 }
2706 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002707 if (super->IsFinal() || super->IsInterface()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002708 Thread* self = Thread::Current();
2709 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002710 "Superclass %s of %s is %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002711 PrettyDescriptor(super).c_str(),
2712 PrettyDescriptor(klass.get()).c_str(),
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002713 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002714 return false;
2715 }
2716 if (!klass->CanAccess(super)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002717 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002718 "Superclass %s is inaccessible by %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002719 PrettyDescriptor(super).c_str(),
2720 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002721 return false;
2722 }
Elliott Hughes20cde902011-10-04 17:37:27 -07002723
2724 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
2725 if (super->IsFinalizable()) {
2726 klass->SetFinalizable();
2727 }
2728
Elliott Hughes2da50362011-10-10 16:57:08 -07002729 // Inherit reference flags (if any) from the superclass.
2730 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
2731 if (reference_flags != 0) {
2732 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
2733 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002734 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07002735 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002736 ThrowLinkageError("Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002737 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002738 return false;
2739 }
Elliott Hughes2da50362011-10-10 16:57:08 -07002740
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002741#ifndef NDEBUG
2742 // Ensure super classes are fully resolved prior to resolving fields..
2743 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002744 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002745 super = super->GetSuperClass();
2746 }
2747#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002748 return true;
2749}
2750
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002751// Populate the class vtable and itable. Compute return type indices.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002752bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002753 if (klass->IsInterface()) {
2754 // No vtable.
2755 size_t count = klass->NumVirtualMethods();
2756 if (!IsUint(16, count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08002757 ThrowClassFormatError("Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002758 return false;
2759 }
Carl Shapiro565f5072011-07-10 13:39:43 -07002760 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002761 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002762 }
jeffhaobdb76512011-09-07 11:43:16 -07002763 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002764 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002765 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07002766 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002767 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002768 }
2769 return true;
2770}
2771
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002772bool ClassLinker::LinkVirtualMethods(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002773 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002774 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
2775 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002776 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002777 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08002778 SirtRef<ObjectArray<Method> > vtable(klass->GetSuperClass()->GetVTable()->CopyOf(max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002779 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002780 MethodHelper local_mh(NULL, this);
2781 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002782 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002783 Method* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002784 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002785 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002786 for (; j < actual_count; ++j) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002787 Method* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002788 super_mh.ChangeMethod(super_method);
2789 if (local_mh.HasSameNameAndSignature(&super_mh)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002790 // Verify
2791 if (super_method->IsFinal()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002792 MethodHelper mh(local_method);
Elliott Hughese555dc02011-09-25 10:46:35 -07002793 ThrowLinkageError("Method %s.%s overrides final method in class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002794 PrettyDescriptor(klass.get()).c_str(),
2795 mh.GetName(), mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002796 return false;
2797 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002798 vtable->Set(j, local_method);
2799 local_method->SetMethodIndex(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002800 break;
2801 }
2802 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002803 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002804 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002805 vtable->Set(actual_count, local_method);
2806 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002807 actual_count += 1;
2808 }
2809 }
2810 if (!IsUint(16, actual_count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08002811 ThrowClassFormatError("Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002812 return false;
2813 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002814 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002815 CHECK_LE(actual_count, max_count);
2816 if (actual_count < max_count) {
Ian Rogers30fab402012-01-23 15:43:46 -08002817 vtable.reset(vtable->CopyOf(actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002818 }
Ian Rogers30fab402012-01-23 15:43:46 -08002819 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002820 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002821 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002822 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002823 if (!IsUint(16, num_virtual_methods)) {
Elliott Hughese555dc02011-09-25 10:46:35 -07002824 ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002825 return false;
2826 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002827 SirtRef<ObjectArray<Method> > vtable(AllocObjectArray<Method>(num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002828 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002829 Method* virtual_method = klass->GetVirtualMethodDuringLinking(i);
2830 vtable->Set(i, virtual_method);
2831 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002832 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002833 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002834 }
2835 return true;
2836}
2837
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002838bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002839 size_t super_ifcount;
2840 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002841 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002842 } else {
2843 super_ifcount = 0;
2844 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002845 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002846 ClassHelper kh(klass.get(), this);
2847 uint32_t num_interfaces = interfaces == NULL ? kh.NumInterfaces() : interfaces->GetLength();
2848 ifcount += num_interfaces;
2849 for (size_t i = 0; i < num_interfaces; i++) {
2850 Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
2851 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002852 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002853 if (ifcount == 0) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002854 // TODO: enable these asserts with klass status validation
Elliott Hughesf5a7a472011-10-07 14:31:02 -07002855 // DCHECK_EQ(klass->GetIfTableCount(), 0);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002856 // DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002857 return true;
2858 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002859 SirtRef<ObjectArray<InterfaceEntry> > iftable(AllocObjectArray<InterfaceEntry>(ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002860 if (super_ifcount != 0) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002861 ObjectArray<InterfaceEntry>* super_iftable = klass->GetSuperClass()->GetIfTable();
2862 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogersb52b01a2012-01-12 17:01:38 -08002863 Class* super_interface = super_iftable->Get(i)->GetInterface();
2864 iftable->Set(i, AllocInterfaceEntry(super_interface));
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002865 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002866 }
2867 // Flatten the interface inheritance hierarchy.
2868 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002869 for (size_t i = 0; i < num_interfaces; i++) {
2870 Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002871 DCHECK(interface != NULL);
2872 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002873 ClassHelper ih(interface);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002874 Thread* self = Thread::Current();
2875 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002876 "Class %s implements non-interface class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002877 PrettyDescriptor(klass.get()).c_str(),
2878 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002879 return false;
2880 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08002881 // Check if interface is already in iftable
2882 bool duplicate = false;
2883 for (size_t j = 0; j < idx; j++) {
2884 Class* existing_interface = iftable->Get(j)->GetInterface();
2885 if (existing_interface == interface) {
2886 duplicate = true;
2887 break;
2888 }
2889 }
2890 if (!duplicate) {
2891 // Add this non-duplicate interface.
2892 iftable->Set(idx++, AllocInterfaceEntry(interface));
2893 // Add this interface's non-duplicate super-interfaces.
2894 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
2895 Class* super_interface = interface->GetIfTable()->Get(j)->GetInterface();
2896 bool super_duplicate = false;
2897 for (size_t k = 0; k < idx; k++) {
2898 Class* existing_interface = iftable->Get(k)->GetInterface();
2899 if (existing_interface == super_interface) {
2900 super_duplicate = true;
2901 break;
2902 }
2903 }
2904 if (!super_duplicate) {
2905 iftable->Set(idx++, AllocInterfaceEntry(super_interface));
2906 }
2907 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002908 }
2909 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08002910 // Shrink iftable in case duplicates were found
2911 if (idx < ifcount) {
2912 iftable.reset(iftable->CopyOf(idx));
2913 ifcount = idx;
2914 } else {
2915 CHECK_EQ(idx, ifcount);
2916 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002917 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07002918
2919 // If we're an interface, we don't need the vtable pointers, so we're done.
2920 if (klass->IsInterface() /*|| super_ifcount == ifcount*/) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002921 return true;
2922 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002923 std::vector<Method*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002924 MethodHelper vtable_mh(NULL, this);
2925 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002926 for (size_t i = 0; i < ifcount; ++i) {
2927 InterfaceEntry* interface_entry = iftable->Get(i);
2928 Class* interface = interface_entry->GetInterface();
2929 ObjectArray<Method>* method_array = AllocObjectArray<Method>(interface->NumVirtualMethods());
2930 interface_entry->SetMethodArray(method_array);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002931 ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002932 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
2933 Method* interface_method = interface->GetVirtualMethod(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002934 interface_mh.ChangeMethod(interface_method);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002935 int32_t k;
Elliott Hughes4681c802011-09-25 18:04:37 -07002936 // For each method listed in the interface's method list, find the
2937 // matching method in our class's method list. We want to favor the
2938 // subclass over the superclass, which just requires walking
2939 // back from the end of the vtable. (This only matters if the
2940 // superclass defines a private method and this class redefines
2941 // it -- otherwise it would use the same vtable slot. In .dex files
2942 // those don't end up in the virtual method table, so it shouldn't
2943 // matter which direction we go. We walk it backward anyway.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002944 for (k = vtable->GetLength() - 1; k >= 0; --k) {
2945 Method* vtable_method = vtable->Get(k);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002946 vtable_mh.ChangeMethod(vtable_method);
2947 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07002948 if (!vtable_method->IsPublic()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002949 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002950 "Implementation not public: %s", PrettyMethod(vtable_method).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002951 return false;
2952 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002953 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002954 break;
2955 }
2956 }
2957 if (k < 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002958 SirtRef<Method> miranda_method(NULL);
Elliott Hughes4681c802011-09-25 18:04:37 -07002959 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002960 Method* mir_method = miranda_list[mir];
2961 vtable_mh.ChangeMethod(mir_method);
2962 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002963 miranda_method.reset(miranda_list[mir]);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002964 break;
2965 }
2966 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002967 if (miranda_method.get() == NULL) {
Elliott Hughes4681c802011-09-25 18:04:37 -07002968 // point the interface table at a phantom slot
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002969 miranda_method.reset(AllocMethod());
2970 memcpy(miranda_method.get(), interface_method, sizeof(Method));
2971 miranda_list.push_back(miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002972 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002973 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002974 }
2975 }
2976 }
Elliott Hughes4681c802011-09-25 18:04:37 -07002977 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002978 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07002979 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07002980 klass->SetVirtualMethods((old_method_count == 0)
2981 ? AllocObjectArray<Method>(new_method_count)
2982 : klass->GetVirtualMethods()->CopyOf(new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002983
Ian Rogers30fab402012-01-23 15:43:46 -08002984 SirtRef<ObjectArray<Method> > vtable(klass->GetVTableDuringLinking());
2985 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002986 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07002987 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers30fab402012-01-23 15:43:46 -08002988 vtable.reset(vtable->CopyOf(new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07002989 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07002990 Method* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07002991 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07002992 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
2993 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
2994 klass->SetVirtualMethod(old_method_count + i, method);
2995 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002996 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002997 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08002998 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002999 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003000
3001 ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
3002 for (int i = 0; i < vtable->GetLength(); ++i) {
3003 CHECK(vtable->Get(i) != NULL);
3004 }
3005
3006// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3007
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003008 return true;
3009}
3010
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003011bool ClassLinker::LinkInstanceFields(SirtRef<Class>& klass) {
3012 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003013 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003014}
3015
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003016bool ClassLinker::LinkStaticFields(SirtRef<Class>& klass) {
3017 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003018 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003019 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003020 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003021 return success;
3022}
3023
Brian Carlstromdbc05252011-09-09 01:59:59 -07003024struct LinkFieldsComparator {
Elliott Hughesba8eee12012-01-24 20:25:24 -08003025 explicit LinkFieldsComparator(FieldHelper* fh) : fh_(fh) {}
Elliott Hughes3b6baaa2011-10-14 19:13:56 -07003026 bool operator()(const Field* field1, const Field* field2) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003027 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003028 fh_->ChangeField(field1);
3029 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3030 fh_->ChangeField(field2);
3031 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003032 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3033 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3034 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3035 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003036 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3037 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3038 if (order1 != order2) {
3039 return order1 < order2;
3040 }
3041
3042 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003043 fh_->ChangeField(field1);
3044 StringPiece name1(fh_->GetName());
3045 fh_->ChangeField(field2);
3046 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003047 return name1 < name2;
3048 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003049
3050 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003051};
3052
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003053bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003054 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003055 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003056
3057 ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003058 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003059
3060 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003061 size_t size;
3062 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003063 if (is_static) {
3064 size = klass->GetClassSize();
3065 field_offset = Class::FieldsOffset();
3066 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003067 Class* super_class = klass->GetSuperClass();
3068 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003069 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003070 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003071 }
3072 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003073 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003074
Brian Carlstromdbc05252011-09-09 01:59:59 -07003075 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003076
Brian Carlstromdbc05252011-09-09 01:59:59 -07003077 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003078 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromdbc05252011-09-09 01:59:59 -07003079 std::deque<Field*> grouped_and_sorted_fields;
3080 for (size_t i = 0; i < num_fields; i++) {
3081 grouped_and_sorted_fields.push_back(fields->Get(i));
3082 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003083 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003084 std::sort(grouped_and_sorted_fields.begin(),
3085 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003086 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003087
3088 // References should be at the front.
3089 size_t current_field = 0;
3090 size_t num_reference_fields = 0;
3091 for (; current_field < num_fields; current_field++) {
3092 Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003093 fh.ChangeField(field);
3094 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003095 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003096 if (isPrimitive) {
3097 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003098 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003099 grouped_and_sorted_fields.pop_front();
3100 num_reference_fields++;
3101 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003102 field->SetOffset(field_offset);
3103 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003104 }
3105
3106 // Now we want to pack all of the double-wide fields together. If
3107 // we're not aligned, though, we want to shuffle one 32-bit field
3108 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003109 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003110 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
3111 Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003112 fh.ChangeField(field);
3113 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003114 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3115 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003116 continue;
3117 }
3118 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003119 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003120 // drop the consumed field
3121 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3122 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003123 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003124 // whether we found a 32-bit field for padding or not, we advance
3125 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003126 }
3127
3128 // Alignment is good, shuffle any double-wide fields forward, and
3129 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003130 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003131 while (!grouped_and_sorted_fields.empty()) {
3132 Field* field = grouped_and_sorted_fields.front();
3133 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003134 fh.ChangeField(field);
3135 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003136 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003137 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003138 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003139 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003140 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003141 ? sizeof(uint64_t)
3142 : sizeof(uint32_t)));
3143 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003144 }
3145
Elliott Hughesadb460d2011-10-05 17:02:34 -07003146 // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003147 std::string descriptor(ClassHelper(klass.get(), this).GetDescriptor());
3148 if (!is_static && descriptor == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003149 // We know there are no non-reference fields in the Reference classes, and we know
3150 // that 'referent' is alphabetically last, so this is easy...
3151 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003152 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003153 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003154 --num_reference_fields;
3155 }
3156
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003157#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003158 // Make sure that all reference fields appear before
3159 // non-reference fields, and all double-wide fields are aligned.
3160 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003161 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003162 Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003163 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003164 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003165 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003166 << " field=" << PrettyField(field)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003167 << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
3168 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003169 fh.ChangeField(field);
3170 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003171 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003172 if (descriptor == "Ljava/lang/ref/Reference;" && StringPiece(fh.GetName()) == "referent") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003173 is_primitive = true; // We lied above, so we have to expect a lie here.
3174 }
3175 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003176 if (!seen_non_ref) {
3177 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003178 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003179 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003180 } else {
3181 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003182 }
3183 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003184 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003185 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003186 }
3187#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003188 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003189 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003190 if (is_static) {
3191 klass->SetNumReferenceStaticFields(num_reference_fields);
3192 klass->SetClassSize(size);
3193 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003194 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003195 if (!klass->IsVariableSize()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003196 klass->SetObjectSize(size);
3197 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003198 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003199 return true;
3200}
3201
3202// Set the bitmap of reference offsets, refOffsets, from the ifields
3203// list.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003204void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003205 uint32_t reference_offsets = 0;
3206 Class* super_class = klass->GetSuperClass();
3207 if (super_class != NULL) {
3208 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003209 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003210 if (reference_offsets == CLASS_WALK_SUPER) {
3211 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003212 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003213 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003214 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003215 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003216}
3217
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003218void ClassLinker::CreateReferenceStaticOffsets(SirtRef<Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003219 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003220}
3221
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003222void ClassLinker::CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003223 uint32_t reference_offsets) {
3224 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003225 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3226 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003227 const ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003228 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003229 // All of the fields that contain object references are guaranteed
3230 // to be at the beginning of the fields list.
3231 for (size_t i = 0; i < num_reference_fields; ++i) {
3232 // Note that byte_offset is the offset from the beginning of
3233 // object, not the offset into instance data
3234 const Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003235 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003236 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3237 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3238 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003239 CHECK_NE(new_bit, 0U);
3240 reference_offsets |= new_bit;
3241 } else {
3242 reference_offsets = CLASS_WALK_SUPER;
3243 break;
3244 }
3245 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003246 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003247 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003248 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003249 } else {
3250 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003251 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003252}
3253
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003254String* ClassLinker::ResolveString(const DexFile& dex_file,
Elliott Hughescf4c6c42011-09-01 15:16:42 -07003255 uint32_t string_idx, DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003256 DCHECK(dex_cache != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003257 String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003258 if (resolved != NULL) {
3259 return resolved;
3260 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003261 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3262 int32_t utf16_length = dex_file.GetStringLength(string_id);
3263 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom928bf022011-10-11 02:48:14 -07003264 String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003265 dex_cache->SetResolvedString(string_idx, string);
3266 return string;
3267}
3268
3269Class* ClassLinker::ResolveType(const DexFile& dex_file,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003270 uint16_t type_idx,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003271 DexCache* dex_cache,
3272 const ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003273 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003274 Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003275 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003276 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003277 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003278 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003279 // TODO: we used to throw here if resolved's class loader was not the
3280 // boot class loader. This was to permit different classes with the
3281 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003282 dex_cache->SetResolvedType(type_idx, resolved);
3283 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08003284 CHECK(Thread::Current()->IsExceptionPending())
3285 << "Expected pending exception for failed resolution of: " << descriptor;
jeffhao8cd6dda2012-02-22 10:15:34 -08003286 // Convert a ClassNotFoundException to a NoClassDefFoundError
3287 if (Thread::Current()->GetException()->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
3288 Thread::Current()->ClearException();
3289 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
3290 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003291 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003292 }
3293 return resolved;
3294}
3295
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003296Method* ClassLinker::ResolveMethod(const DexFile& dex_file,
3297 uint32_t method_idx,
3298 DexCache* dex_cache,
3299 const ClassLoader* class_loader,
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003300 bool is_direct) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003301 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003302 Method* resolved = dex_cache->GetResolvedMethod(method_idx);
3303 if (resolved != NULL) {
3304 return resolved;
3305 }
3306 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
3307 Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
3308 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003309 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003310 return NULL;
3311 }
3312
Brian Carlstrom7540ff42011-09-04 16:38:46 -07003313 if (is_direct) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003314 resolved = klass->FindDirectMethod(dex_cache, method_idx);
Brian Carlstrom7540ff42011-09-04 16:38:46 -07003315 } else if (klass->IsInterface()) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003316 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003317 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003318 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003319 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003320
3321 if (resolved == NULL) {
3322 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3323 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3324 if (is_direct) {
3325 resolved = klass->FindDirectMethod(name, signature);
3326 } else if (klass->IsInterface()) {
3327 resolved = klass->FindInterfaceMethod(name, signature);
3328 } else {
3329 resolved = klass->FindVirtualMethod(name, signature);
jeffhao8cd6dda2012-02-22 10:15:34 -08003330 // If a virtual method isn't found, search the direct methods. This can
3331 // happen when trying to access private methods directly, and allows the
3332 // proper exception to be thrown in the caller.
3333 if (resolved == NULL) {
3334 resolved = klass->FindDirectMethod(name, signature);
3335 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003336 }
3337 if (resolved == NULL) {
3338 ThrowNoSuchMethodError(is_direct, klass, name, signature);
3339 return NULL;
3340 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003341 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003342 dex_cache->SetResolvedMethod(method_idx, resolved);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003343 return resolved;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003344}
3345
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003346Field* ClassLinker::ResolveField(const DexFile& dex_file,
3347 uint32_t field_idx,
3348 DexCache* dex_cache,
3349 const ClassLoader* class_loader,
3350 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003351 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003352 Field* resolved = dex_cache->GetResolvedField(field_idx);
3353 if (resolved != NULL) {
3354 return resolved;
3355 }
3356 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3357 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3358 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003359 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003360 return NULL;
3361 }
3362
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003363 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003364 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003365 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003366 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003367 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003368
3369 if (resolved == NULL) {
3370 const char* name = dex_file.GetFieldName(field_id);
3371 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3372 if (is_static) {
3373 resolved = klass->FindStaticField(name, type);
3374 } else {
3375 resolved = klass->FindInstanceField(name, type);
3376 }
3377 if (resolved == NULL) {
3378 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3379 return NULL;
3380 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003381 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003382 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003383 return resolved;
3384}
3385
3386Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3387 uint32_t field_idx,
3388 DexCache* dex_cache,
3389 const ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003390 DCHECK(dex_cache != NULL);
Ian Rogersb067ac22011-12-13 18:05:09 -08003391 Field* resolved = dex_cache->GetResolvedField(field_idx);
3392 if (resolved != NULL) {
3393 return resolved;
3394 }
3395 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3396 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3397 if (klass == NULL) {
3398 DCHECK(Thread::Current()->IsExceptionPending());
3399 return NULL;
3400 }
3401
3402 const char* name = dex_file.GetFieldName(field_id);
3403 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3404 resolved = klass->FindField(name, type);
3405 if (resolved != NULL) {
3406 dex_cache->SetResolvedField(field_idx, resolved);
3407 } else {
3408 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003409 }
3410 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003411}
3412
Ian Rogers19846512012-02-24 11:42:47 -08003413const char* ClassLinker::MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length) {
Ian Rogersad25ac52011-10-04 19:13:33 -07003414 Class* declaring_class = referrer->GetDeclaringClass();
3415 DexCache* dex_cache = declaring_class->GetDexCache();
3416 const DexFile& dex_file = FindDexFile(dex_cache);
3417 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003418 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003419}
3420
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003421void ClassLinker::DumpAllClasses(int flags) const {
3422 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3423 // lock held, because it might need to resolve a field's type, which would try to take the lock.
3424 std::vector<Class*> all_classes;
3425 {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003426 MutexLock mu(classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003427 typedef Table::const_iterator It; // TODO: C++0x auto
3428 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3429 all_classes.push_back(it->second);
3430 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003431 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3432 all_classes.push_back(it->second);
3433 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003434 }
3435
3436 for (size_t i = 0; i < all_classes.size(); ++i) {
3437 all_classes[i]->DumpClass(std::cerr, flags);
3438 }
3439}
3440
Elliott Hughescac6cc72011-11-03 20:31:21 -07003441void ClassLinker::DumpForSigQuit(std::ostream& os) const {
3442 MutexLock mu(classes_lock_);
3443 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3444 << classes_.size() << " allocated classes\n";
3445}
3446
Elliott Hughese27955c2011-08-26 15:21:24 -07003447size_t ClassLinker::NumLoadedClasses() const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003448 MutexLock mu(classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003449 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003450}
3451
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003452pid_t ClassLinker::GetClassesLockOwner() {
3453 return classes_lock_.GetOwner();
3454}
3455
3456pid_t ClassLinker::GetDexLockOwner() {
3457 return dex_lock_.GetOwner();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003458}
3459
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003460void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
3461 DCHECK(!init_done_);
3462
3463 DCHECK(klass != NULL);
3464 DCHECK(klass->GetClassLoader() == NULL);
3465
3466 DCHECK(class_roots_ != NULL);
3467 DCHECK(class_roots_->Get(class_root) == NULL);
3468 class_roots_->Set(class_root, klass);
3469}
3470
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003471} // namespace art