blob: e755cbdf3748652e9f01010f9314806f2782cd1d [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 Hughes0512f022012-03-15 22:10:52 -070056static void ThrowNoClassDefFoundError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
57static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070058 va_list args;
59 va_start(args, fmt);
60 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
61 va_end(args);
62}
63
Elliott Hughes0512f022012-03-15 22:10:52 -070064static void ThrowClassFormatError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
65static void ThrowClassFormatError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070066 va_list args;
67 va_start(args, fmt);
Elliott Hughese555dc02011-09-25 10:46:35 -070068 Thread::Current()->ThrowNewExceptionV("Ljava/lang/ClassFormatError;", fmt, args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -070069 va_end(args);
70}
71
Elliott Hughes0512f022012-03-15 22:10:52 -070072static void ThrowLinkageError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
73static void ThrowLinkageError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070074 va_list args;
75 va_start(args, fmt);
76 Thread::Current()->ThrowNewExceptionV("Ljava/lang/LinkageError;", fmt, args);
77 va_end(args);
78}
79
Elliott Hughes0512f022012-03-15 22:10:52 -070080static void ThrowNoSuchMethodError(bool is_direct, Class* c, const StringPiece& name,
81 const StringPiece& signature) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080082 ClassHelper kh(c);
Elliott Hughes3b6baaa2011-10-14 19:13:56 -070083 std::ostringstream msg;
Ian Rogersc8b306f2012-02-17 21:34:44 -080084 msg << "no " << (is_direct ? "direct" : "virtual") << " method " << name << signature
Ian Rogers9f1ab122011-12-12 08:52:43 -080085 << " in class " << kh.GetDescriptor() << " or its superclasses";
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080086 std::string location(kh.GetLocation());
87 if (!location.empty()) {
88 msg << " (defined in " << location << ")";
Elliott Hughescc5f9a92011-09-28 19:17:29 -070089 }
Elliott Hughes5cb5ad22011-10-02 12:13:39 -070090 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
Elliott Hughescc5f9a92011-09-28 19:17:29 -070091}
92
Elliott Hughes0512f022012-03-15 22:10:52 -070093static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
94 const StringPiece& name) {
Ian Rogers9f1ab122011-12-12 08:52:43 -080095 ClassHelper kh(c);
96 std::ostringstream msg;
Ian Rogersb067ac22011-12-13 18:05:09 -080097 msg << "no " << scope << "field " << name << " of type " << type
Ian Rogers9f1ab122011-12-12 08:52:43 -080098 << " in class " << kh.GetDescriptor() << " or its superclasses";
99 std::string location(kh.GetLocation());
100 if (!location.empty()) {
101 msg << " (defined in " << location << ")";
102 }
103 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
104}
105
Elliott Hughes0512f022012-03-15 22:10:52 -0700106static void ThrowNullPointerException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
107static void ThrowNullPointerException(const char* fmt, ...) {
Ian Rogerscab01012012-01-10 17:35:46 -0800108 va_list args;
109 va_start(args, fmt);
110 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NullPointerException;", fmt, args);
111 va_end(args);
112}
113
Elliott Hughes0512f022012-03-15 22:10:52 -0700114static void ThrowEarlierClassFailure(Class* c) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700115 /*
116 * The class failed to initialize on a previous attempt, so we want to throw
117 * a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
118 * failed in verification, in which case v2 5.4.1 says we need to re-throw
119 * the previous error.
120 */
121 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
122
Brian Carlstrom4d9716c2012-01-30 01:49:33 -0800123 CHECK(c->IsErroneous()) << PrettyClass(c);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700124 if (c->GetVerifyErrorClass() != NULL) {
125 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800126 ClassHelper ve_ch(c->GetVerifyErrorClass());
127 std::string error_descriptor(ve_ch.GetDescriptor());
128 Thread::Current()->ThrowNewException(error_descriptor.c_str(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700129 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800130 ThrowNoClassDefFoundError("%s", PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700131 }
132}
133
Elliott Hughes0512f022012-03-15 22:10:52 -0700134static void WrapExceptionInInitializer() {
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700135 JNIEnv* env = Thread::Current()->GetJniEnv();
136
137 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
138 CHECK(cause.get() != NULL);
139
140 env->ExceptionClear();
141
142 // TODO: add java.lang.Error to JniConstants?
143 ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/Error"));
144 CHECK(error_class.get() != NULL);
145 if (env->IsInstanceOf(cause.get(), error_class.get())) {
146 // We only wrap non-Error exceptions; an Error can just be used as-is.
147 env->Throw(cause.get());
148 return;
149 }
150
151 // TODO: add java.lang.ExceptionInInitializerError to JniConstants?
152 ScopedLocalRef<jclass> eiie_class(env, env->FindClass("java/lang/ExceptionInInitializerError"));
153 CHECK(eiie_class.get() != NULL);
154
155 jmethodID mid = env->GetMethodID(eiie_class.get(), "<init>" , "(Ljava/lang/Throwable;)V");
156 CHECK(mid != NULL);
157
158 ScopedLocalRef<jthrowable> eiie(env,
159 reinterpret_cast<jthrowable>(env->NewObject(eiie_class.get(), mid, cause.get())));
160 env->Throw(eiie.get());
161}
162
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800163static size_t Hash(const char* s) {
164 // This is the java.lang.String hashcode for convenience, not interoperability.
165 size_t hash = 0;
166 for (; *s != '\0'; ++s) {
167 hash = hash * 31 + *s;
168 }
169 return hash;
170}
171
Elliott Hughes418d20f2011-09-22 14:00:39 -0700172const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700173 "Ljava/lang/Class;",
174 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700175 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700176 "[Ljava/lang/Object;",
177 "Ljava/lang/String;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700178 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700179 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700180 "Ljava/lang/reflect/Field;",
181 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700182 "Ljava/lang/reflect/Proxy;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700183 "Ljava/lang/ClassLoader;",
184 "Ldalvik/system/BaseDexClassLoader;",
185 "Ldalvik/system/PathClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800186 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800187 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700188 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700189 "Z",
190 "B",
191 "C",
192 "D",
193 "F",
194 "I",
195 "J",
196 "S",
197 "V",
198 "[Z",
199 "[B",
200 "[C",
201 "[D",
202 "[F",
203 "[I",
204 "[J",
205 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700206 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700207};
208
Brian Carlstroma004aa92012-02-08 18:05:09 -0800209ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
210 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700211 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800212 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800213 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700214 return class_linker.release();
215}
216
Brian Carlstroma004aa92012-02-08 18:05:09 -0800217ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800218 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700219 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700220 return class_linker.release();
221}
222
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800223ClassLinker::ClassLinker(InternTable* intern_table)
224 : dex_lock_("ClassLinker dex lock"),
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700225 classes_lock_("ClassLinker classes lock"),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700226 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700227 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700228 init_done_(false),
229 intern_table_(intern_table) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700230 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700231}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700232
Brian Carlstroma004aa92012-02-08 18:05:09 -0800233void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
234 VLOG(startup) << "ClassLinker::Init";
235 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700236
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700237 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700238
Elliott Hughes30646832011-10-13 16:59:46 -0700239 // java_lang_Class comes first, it's needed for AllocClass
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800240 Heap* heap = Runtime::Current()->GetHeap();
241 SirtRef<Class> java_lang_Class(down_cast<Class*>(heap->AllocObject(NULL, sizeof(ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700242 CHECK(java_lang_Class.get() != NULL);
243 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700244 java_lang_Class->SetClassSize(sizeof(ClassClass));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700245 // AllocClass(Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700246
Elliott Hughes418d20f2011-09-22 14:00:39 -0700247 // Class[] is used for reflection support.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700248 SirtRef<Class> class_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
249 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700250
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700251 // java_lang_Object comes next so that object_array_class can be created
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700252 SirtRef<Class> java_lang_Object(AllocClass(java_lang_Class.get(), sizeof(Class)));
253 CHECK(java_lang_Object.get() != NULL);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700254 // backfill Object as the super class of Class
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700255 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700256 java_lang_Object->SetStatus(Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700257
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700258 // Object[] next to hold class roots
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700259 SirtRef<Class> object_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
260 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700261
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700262 // Setup the char class to be used for char[]
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700263 SirtRef<Class> char_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700264
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700265 // Setup the char[] class to be used for String
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700266 SirtRef<Class> char_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
267 char_array_class->SetComponentType(char_class.get());
268 CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700269
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700270 // Setup String
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700271 SirtRef<Class> java_lang_String(AllocClass(java_lang_Class.get(), sizeof(StringClass)));
272 String::SetClass(java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700273 java_lang_String->SetObjectSize(sizeof(String));
274 java_lang_String->SetStatus(Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400275
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700276 // Create storage for root classes, save away our work so far (requires
277 // descriptors)
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700278 class_roots_ = ObjectArray<Class>::Alloc(object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700279 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700280 SetClassRoot(kJavaLangClass, java_lang_Class.get());
281 SetClassRoot(kJavaLangObject, java_lang_Object.get());
282 SetClassRoot(kClassArrayClass, class_array_class.get());
283 SetClassRoot(kObjectArrayClass, object_array_class.get());
284 SetClassRoot(kCharArrayClass, char_array_class.get());
285 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700286
287 // Setup the primitive type classes.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700288 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass("Z", Primitive::kPrimBoolean));
289 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass("B", Primitive::kPrimByte));
290 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass("S", Primitive::kPrimShort));
291 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass("I", Primitive::kPrimInt));
292 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass("J", Primitive::kPrimLong));
293 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass("F", Primitive::kPrimFloat));
294 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass("D", Primitive::kPrimDouble));
295 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass("V", Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700296
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700297 // Create array interface entries to populate once we can load system classes
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700298 array_iftable_ = AllocObjectArray<InterfaceEntry>(2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700299
300 // Create int array type for AllocDexCache (done in AppendToBootClassPath)
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700301 SirtRef<Class> int_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700302 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700303 IntArray::SetArrayClass(int_array_class.get());
304 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700305
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700306 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700307
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700308 // setup boot_class_path_ and register class_path now that we can
309 // use AllocObjectArray to create DexCache instances
Brian Carlstroma004aa92012-02-08 18:05:09 -0800310 CHECK_NE(0U, boot_class_path.size());
311 for (size_t i = 0; i != boot_class_path.size(); ++i) {
312 const DexFile* dex_file = boot_class_path[i];
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700313 CHECK(dex_file != NULL);
314 AppendToBootClassPath(*dex_file);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700315 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700316
Elliott Hughes80609252011-09-23 17:24:51 -0700317 // Constructor, Field, and Method are necessary so that FindClass can link members
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700318 SirtRef<Class> java_lang_reflect_Constructor(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700319 CHECK(java_lang_reflect_Constructor.get() != NULL);
Elliott Hughes80609252011-09-23 17:24:51 -0700320 java_lang_reflect_Constructor->SetObjectSize(sizeof(Method));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700321 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
Elliott Hughes80609252011-09-23 17:24:51 -0700322 java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
323
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700324 SirtRef<Class> java_lang_reflect_Field(AllocClass(java_lang_Class.get(), sizeof(FieldClass)));
325 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700326 java_lang_reflect_Field->SetObjectSize(sizeof(Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700327 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700328 java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700329 Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700330
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700331 SirtRef<Class> java_lang_reflect_Method(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700332 CHECK(java_lang_reflect_Method.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700333 java_lang_reflect_Method->SetObjectSize(sizeof(Method));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700334 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700335 java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700336 Method::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700337
338 // now we can use FindSystemClass
339
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700340 // run char class through InitializePrimitiveClass to finish init
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700341 InitializePrimitiveClass(char_class.get(), "C", Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700342 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700343
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700344 // Object and String need to be rerun through FindSystemClass to finish init
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700345 java_lang_Object->SetStatus(Class::kStatusNotReady);
346 Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700347 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700348 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(Object));
349 java_lang_String->SetStatus(Class::kStatusNotReady);
350 Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700351 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700352 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
353
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700354 // Setup the primitive array type classes - can't be done until Object has a vtable
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700355 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
356 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
357
358 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
359 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
360
361 Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700362 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700363
364 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
365 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
366
367 Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700368 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700369
370 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
371 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
372
373 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
374 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
375
376 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
377 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
378
Elliott Hughes418d20f2011-09-22 14:00:39 -0700379 Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700380 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700381
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700382 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700383 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700384
385 // Setup the single, global copies of "interfaces" and "iftable"
386 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
387 CHECK(java_lang_Cloneable != NULL);
388 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
389 CHECK(java_io_Serializable != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700390 // We assume that Cloneable/Serializable don't have superinterfaces --
391 // normally we'd have to crawl up and explicitly list all of the
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700392 // supers as well.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800393 array_iftable_->Set(0, AllocInterfaceEntry(java_lang_Cloneable));
394 array_iftable_->Set(1, AllocInterfaceEntry(java_io_Serializable));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700395
Elliott Hughes418d20f2011-09-22 14:00:39 -0700396 // Sanity check Class[] and Object[]'s interfaces
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800397 ClassHelper kh(class_array_class.get(), this);
398 CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
399 CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
400 kh.ChangeClass(object_array_class.get());
401 CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
402 CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
Elliott Hughes80609252011-09-23 17:24:51 -0700403 // run Class, Constructor, Field, and Method through FindSystemClass.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700404 // this initializes their dex_cache_ fields and register them in classes_.
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700405 Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700406 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700407
Elliott Hughes80609252011-09-23 17:24:51 -0700408 java_lang_reflect_Constructor->SetStatus(Class::kStatusNotReady);
409 Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700410 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700411
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700412 java_lang_reflect_Field->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700413 Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700414 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700415
416 java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700417 Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700418 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700419
Ian Rogers466bb252011-10-14 03:29:56 -0700420 // End of special init trickery, subsequent classes may be loaded via FindSystemClass
421
422 // Create java.lang.reflect.Proxy root
423 Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
424 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
425
Brian Carlstrom1f870082011-08-23 16:02:11 -0700426 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700427 Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
428 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700429 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700430 java_lang_ref_FinalizerReference->SetAccessFlags(
431 java_lang_ref_FinalizerReference->GetAccessFlags() |
432 kAccClassIsReference | kAccClassIsFinalizerReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700433 Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700434 java_lang_ref_PhantomReference->SetAccessFlags(
435 java_lang_ref_PhantomReference->GetAccessFlags() |
436 kAccClassIsReference | kAccClassIsPhantomReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700437 Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700438 java_lang_ref_SoftReference->SetAccessFlags(
439 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700440 Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700441 java_lang_ref_WeakReference->SetAccessFlags(
442 java_lang_ref_WeakReference->GetAccessFlags() |
443 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700444
Brian Carlstromaded5f72011-10-07 17:15:04 -0700445 // Setup the ClassLoaders, verifying the object_size_
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700446 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
Brian Carlstromaded5f72011-10-07 17:15:04 -0700447 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700448 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
449
450 Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
451 CHECK_EQ(dalvik_system_BaseDexClassLoader->GetObjectSize(), sizeof(BaseDexClassLoader));
452 SetClassRoot(kDalvikSystemBaseDexClassLoader, dalvik_system_BaseDexClassLoader);
453
454 Class* dalvik_system_PathClassLoader = FindSystemClass("Ldalvik/system/PathClassLoader;");
455 CHECK_EQ(dalvik_system_PathClassLoader->GetObjectSize(), sizeof(PathClassLoader));
456 SetClassRoot(kDalvikSystemPathClassLoader, dalvik_system_PathClassLoader);
457 PathClassLoader::SetClass(dalvik_system_PathClassLoader);
458
jeffhao8cd6dda2012-02-22 10:15:34 -0800459 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
460 // java.lang.StackTraceElement as a convenience
Ian Rogers5167c972012-02-03 10:41:20 -0800461 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
462 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800463 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700464 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
465 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700466 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700467
Brian Carlstroma663ea52011-08-19 23:33:41 -0700468 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700469
Brian Carlstroma004aa92012-02-08 18:05:09 -0800470 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700471}
472
473void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800474 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700475
476 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700477 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700478 // as the types of the field can't be resolved prior to the runtime being
479 // fully initialized
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700480 Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700481 Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700482 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
483
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800484 Heap* heap = Runtime::Current()->GetHeap();
485 heap->SetWellKnownClasses(java_lang_ref_FinalizerReference, java_lang_ref_ReferenceQueue);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700486
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800487 const DexFile& java_lang_dex = FindDexFile(java_lang_ref_Reference->GetDexCache());
488
Brian Carlstrom16192862011-09-12 17:50:06 -0700489 Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800490 FieldHelper fh(pendingNext, this);
491 CHECK_STREQ(fh.GetName(), "pendingNext");
492 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
493 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700494
495 Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800496 fh.ChangeField(queue);
497 CHECK_STREQ(fh.GetName(), "queue");
498 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
499 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700500
501 Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800502 fh.ChangeField(queueNext);
503 CHECK_STREQ(fh.GetName(), "queueNext");
504 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
505 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700506
507 Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800508 fh.ChangeField(referent);
509 CHECK_STREQ(fh.GetName(), "referent");
510 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
511 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700512
513 Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800514 fh.ChangeField(zombie);
515 CHECK_STREQ(fh.GetName(), "zombie");
516 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
517 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700518
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800519 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700520 queue->GetOffset(),
521 queueNext->GetOffset(),
522 pendingNext->GetOffset(),
523 zombie->GetOffset());
524
Brian Carlstroma663ea52011-08-19 23:33:41 -0700525 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700526 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700527 ClassRoot class_root = static_cast<ClassRoot>(i);
528 Class* klass = GetClassRoot(class_root);
529 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700530 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700531 // note SetClassRoot does additional validation.
532 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700533 }
534
Elliott Hughes92f14b22011-10-06 12:29:54 -0700535 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700536
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700537 // disable the slow paths in FindClass and CreatePrimitiveClass now
538 // that Object, Class, and Object[] are setup
539 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700540
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800541 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700542}
543
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700544void ClassLinker::RunRootClinits() {
545 Thread* self = Thread::Current();
546 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
547 Class* c = GetClassRoot(ClassRoot(i));
548 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700549 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -0700550 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700551 }
552 }
553}
554
Brian Carlstromd601af82012-01-06 10:15:19 -0800555bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
556 int oat_fd,
557 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800558 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700559 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800560 const char* dex2oat = dex2oat_string.c_str();
561
Brian Carlstroma004aa92012-02-08 18:05:09 -0800562 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800563
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800564 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800565 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700566 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800567 const char* boot_image_option = boot_image_option_string.c_str();
568
569 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800570 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800571 const char* dex_file_option = dex_file_option_string.c_str();
572
Brian Carlstromd601af82012-01-06 10:15:19 -0800573 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800574 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800575 const char* oat_fd_option = oat_fd_option_string.c_str();
576
Brian Carlstroma004aa92012-02-08 18:05:09 -0800577 std::string oat_location_option_string("--oat-location=");
578 oat_location_option_string += oat_cache_filename;
579 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800580
jeffhao262bf462011-10-20 18:36:32 -0700581 // fork and exec dex2oat
582 pid_t pid = fork();
583 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800584 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800585
586 // change process groups, so we don't get reaped by ProcessManager
587 setpgid(0, 0);
588
jeffhao10037c82012-01-23 15:06:23 -0800589 VLOG(class_linker) << dex2oat
590 << " --runtime-arg -Xms64m"
591 << " --runtime-arg -Xmx64m"
592 << " --runtime-arg -classpath"
593 << " --runtime-arg " << class_path
594 << " " << boot_image_option
595 << " " << dex_file_option
596 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800597 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800598
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800599 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700600 "--runtime-arg", "-Xms64m",
601 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500602 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800603 "--runtime-arg", class_path,
604 boot_image_option,
605 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800606 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800607 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700608 NULL);
609
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800610 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800611 return false;
jeffhao262bf462011-10-20 18:36:32 -0700612 } else {
613 // wait for dex2oat to finish
614 int status;
615 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
616 if (got_pid != pid) {
617 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800618 return false;
jeffhao262bf462011-10-20 18:36:32 -0700619 }
620 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800621 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
622 return false;
jeffhao262bf462011-10-20 18:36:32 -0700623 }
624 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800625 return true;
jeffhao262bf462011-10-20 18:36:32 -0700626}
627
Brian Carlstrom866c8622012-01-06 16:35:13 -0800628void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
629 MutexLock mu(dex_lock_);
630 RegisterOatFileLocked(oat_file);
631}
632
633void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
634 dex_lock_.AssertHeld();
635 oat_files_.push_back(&oat_file);
636}
637
Ian Rogers30fab402012-01-23 15:43:46 -0800638OatFile* ClassLinker::OpenOat(const ImageSpace* space) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700639 MutexLock mu(dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700640 const Runtime* runtime = Runtime::Current();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700641 const ImageHeader& image_header = space->GetImageHeader();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800642 // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
643 // check the down cast
644 String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700645 std::string oat_filename;
646 oat_filename += runtime->GetHostPrefix();
647 oat_filename += oat_location->ToModifiedUtf8();
Logan Chien0c717dd2012-03-28 18:31:07 +0800648 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename,
649 image_header.GetOatBegin(),
650 OatFile::kRelocNone);
Ian Rogers30fab402012-01-23 15:43:46 -0800651 VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700652 if (oat_file == NULL) {
Brian Carlstroma9f19782011-10-13 00:14:47 -0700653 LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700654 return NULL;
655 }
656 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
657 uint32_t image_oat_checksum = image_header.GetOatChecksum();
658 if (oat_checksum != image_oat_checksum) {
Brian Carlstrom866c8622012-01-06 16:35:13 -0800659 LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700660 << " to expected oat checksum " << std::hex << oat_checksum
661 << " in image";
662 return NULL;
663 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800664 RegisterOatFileLocked(*oat_file);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800665 VLOG(startup) << "ClassLinker::OpenOat exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700666 return oat_file;
667}
668
Brian Carlstromae826982011-11-09 01:33:42 -0800669const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800670 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800671}
672
Brian Carlstroma004aa92012-02-08 18:05:09 -0800673const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800674 for (size_t i = 0; i < oat_files_.size(); i++) {
675 const OatFile* oat_file = oat_files_[i];
676 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800677 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800678 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800679 return oat_file;
680 }
681 }
682 return NULL;
683}
684
Brian Carlstromd601af82012-01-06 10:15:19 -0800685class LockedFd {
686 public:
687 static LockedFd* CreateAndLock(std::string& name, mode_t mode) {
688 int fd = open(name.c_str(), O_CREAT | O_RDWR, mode);
689 if (fd == -1) {
690 PLOG(ERROR) << "Failed to open file '" << name << "'";
691 return NULL;
692 }
693 fchmod(fd, mode);
694
695 LOG(INFO) << "locking file " << name << " (fd=" << fd << ")";
696 // try to lock non-blocking so we can log if we need may need to block
697 int result = flock(fd, LOCK_EX | LOCK_NB);
698 if (result == -1) {
699 LOG(WARNING) << "sleeping while locking file " << name;
700 // retry blocking
701 result = flock(fd, LOCK_EX);
702 }
703 if (result == -1) {
704 PLOG(ERROR) << "Failed to lock file '" << name << "'";
705 close(fd);
706 return NULL;
707 }
708 return new LockedFd(fd);
709 }
710
711 int GetFd() const {
712 return fd_;
713 }
714
715 ~LockedFd() {
716 if (fd_ != -1) {
717 int result = flock(fd_, LOCK_UN);
718 if (result == -1) {
719 PLOG(WARNING) << "flock(" << fd_ << ", LOCK_UN) failed";
720 }
721 close(fd_);
722 }
723 }
724
725 private:
726 explicit LockedFd(int fd) : fd_(fd) {}
727
728 int fd_;
729};
730
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800731static const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
732 uint32_t dex_location_checksum,
733 const std::string& oat_location) {
Logan Chien0c717dd2012-03-28 18:31:07 +0800734 UniquePtr<OatFile> oat_file(
735 OatFile::Open(oat_location, oat_location, NULL, OatFile::kRelocAll));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800736 if (oat_file.get() == NULL) {
737 return NULL;
738 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700739 Runtime* runtime = Runtime::Current();
740 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
741 if (oat_file->GetOatHeader().GetImageFileLocationChecksum() != image_header.GetOatChecksum()) {
742 return NULL;
743 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800744 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
745 if (oat_dex_file == NULL) {
746 return NULL;
747 }
748 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
749 return NULL;
750 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700751 runtime->GetClassLinker()->RegisterOatFile(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800752 return oat_dex_file->OpenDexFile();
753}
754
755const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
756 const std::string& oat_location) {
757 uint32_t dex_location_checksum;
758 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
759 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
760 return NULL;
761 }
762
763 // Check if we already have an up-to-date output file
764 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
765 dex_location_checksum,
766 oat_location);
767 if (dex_file != NULL) {
768 return dex_file;
769 }
770
771 // Generate the output oat file for the dex file
772 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
773 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
774 if (file.get() == NULL) {
775 LOG(ERROR) << "Failed to create oat file: " << oat_location;
776 return NULL;
777 }
778 if (!class_linker->GenerateOatFile(dex_location, file->Fd(), oat_location)) {
779 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
780 return NULL;
781 }
782 // Open the oat from file descriptor we passed to GenerateOatFile
783 if (lseek(file->Fd(), 0, SEEK_SET) != 0) {
784 LOG(ERROR) << "Failed to seek to start of generated oat file: " << oat_location;
785 return NULL;
786 }
Logan Chien0c717dd2012-03-28 18:31:07 +0800787 const OatFile* oat_file =
788 OatFile::Open(*file.get(), oat_location, NULL, OatFile::kRelocAll);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800789 if (oat_file == NULL) {
790 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
791 return NULL;
792 }
793 class_linker->RegisterOatFile(*oat_file);
794 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
795 if (oat_dex_file == NULL) {
796 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
797 return NULL;
798 }
799 return oat_dex_file->OpenDexFile();
800}
801
802const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700803 MutexLock mu(dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800804
Brian Carlstroma004aa92012-02-08 18:05:09 -0800805 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800806 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800807 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800808 }
809
Brian Carlstroma004aa92012-02-08 18:05:09 -0800810 // Look for an existing file next to dex, assuming its up-to-date if found
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800811 std::string oat_filename(OatFile::DexFilenameToOatFilename(dex_location));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800812 const OatFile* oat_file = FindOatFileFromOatLocation(oat_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800813 if (oat_file != NULL) {
814 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800815 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
816 return oat_dex_file->OpenDexFile();
817 }
818 // Look for an existing file in the art-cache, validating the result if found
819 // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
820 std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
821 oat_file = FindOatFileFromOatLocation(cache_location);
822 if (oat_file != NULL) {
823 uint32_t dex_location_checksum;
824 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
825 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
826 return NULL;
827 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700828
829 Runtime* runtime = Runtime::Current();
830 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
831 uint32_t image_checksum = image_header.GetOatChecksum();
832 bool image_check = (oat_file->GetOatHeader().GetImageFileLocationChecksum() == image_checksum);
833
Brian Carlstroma004aa92012-02-08 18:05:09 -0800834 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
835 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700836 bool dex_check = (dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum());
837
838 if (image_check && dex_check) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800839 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Elliott Hughesed6d78e2011-10-25 17:35:14 -0700840 }
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700841 if (!image_check) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700842 std::string image_file(image_header.GetImageRoot(
843 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
844 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
845 << " checksum ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
846 << ") mismatch with " << image_file
847 << " (" << std::hex << image_checksum << ")--- regenerating";
848 }
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700849 if (!dex_check) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700850 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
851 << " checksum ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
852 << ") mismatch with " << dex_location
853 << " (" << std::hex << dex_location_checksum << ")--- regenerating";
854 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800855 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700856 PLOG(FATAL) << "Failed to remove obsolete .oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800857 }
jeffhao262bf462011-10-20 18:36:32 -0700858 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800859 LOG(INFO) << "Failed to open oat file from " << oat_filename << " or " << cache_location << ".";
860
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800861 // Try to generate oat file if it wasn't found or was obsolete.
862 std::string oat_cache_filename(GetArtCacheFilenameOrDie(oat_filename));
863 return FindOrCreateOatFileForDexLocation(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700864}
865
Brian Carlstromae826982011-11-09 01:33:42 -0800866const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700867 for (size_t i = 0; i < oat_files_.size(); i++) {
868 const OatFile* oat_file = oat_files_[i];
869 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800870 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700871 return oat_file;
872 }
873 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700874 return NULL;
875}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700876
Brian Carlstromae826982011-11-09 01:33:42 -0800877const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800878 MutexLock mu(dex_lock_);
879 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
880 if (oat_file != NULL) {
881 return oat_file;
882 }
883
Logan Chien0c717dd2012-03-28 18:31:07 +0800884 oat_file = OatFile::Open(oat_location, oat_location, NULL,
885 OatFile::kRelocAll);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700886 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800887 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700888 }
Brian Carlstromae826982011-11-09 01:33:42 -0800889 CHECK(oat_file != NULL) << oat_location;
jeffhaof6174e82012-01-31 16:14:17 -0800890 RegisterOatFileLocked(*oat_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700891 return oat_file;
892}
893
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700894void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800895 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700896 CHECK(!init_done_);
897
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800898 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700899 ImageSpace* space = heap->GetImageSpace();
900 OatFile* oat_file = OpenOat(space);
901 CHECK(oat_file != NULL) << "Failed to open oat file for image";
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700902 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationChecksum(), 0U);
903 CHECK(oat_file->GetOatHeader().GetImageFileLocation() == "");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700904 Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
905 ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700906
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700907 // Special case of setting up the String class early so that we can test arbitrary objects
908 // as being Strings or not
909 Class* java_lang_String = space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)
910 ->AsObjectArray<Class>()->Get(kJavaLangString);
911 String::SetClass(java_lang_String);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800912
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700913 CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
914 static_cast<uint32_t>(dex_caches->GetLength()));
915 for (int i = 0; i < dex_caches->GetLength(); i++) {
916 SirtRef<DexCache> dex_cache(dex_caches->Get(i));
917 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
918 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
919 const DexFile* dex_file = oat_dex_file->OpenDexFile();
920 if (dex_file == NULL) {
921 LOG(FATAL) << "Failed to open dex file " << dex_file_location
922 << " from within oat file " << oat_file->GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700923 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700924
925 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
926
927 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700928 }
929
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800930 HeapBitmap* heap_bitmap = heap->GetLiveBits();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700931 DCHECK(heap_bitmap != NULL);
932
Brian Carlstroma663ea52011-08-19 23:33:41 -0700933 // reinit clases_ table
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700934 heap_bitmap->Walk(InitFromImageCallback, this);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700935
936 // reinit class_roots_
Ian Rogers30fab402012-01-23 15:43:46 -0800937 Object* class_roots_object =
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700938 heap->GetImageSpace()->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots);
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700939 class_roots_ = class_roots_object->AsObjectArray<Class>();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700940
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800941 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -0700942 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
943 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800944 // String class root was set above
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700945 Field::SetClass(GetClassRoot(kJavaLangReflectField));
Elliott Hughes80609252011-09-23 17:24:51 -0700946 Method::SetClasses(GetClassRoot(kJavaLangReflectConstructor), GetClassRoot(kJavaLangReflectMethod));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700947 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
948 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
949 CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
950 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
951 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
952 IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
953 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
954 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700955 PathClassLoader::SetClass(GetClassRoot(kDalvikSystemPathClassLoader));
Ian Rogers5167c972012-02-03 10:41:20 -0800956 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700957 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700958
959 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700960
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800961 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700962}
963
Brian Carlstrom78128a62011-09-15 17:21:19 -0700964void ClassLinker::InitFromImageCallback(Object* obj, void* arg) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700965 DCHECK(obj != NULL);
966 DCHECK(arg != NULL);
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700967 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700968
Elliott Hughesdbb40792011-11-18 17:05:22 -0800969 if (obj->GetClass()->IsStringClass()) {
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700970 class_linker->intern_table_->RegisterStrong(obj->AsString());
Brian Carlstromc74255f2011-09-11 22:47:39 -0700971 return;
972 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700973 if (obj->IsClass()) {
974 // restore class to ClassLinker::classes_ table
975 Class* klass = obj->AsClass();
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800976 ClassHelper kh(klass, class_linker);
Brian Carlstrom07bb8552012-01-18 22:10:50 -0800977 Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
978 DCHECK(existing == NULL) << kh.GetDescriptor();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700979 return;
980 }
Brian Carlstroma663ea52011-08-19 23:33:41 -0700981}
982
983// Keep in sync with InitCallback. Anything we visit, we need to
984// reinit references to when reinitializing a ClassLinker from a
985// mapped image.
Elliott Hughes410c0c82011-09-01 17:58:25 -0700986void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
987 visitor(class_roots_, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700988
989 for (size_t i = 0; i < dex_caches_.size(); i++) {
Elliott Hughes410c0c82011-09-01 17:58:25 -0700990 visitor(dex_caches_[i], arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700991 }
992
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700993 {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700994 MutexLock mu(classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700995 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700996 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -0700997 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700998 }
Ian Rogers5d76c432011-10-31 21:42:49 -0700999 // Note. we deliberately ignore the class roots in the image (held in image_classes_)
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001000 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001001
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001002 visitor(array_iftable_, arg);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001003}
1004
Elliott Hughesa2155262011-11-16 16:26:58 -08001005void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
1006 MutexLock mu(classes_lock_);
1007 typedef Table::const_iterator It; // TODO: C++0x auto
1008 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
1009 if (!visitor(it->second, arg)) {
1010 return;
1011 }
1012 }
1013 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
1014 if (!visitor(it->second, arg)) {
1015 return;
1016 }
1017 }
1018}
1019
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001020ClassLinker::~ClassLinker() {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001021 String::ResetClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001022 Field::ResetClass();
Elliott Hughes80609252011-09-23 17:24:51 -07001023 Method::ResetClasses();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001024 BooleanArray::ResetArrayClass();
1025 ByteArray::ResetArrayClass();
1026 CharArray::ResetArrayClass();
1027 DoubleArray::ResetArrayClass();
1028 FloatArray::ResetArrayClass();
1029 IntArray::ResetArrayClass();
1030 LongArray::ResetArrayClass();
1031 ShortArray::ResetArrayClass();
1032 PathClassLoader::ResetClass();
Ian Rogers5167c972012-02-03 10:41:20 -08001033 Throwable::ResetClass();
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001034 StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001035 STLDeleteElements(&boot_class_path_);
1036 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001037}
1038
1039DexCache* ClassLinker::AllocDexCache(const DexFile& dex_file) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001040 SirtRef<DexCache> dex_cache(down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::LengthAsArray())));
1041 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001042 return NULL;
1043 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001044 SirtRef<String> location(intern_table_->InternStrong(dex_file.GetLocation().c_str()));
1045 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001046 return NULL;
1047 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001048 SirtRef<ObjectArray<String> > strings(AllocObjectArray<String>(dex_file.NumStringIds()));
1049 if (strings.get() == NULL) {
1050 return NULL;
1051 }
1052 SirtRef<ObjectArray<Class> > types(AllocClassArray(dex_file.NumTypeIds()));
1053 if (types.get() == NULL) {
1054 return NULL;
1055 }
1056 SirtRef<ObjectArray<Method> > methods(AllocObjectArray<Method>(dex_file.NumMethodIds()));
1057 if (methods.get() == NULL) {
1058 return NULL;
1059 }
1060 SirtRef<ObjectArray<Field> > fields(AllocObjectArray<Field>(dex_file.NumFieldIds()));
1061 if (fields.get() == NULL) {
1062 return NULL;
1063 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001064 SirtRef<ObjectArray<StaticStorageBase> > initialized_static_storage(AllocObjectArray<StaticStorageBase>(dex_file.NumTypeIds()));
1065 if (initialized_static_storage.get() == NULL) {
1066 return NULL;
1067 }
1068
1069 dex_cache->Init(location.get(),
1070 strings.get(),
1071 types.get(),
1072 methods.get(),
1073 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001074 initialized_static_storage.get());
1075 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001076}
1077
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001078InterfaceEntry* ClassLinker::AllocInterfaceEntry(Class* interface) {
1079 DCHECK(interface->IsInterface());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001080 SirtRef<ObjectArray<Object> > array(AllocObjectArray<Object>(InterfaceEntry::LengthAsArray()));
1081 SirtRef<InterfaceEntry> interface_entry(down_cast<InterfaceEntry*>(array.get()));
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001082 interface_entry->SetInterface(interface);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001083 return interface_entry.get();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001084}
1085
Brian Carlstrom4873d462011-08-21 15:23:39 -07001086Class* ClassLinker::AllocClass(Class* java_lang_Class, size_t class_size) {
1087 DCHECK_GE(class_size, sizeof(Class));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001088 Heap* heap = Runtime::Current()->GetHeap();
1089 SirtRef<Class> klass(heap->AllocObject(java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001090 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001091 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001092 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001093}
1094
Brian Carlstrom4873d462011-08-21 15:23:39 -07001095Class* ClassLinker::AllocClass(size_t class_size) {
1096 return AllocClass(GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001097}
1098
Jesse Wilson35baaab2011-08-10 16:18:03 -04001099Field* ClassLinker::AllocField() {
Brian Carlstrom1f870082011-08-23 16:02:11 -07001100 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject());
Brian Carlstroma0808032011-07-18 00:39:23 -07001101}
1102
1103Method* ClassLinker::AllocMethod() {
Brian Carlstrom1f870082011-08-23 16:02:11 -07001104 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001105}
1106
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001107ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(size_t length) {
1108 return ObjectArray<StackTraceElement>::Alloc(
1109 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1110 length);
1111}
1112
Brian Carlstromaded5f72011-10-07 17:15:04 -07001113Class* EnsureResolved(Class* klass) {
1114 DCHECK(klass != NULL);
1115 // Wait for the class if it has not already been linked.
Carl Shapirob5573532011-07-12 18:22:59 -07001116 Thread* self = Thread::Current();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001117 if (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001118 ObjectLock lock(klass);
1119 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001120 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001121 self->ThrowNewException("Ljava/lang/ClassCircularityError;",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001122 PrettyDescriptor(klass).c_str());
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001123 klass->SetStatus(Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001124 return NULL;
1125 }
1126 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001127 while (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001128 lock.Wait();
1129 }
1130 }
1131 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001132 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001133 return NULL;
1134 }
1135 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001136 CHECK(klass->IsResolved()) << PrettyClass(klass);
1137 CHECK(!self->IsExceptionPending())
1138 << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException());
1139 return klass;
1140}
1141
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001142Class* ClassLinker::FindSystemClass(const char* descriptor) {
1143 return FindClass(descriptor, NULL);
1144}
1145
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001146Class* ClassLinker::FindClass(const char* descriptor, const ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001147 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001148 Thread* self = Thread::Current();
1149 DCHECK(self != NULL);
1150 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001151 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001152 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1153 // for primitive classes that aren't backed by dex files.
1154 return FindPrimitiveClass(descriptor[0]);
1155 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001156 // Find the class in the loaded classes table.
1157 Class* klass = LookupClass(descriptor, class_loader);
1158 if (klass != NULL) {
1159 return EnsureResolved(klass);
1160 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001161 // Class is not yet loaded.
1162 if (descriptor[0] == '[') {
1163 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001164
Jesse Wilson47daf872011-11-23 11:42:45 -05001165 } else if (class_loader == NULL) {
1166 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1167 if (pair.second != NULL) {
1168 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1169 }
1170
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001171 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001172 // first try the boot class path
1173 Class* system_class = FindSystemClass(descriptor);
1174 if (system_class != NULL) {
1175 return system_class;
1176 }
1177 CHECK(self->IsExceptionPending());
1178 self->ClearException();
1179
1180 // next try the compile time class path
Brian Carlstromaded5f72011-10-07 17:15:04 -07001181 const std::vector<const DexFile*>& class_path
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001182 = Runtime::Current()->GetCompileTimeClassPath(class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001183 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001184 if (pair.second != NULL) {
1185 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001186 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001187
1188 } else {
Elliott Hughes95572412011-12-13 18:14:20 -08001189 std::string class_name_string(DescriptorToDot(descriptor));
Elliott Hughes09d4d012012-02-03 17:44:20 -08001190 ScopedThreadStateChange tsc(self, Thread::kNative);
Elliott Hughes748382f2012-01-26 18:07:38 -08001191 JNIEnv* env = self->GetJniEnv();
Jesse Wilson47daf872011-11-23 11:42:45 -05001192 ScopedLocalRef<jclass> c(env, AddLocalReference<jclass>(env, GetClassRoot(kJavaLangClassLoader)));
1193 CHECK(c.get() != NULL);
1194 // TODO: cache method?
1195 jmethodID mid = env->GetMethodID(c.get(), "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
1196 CHECK(mid != NULL);
1197 ScopedLocalRef<jobject> class_name_object(env, env->NewStringUTF(class_name_string.c_str()));
1198 if (class_name_object.get() == NULL) {
1199 return NULL;
1200 }
1201 ScopedLocalRef<jobject> class_loader_object(env, AddLocalReference<jobject>(env, class_loader));
Elliott Hughes9c750f92012-04-05 12:07:59 -07001202 CHECK(class_loader_object.get() != NULL);
Ian Rogers761bfa82012-01-11 10:14:05 -08001203 ScopedLocalRef<jobject> result(env, env->CallObjectMethod(class_loader_object.get(), mid,
1204 class_name_object.get()));
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001205 if (env->ExceptionCheck()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001206 // If the ClassLoader threw, pass that exception up.
1207 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001208 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001209 // broken loader - throw NPE to be compatible with Dalvik
1210 ThrowNullPointerException("ClassLoader.loadClass returned null for %s",
1211 class_name_string.c_str());
1212 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001213 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08001214 // success, return Class*
Ian Rogers6b0870d2011-12-15 19:38:12 -08001215 return Decode<Class*>(env, result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001216 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001217 }
1218
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001219 ThrowNoClassDefFoundError("Class %s not found", PrintableString(StringPiece(descriptor)).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001220 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001221}
1222
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001223Class* ClassLinker::DefineClass(const StringPiece& descriptor,
Brian Carlstromaded5f72011-10-07 17:15:04 -07001224 const ClassLoader* class_loader,
1225 const DexFile& dex_file,
1226 const DexFile::ClassDef& dex_class_def) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001227 SirtRef<Class> klass(NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001228 // Load the class from the dex file.
1229 if (!init_done_) {
1230 // finish up init of hand crafted class_roots_
1231 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001232 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001233 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001234 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001235 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001236 klass.reset(GetClassRoot(kJavaLangString));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001237 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001238 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001239 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001240 klass.reset(GetClassRoot(kJavaLangReflectField));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001241 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001242 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001243 } else {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001244 klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001245 }
1246 } else {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001247 klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001248 }
1249 klass->SetDexCache(FindDexCache(dex_file));
1250 LoadClass(dex_file, dex_class_def, klass, class_loader);
1251 // Check for a pending exception during load
1252 Thread* self = Thread::Current();
1253 if (self->IsExceptionPending()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001254 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001255 return NULL;
1256 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001257 ObjectLock lock(klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001258 klass->SetClinitThreadId(self->GetTid());
1259 // Add the newly loaded class to the loaded classes table.
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001260 SirtRef<Class> existing(InsertClass(descriptor, klass.get(), false));
1261 if (existing.get() != NULL) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001262 // We failed to insert because we raced with another thread.
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001263 return EnsureResolved(existing.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001264 }
1265 // Finish loading (if necessary) by finding parents
1266 CHECK(!klass->IsLoaded());
1267 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1268 // Loading failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001269 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001270 lock.NotifyAll();
1271 return NULL;
1272 }
1273 CHECK(klass->IsLoaded());
1274 // Link the class (if necessary)
1275 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001276 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001277 // Linking failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001278 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001279 lock.NotifyAll();
1280 return NULL;
1281 }
1282 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001283
1284 /*
1285 * We send CLASS_PREPARE events to the debugger from here. The
1286 * definition of "preparation" is creating the static fields for a
1287 * class and initializing them to the standard default values, but not
1288 * executing any code (that comes later, during "initialization").
1289 *
1290 * We did the static preparation in LinkClass.
1291 *
1292 * The class has been prepared and resolved but possibly not yet verified
1293 * at this point.
1294 */
1295 Dbg::PostClassPrepare(klass.get());
1296
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001297 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001298}
1299
Brian Carlstrom4873d462011-08-21 15:23:39 -07001300// Precomputes size that will be needed for Class, matching LinkStaticFields
1301size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1302 const DexFile::ClassDef& dex_class_def) {
1303 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001304 size_t num_ref = 0;
1305 size_t num_32 = 0;
1306 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001307 if (class_data != NULL) {
1308 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1309 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001310 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001311 char c = descriptor[0];
1312 if (c == 'L' || c == '[') {
1313 num_ref++;
1314 } else if (c == 'J' || c == 'D') {
1315 num_64++;
1316 } else {
1317 num_32++;
1318 }
1319 }
1320 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001321 // start with generic class data
1322 size_t size = sizeof(Class);
1323 // follow with reference fields which must be contiguous at start
1324 size += (num_ref * sizeof(uint32_t));
1325 // if there are 64-bit fields to add, make sure they are aligned
1326 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
1327 if (num_32 != 0) {
1328 // use an available 32-bit field for padding
1329 num_32--;
1330 }
1331 size += sizeof(uint32_t); // either way, we are adding a word
1332 DCHECK_EQ(size, RoundUp(size, 8));
1333 }
1334 // tack on any 64-bit fields now that alignment is assured
1335 size += (num_64 * sizeof(uint64_t));
1336 // tack on any remaining 32-bit fields
1337 size += (num_32 * sizeof(uint32_t));
1338 return size;
1339}
1340
Ian Rogers19846512012-02-24 11:42:47 -08001341const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1342 DCHECK(descriptor != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001343 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1344 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1345 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1346 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1347 uint32_t class_def_index;
1348 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1349 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1350 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1351 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1352 return oat_class;
1353}
1354
Brian Carlstromf5822582012-03-19 22:34:31 -07001355// Special case to get oat code without overwriting a trampoline.
Ian Rogers19846512012-02-24 11:42:47 -08001356const void* ClassLinker::GetOatCodeFor(const Method* method) {
Brian Carlstromf5822582012-03-19 22:34:31 -07001357 CHECK(Runtime::Current()->IsCompiler() || method->GetDeclaringClass()->IsInitializing());
Ian Rogers19846512012-02-24 11:42:47 -08001358 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001359 // method for direct methods (or virtual methods made direct).
1360 Class* declaring_class = method->GetDeclaringClass();
1361 size_t oat_method_index;
1362 if (method->IsStatic() || method->IsDirect()) {
1363 // Simple case where the oat method index was stashed at load time.
1364 oat_method_index = method->GetMethodIndex();
1365 } else {
1366 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1367 // by search for its position in the declared virtual methods.
1368 oat_method_index = declaring_class->NumDirectMethods();
1369 size_t end = declaring_class->NumVirtualMethods();
1370 bool found = false;
1371 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001372 if (declaring_class->GetVirtualMethod(i) == method) {
1373 found = true;
1374 break;
1375 }
Ian Rogersf320b632012-03-13 18:47:47 -07001376 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001377 }
1378 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1379 }
1380 ClassHelper kh(declaring_class);
Ian Rogers19846512012-02-24 11:42:47 -08001381 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001382 CHECK(oat_class.get() != NULL);
Ian Rogersfb6adba2012-03-04 21:51:51 -08001383 return oat_class->GetOatMethod(oat_method_index).GetCode();
Ian Rogers19846512012-02-24 11:42:47 -08001384}
1385
1386void ClassLinker::FixupStaticTrampolines(Class* klass) {
1387 ClassHelper kh(klass);
1388 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1389 CHECK(dex_class_def != NULL);
1390 const DexFile& dex_file = kh.GetDexFile();
1391 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1392 if (class_data == NULL) {
1393 return; // no fields or methods - for example a marker interface
1394 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001395 if (!Runtime::Current()->IsStarted() || Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001396 // OAT file unavailable
1397 return;
1398 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001399 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1400 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001401 ClassDataItemIterator it(dex_file, class_data);
1402 // Skip fields
1403 while (it.HasNextStaticField()) {
1404 it.Next();
1405 }
1406 while (it.HasNextInstanceField()) {
1407 it.Next();
1408 }
1409 size_t method_index = 0;
1410 // Link the code of methods skipped by LinkCode
1411 const void* trampoline = Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData();
1412 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1413 Method* method = klass->GetDirectMethod(i);
jeffhaob5e81852012-03-12 11:15:45 -07001414 if (Runtime::Current()->IsMethodTracingActive()) {
1415 Trace* tracer = Runtime::Current()->GetTracer();
1416 if (tracer->GetSavedCodeFromMap(method) == trampoline) {
1417 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1418 tracer->ResetSavedCode(method);
1419 method->SetCode(code);
1420 tracer->SaveAndUpdateCode(method);
1421 }
1422 } else if (method->GetCode() == trampoline) {
Ian Rogers19846512012-02-24 11:42:47 -08001423 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1424 CHECK(code != NULL);
1425 method->SetCode(code);
1426 }
1427 method_index++;
1428 }
1429}
1430
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001431void LinkCode(SirtRef<Method>& method, const OatFile::OatClass* oat_class, uint32_t method_index) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001432 // Every kind of method should at least get an invoke stub from the oat_method.
1433 // non-abstract methods also get their code pointers.
1434 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstromae826982011-11-09 01:33:42 -08001435 oat_method.LinkMethodPointers(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001436
Ian Rogers19846512012-02-24 11:42:47 -08001437 Runtime* runtime = Runtime::Current();
Brian Carlstrom92827a52011-10-10 15:50:01 -07001438 if (method->IsAbstract()) {
Ian Rogers19846512012-02-24 11:42:47 -08001439 method->SetCode(runtime->GetAbstractMethodErrorStubArray()->GetData());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001440 return;
1441 }
Ian Rogers19846512012-02-24 11:42:47 -08001442
1443 if (method->IsStatic() && !method->IsConstructor()) {
1444 // For static methods excluding the class initializer, install the trampoline
1445 method->SetCode(runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData());
Ian Rogers0d6de042012-02-29 08:50:26 -08001446 }
1447 if (method->IsNative()) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001448 // unregistering restores the dlsym lookup stub
Ian Rogers19846512012-02-24 11:42:47 -08001449 method->UnregisterNative(Thread::Current());
jeffhao26c0a1a2012-01-17 16:28:33 -08001450 }
1451
1452 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhao26c0a1a2012-01-17 16:28:33 -08001453 Trace* tracer = Runtime::Current()->GetTracer();
jeffhaob5e81852012-03-12 11:15:45 -07001454 tracer->SaveAndUpdateCode(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001455 }
1456}
1457
Brian Carlstromf615a612011-07-23 12:50:34 -07001458void ClassLinker::LoadClass(const DexFile& dex_file,
1459 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001460 SirtRef<Class>& klass,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001461 const ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001462 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001463 CHECK(klass->GetDexCache() != NULL);
1464 CHECK_EQ(Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001465 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001466 CHECK(descriptor != NULL);
1467
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001468 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001469 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001470 // Make sure that none of our runtime-only flags are set.
1471 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001472 klass->SetAccessFlags(access_flags);
1473 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001474 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001475 klass->SetStatus(Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001476
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001477 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001478
Ian Rogers0571d352011-11-03 19:51:38 -07001479 // Load fields fields.
1480 const byte* class_data = dex_file.GetClassData(dex_class_def);
1481 if (class_data == NULL) {
1482 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001483 }
Ian Rogers0571d352011-11-03 19:51:38 -07001484 ClassDataItemIterator it(dex_file, class_data);
1485 if (it.NumStaticFields() != 0) {
1486 klass->SetSFields(AllocObjectArray<Field>(it.NumStaticFields()));
1487 }
1488 if (it.NumInstanceFields() != 0) {
1489 klass->SetIFields(AllocObjectArray<Field>(it.NumInstanceFields()));
1490 }
1491 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
1492 SirtRef<Field> sfield(AllocField());
1493 klass->SetStaticField(i, sfield.get());
1494 LoadField(dex_file, it, klass, sfield);
1495 }
1496 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
1497 SirtRef<Field> ifield(AllocField());
1498 klass->SetInstanceField(i, ifield.get());
1499 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001500 }
1501
Brian Carlstromf5822582012-03-19 22:34:31 -07001502 UniquePtr<const OatFile::OatClass> oat_class;
1503 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1504 oat_class.reset(GetOatClass(dex_file, descriptor));
1505 }
Ian Rogers19846512012-02-24 11:42:47 -08001506
Ian Rogers0571d352011-11-03 19:51:38 -07001507 // Load methods.
1508 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001509 // TODO: append direct methods to class object
Ian Rogers0571d352011-11-03 19:51:38 -07001510 klass->SetDirectMethods(AllocObjectArray<Method>(it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001511 }
Ian Rogers0571d352011-11-03 19:51:38 -07001512 if (it.NumVirtualMethods() != 0) {
1513 // TODO: append direct methods to class object
1514 klass->SetVirtualMethods(AllocObjectArray<Method>(it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001515 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001516 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001517 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1518 SirtRef<Method> method(AllocMethod());
1519 klass->SetDirectMethod(i, method.get());
1520 LoadMethod(dex_file, it, klass, method);
1521 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001522 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001523 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001524 method->SetMethodIndex(class_def_method_index);
1525 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001526 }
1527 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
1528 SirtRef<Method> method(AllocMethod());
1529 klass->SetVirtualMethod(i, method.get());
1530 LoadMethod(dex_file, it, klass, method);
Ian Rogersfb6adba2012-03-04 21:51:51 -08001531 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001532 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001533 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001534 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001535 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001536 }
1537 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001538}
1539
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001540void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Ian Rogers0571d352011-11-03 19:51:38 -07001541 SirtRef<Class>& klass, SirtRef<Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001542 uint32_t field_idx = it.GetMemberIndex();
1543 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001544 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001545 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001546}
1547
Ian Rogers0571d352011-11-03 19:51:38 -07001548void ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
1549 SirtRef<Class>& klass, SirtRef<Method>& dst) {
Ian Rogers19846512012-02-24 11:42:47 -08001550 uint32_t dex_method_idx = it.GetMemberIndex();
1551 dst->SetDexMethodIndex(dex_method_idx);
1552 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001553 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001554
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001555
1556 StringPiece method_name(dex_file.GetMethodName(method_id));
1557 if (method_name == "<init>") {
Elliott Hughes80609252011-09-23 17:24:51 -07001558 dst->SetClass(GetClassRoot(kJavaLangReflectConstructor));
1559 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001560
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001561 if (method_name == "finalize") {
1562 // Create the prototype for a signature of "()V"
1563 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1564 if (void_string_id != NULL) {
1565 const DexFile::TypeId* void_type_id =
1566 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1567 if (void_type_id != NULL) {
1568 std::vector<uint16_t> no_args;
1569 const DexFile::ProtoId* finalizer_proto =
1570 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1571 if (finalizer_proto != NULL) {
1572 // We have the prototype in the dex file
1573 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1574 klass->SetFinalizable();
1575 } else {
1576 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1577 // The Enum class declares a "final" finalize() method to prevent subclasses from
1578 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1579 // subclasses, so we exclude it here.
1580 // We also want to avoid setting the flag on Object, where we know that finalize() is
1581 // empty.
1582 if (klass_descriptor != "Ljava/lang/Object;" &&
1583 klass_descriptor != "Ljava/lang/Enum;") {
1584 klass->SetFinalizable();
1585 }
1586 }
1587 }
1588 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001589 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001590 }
Ian Rogers0571d352011-11-03 19:51:38 -07001591 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001592 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001593
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001594 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001595 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001596 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001597 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001598}
1599
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001600void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001601 SirtRef<DexCache> dex_cache(AllocDexCache(dex_file));
1602 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001603}
1604
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001605void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
1606 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001607 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001608 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001609}
1610
Brian Carlstromaded5f72011-10-07 17:15:04 -07001611bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001612 dex_lock_.AssertHeld();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001613 for (size_t i = 0; i != dex_files_.size(); ++i) {
1614 if (dex_files_[i] == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001615 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001616 }
1617 }
1618 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001619}
1620
Brian Carlstromaded5f72011-10-07 17:15:04 -07001621bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001622 MutexLock mu(dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001623 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001624}
1625
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001626void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001627 dex_lock_.AssertHeld();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001628 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001629 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001630 dex_files_.push_back(&dex_file);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001631 dex_caches_.push_back(dex_cache.get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001632}
1633
Brian Carlstromaded5f72011-10-07 17:15:04 -07001634void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001635 {
1636 MutexLock mu(dex_lock_);
1637 if (IsDexFileRegisteredLocked(dex_file)) {
1638 return;
1639 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001640 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001641 // Don't alloc while holding the lock, since allocation may need to
1642 // suspend all threads and another thread may need the dex_lock_ to
1643 // get to a suspend point.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001644 SirtRef<DexCache> dex_cache(AllocDexCache(dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001645 {
1646 MutexLock mu(dex_lock_);
1647 if (IsDexFileRegisteredLocked(dex_file)) {
1648 return;
1649 }
1650 RegisterDexFileLocked(dex_file, dex_cache);
1651 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001652}
1653
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001654void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001655 MutexLock mu(dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001656 RegisterDexFileLocked(dex_file, dex_cache);
1657}
1658
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001659const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
Ian Rogers466bb252011-10-14 03:29:56 -07001660 CHECK(dex_cache != NULL);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001661 MutexLock mu(dex_lock_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001662 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1663 if (dex_caches_[i] == dex_cache) {
Ian Rogers19846512012-02-24 11:42:47 -08001664 return *dex_files_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001665 }
1666 }
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001667 CHECK(false) << "Failed to find DexFile for DexCache " << dex_cache->GetLocation()->ToModifiedUtf8();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001668 return *dex_files_[-1];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001669}
1670
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001671DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001672 MutexLock mu(dex_lock_);
Brian Carlstromf615a612011-07-23 12:50:34 -07001673 for (size_t i = 0; i != dex_files_.size(); ++i) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001674 if (dex_files_[i] == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001675 return dex_caches_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001676 }
1677 }
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001678 CHECK(false) << "Failed to find DexCache for DexFile " << dex_file.GetLocation();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001679 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001680}
1681
Ian Rogers19846512012-02-24 11:42:47 -08001682void ClassLinker::FixupDexCaches(Method* resolution_method) const {
1683 MutexLock mu(dex_lock_);
1684 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1685 dex_caches_[i]->Fixup(resolution_method);
1686 }
1687}
1688
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001689Class* ClassLinker::InitializePrimitiveClass(Class* primitive_class,
1690 const char* descriptor,
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001691 Primitive::Type type) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001692 // TODO: deduce one argument from the other
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001693 CHECK(primitive_class != NULL);
1694 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001695 primitive_class->SetPrimitiveType(type);
1696 primitive_class->SetStatus(Class::kStatusInitialized);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001697 Class* existing = InsertClass(descriptor, primitive_class, false);
1698 CHECK(existing == NULL) << "InitPrimitiveClass(" << descriptor << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001699 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001700}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001701
Brian Carlstrombe977852011-07-19 14:54:54 -07001702// Create an array class (i.e. the class object for the array, not the
1703// array itself). "descriptor" looks like "[C" or "[[[[B" or
1704// "[Ljava/lang/String;".
1705//
1706// If "descriptor" refers to an array of primitives, look up the
1707// primitive type's internally-generated class object.
1708//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001709// "class_loader" is the class loader of the class that's referring to
1710// us. It's used to ensure that we're looking for the element type in
1711// the right context. It does NOT become the class loader for the
1712// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001713//
1714// Returns NULL with an exception raised on failure.
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001715Class* ClassLinker::CreateArrayClass(const std::string& descriptor, const ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001716 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001717
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001718 // Identify the underlying component type
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001719 Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001720 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001721 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001722 return NULL;
1723 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001724
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001725 // See if the component type is already loaded. Array classes are
1726 // always associated with the class loader of their underlying
1727 // element type -- an array of Strings goes with the loader for
1728 // java/lang/String -- so we need to look for it there. (The
1729 // caller should have checked for the existence of the class
1730 // before calling here, but they did so with *their* class loader,
1731 // not the component type's loader.)
1732 //
1733 // If we find it, the caller adds "loader" to the class' initiating
1734 // loader list, which should prevent us from going through this again.
1735 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001736 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001737 // are the same, because our caller (FindClass) just did the
1738 // lookup. (Even if we get this wrong we still have correct behavior,
1739 // because we effectively do this lookup again when we add the new
1740 // class to the hash table --- necessary because of possible races with
1741 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001742 if (class_loader != component_type->GetClassLoader()) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001743 Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001744 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001745 return new_class;
1746 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001747 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001748
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001749 // Fill out the fields in the Class.
1750 //
1751 // It is possible to execute some methods against arrays, because
1752 // all arrays are subclasses of java_lang_Object_, so we need to set
1753 // up a vtable. We can just point at the one in java_lang_Object_.
1754 //
1755 // Array classes are simple enough that we don't need to do a full
1756 // link step.
1757
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001758 SirtRef<Class> new_class(NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001759 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001760 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07001761 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001762 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07001763 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001764 new_class.reset(GetClassRoot(kObjectArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001765 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001766 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001767 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001768 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001769 }
1770 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001771 if (new_class.get() == NULL) {
1772 new_class.reset(AllocClass(sizeof(Class)));
1773 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001774 return NULL;
1775 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001776 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001777 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001778 DCHECK(new_class->GetComponentType() != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001779 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001780 new_class->SetSuperClass(java_lang_Object);
1781 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001782 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001783 new_class->SetClassLoader(component_type->GetClassLoader());
1784 new_class->SetStatus(Class::kStatusInitialized);
1785 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001786 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001787
1788
1789 // All arrays have java/lang/Cloneable and java/io/Serializable as
1790 // interfaces. We need to set that up here, so that stuff like
1791 // "instanceof" works right.
1792 //
1793 // Note: The GC could run during the call to FindSystemClass,
1794 // so we need to make sure the class object is GC-valid while we're in
1795 // there. Do this by clearing the interface list so the GC will just
1796 // think that the entries are null.
1797
1798
1799 // Use the single, global copies of "interfaces" and "iftable"
1800 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07001801 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001802 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001803
1804 // Inherit access flags from the component type. Arrays can't be
1805 // used as a superclass or interface, so we want to add "final"
1806 // and remove "interface".
1807 //
1808 // Don't inherit any non-standard flags (e.g., kAccFinal)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001809 // from component_type. We assume that the array class does not
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001810 // override finalize().
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001811 new_class->SetAccessFlags(((new_class->GetComponentType()->GetAccessFlags() &
1812 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001813
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001814 Class* existing = InsertClass(descriptor, new_class.get(), false);
1815 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001816 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001817 }
1818 // Another thread must have loaded the class after we
1819 // started but before we finished. Abandon what we've
1820 // done.
1821 //
1822 // (Yes, this happens.)
1823
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001824 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001825}
1826
1827Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001828 switch (Primitive::GetType(type)) {
1829 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001830 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001831 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001832 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001833 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001834 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001835 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001836 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001837 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001838 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001839 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001840 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001841 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001842 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001843 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001844 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001845 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001846 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001847 case Primitive::kPrimNot:
1848 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07001849 }
Elliott Hughesbd935992011-08-22 11:59:34 -07001850 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001851 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07001852 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001853}
1854
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001855Class* ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass, bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001856 if (VLOG_IS_ON(class_linker)) {
Brian Carlstromae826982011-11-09 01:33:42 -08001857 DexCache* dex_cache = klass->GetDexCache();
1858 std::string source;
1859 if (dex_cache != NULL) {
1860 source += " from ";
1861 source += dex_cache->GetLocation()->ToModifiedUtf8();
1862 }
1863 LOG(INFO) << "Loaded class " << descriptor << source;
1864 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001865 size_t hash = StringPieceHash()(descriptor);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001866 MutexLock mu(classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001867 Table& classes = image_class ? image_classes_ : classes_;
1868 Class* existing = LookupClass(descriptor.data(), klass->GetClassLoader(), hash, classes);
1869#ifndef NDEBUG
1870 // Check we don't have the class in the other table in error
1871 Table& other_classes = image_class ? classes_ : image_classes_;
1872 CHECK(LookupClass(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
1873#endif
1874 if (existing != NULL) {
1875 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07001876 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001877 classes.insert(std::make_pair(hash, klass));
1878 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001879}
1880
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001881bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
1882 size_t hash = Hash(descriptor);
Brian Carlstromae826982011-11-09 01:33:42 -08001883 MutexLock mu(classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08001884 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08001885 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001886 ClassHelper kh;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001887 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08001888 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001889 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001890 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08001891 classes_.erase(it);
1892 return true;
1893 }
1894 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001895 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08001896 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001897 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001898 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08001899 image_classes_.erase(it);
1900 return true;
1901 }
1902 }
1903 return false;
1904}
1905
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001906Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
1907 size_t hash = Hash(descriptor);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001908 MutexLock mu(classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07001909 // TODO: determine if its better to search classes_ or image_classes_ first
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001910 Class* klass = LookupClass(descriptor, class_loader, hash, classes_);
1911 if (klass != NULL) {
1912 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001913 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001914 return LookupClass(descriptor, class_loader, hash, image_classes_);
1915}
1916
1917Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader,
1918 size_t hash, const Table& classes) {
1919 ClassHelper kh(NULL, this);
1920 typedef Table::const_iterator It; // TODO: C++0x auto
1921 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers5d76c432011-10-31 21:42:49 -07001922 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001923 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001924 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001925#ifndef NDEBUG
1926 for (++it; it != end && it->first == hash; ++it) {
Ian Rogersd85016c2012-02-03 18:27:34 -08001927 Class* klass2 = it->second;
1928 kh.ChangeClass(klass2);
1929 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001930 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08001931 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001932 }
1933#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07001934 return klass;
1935 }
1936 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001937 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001938}
1939
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001940void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001941 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001942 size_t hash = Hash(descriptor);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001943 MutexLock mu(classes_lock_);
1944 typedef Table::const_iterator It; // TODO: C++0x auto
1945 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001946 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001947 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001948 Class* klass = it->second;
1949 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001950 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001951 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001952 }
1953 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001954 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001955 Class* klass = it->second;
1956 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001957 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001958 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001959 }
1960 }
1961}
1962
TDYa1273db52852012-04-01 15:11:43 -07001963#if !defined(NDEBUG) && !defined(ART_USE_LLVM_COMPILER)
Ian Rogersc20a83e2012-01-18 18:15:32 -08001964static void CheckMethodsHaveGcMaps(Class* klass) {
1965 if (!Runtime::Current()->IsStarted()) {
1966 return;
1967 }
1968 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
1969 Method* method = klass->GetDirectMethod(i);
1970 if (!method->IsNative() && !method->IsAbstract()) {
1971 CHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
1972 }
1973 }
1974 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
1975 Method* method = klass->GetVirtualMethod(i);
1976 if (!method->IsNative() && !method->IsAbstract()) {
1977 CHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
1978 }
1979 }
1980}
1981#else
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001982static void CheckMethodsHaveGcMaps(Class*) {
Ian Rogersc20a83e2012-01-18 18:15:32 -08001983}
1984#endif
1985
jeffhao98eacac2011-09-14 16:11:53 -07001986void ClassLinker::VerifyClass(Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08001987 // TODO: assert that the monitor on the Class is held
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001988 ObjectLock lock(klass);
1989
jeffhao98eacac2011-09-14 16:11:53 -07001990 if (klass->IsVerified()) {
1991 return;
1992 }
1993
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08001994 // The class might already be erroneous if we attempted to verify a subclass
1995 if (klass->IsErroneous()) {
1996 ThrowEarlierClassFailure(klass);
1997 return;
1998 }
1999
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002000 CHECK_EQ(klass->GetStatus(), Class::kStatusResolved) << PrettyClass(klass);
jeffhao98eacac2011-09-14 16:11:53 -07002001 klass->SetStatus(Class::kStatusVerifying);
jeffhao98eacac2011-09-14 16:11:53 -07002002
Ian Rogers1c5eb702012-02-01 09:18:34 -08002003 // Verify super class
2004 Class* super = klass->GetSuperClass();
2005 std::string error_msg;
2006 if (super != NULL) {
2007 // Acquire lock to prevent races on verifying the super class
2008 ObjectLock lock(super);
2009
2010 if (!super->IsVerified() && !super->IsErroneous()) {
2011 Runtime::Current()->GetClassLinker()->VerifyClass(super);
2012 }
2013 if (!super->IsVerified()) {
2014 error_msg = "Rejecting class ";
2015 error_msg += PrettyDescriptor(klass);
2016 error_msg += " that attempts to sub-class erroneous class ";
2017 error_msg += PrettyDescriptor(super);
2018 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
2019 Thread* self = Thread::Current();
2020 SirtRef<Throwable> cause(self->GetException());
2021 if (cause.get() != NULL) {
2022 self->ClearException();
2023 }
2024 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2025 if (cause.get() != NULL) {
2026 self->GetException()->SetCause(cause.get());
2027 }
2028 CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
2029 klass->SetStatus(Class::kStatusError);
2030 return;
2031 }
2032 }
2033
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002034 // Try to use verification information from the oat file, otherwise do runtime verification.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002035 const DexFile& dex_file = FindDexFile(klass->GetDexCache());
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002036 Class::Status oat_file_class_status(Class::kStatusNotReady);
2037 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
2038 bool verified = preverified || verifier::DexVerifier::VerifyClass(klass, error_msg);
2039 if (verified) {
2040 if (!preverified && oat_file_class_status == Class::kStatusError) {
2041 LOG(FATAL) << "Verification failed hard on class " << PrettyDescriptor(klass)
2042 << " at compile time, but succeeded at runtime! The verifier must be broken.";
2043 }
Ian Rogersc4762272012-02-01 15:55:55 -08002044 DCHECK(!Thread::Current()->IsExceptionPending());
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002045 // Make sure all classes referenced by catch blocks are resolved
2046 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002047 klass->SetStatus(Class::kStatusVerified);
Ian Rogersc20a83e2012-01-18 18:15:32 -08002048 // Sanity check that a verified class has GC maps on all methods
2049 CheckMethodsHaveGcMaps(klass);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002050 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002051 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002052 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2053 << " because: " << error_msg;
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002054 Thread* self = Thread::Current();
Ian Rogersc4762272012-02-01 15:55:55 -08002055 CHECK(!self->IsExceptionPending());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002056 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2057 CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002058 klass->SetStatus(Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002059 }
jeffhao98eacac2011-09-14 16:11:53 -07002060}
2061
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002062bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
2063 Class::Status& oat_file_class_status) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002064 if (!Runtime::Current()->IsStarted()) {
2065 return false;
2066 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002067 if (Runtime::Current()->UseCompileTimeClassPath()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002068 return false;
2069 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002070 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2071 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002072 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002073 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002074 const char* descriptor = ClassHelper(klass).GetDescriptor();
2075 uint32_t class_def_index;
2076 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002077 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002078 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002079 CHECK(oat_class.get() != NULL)
2080 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002081 oat_file_class_status = oat_class->GetStatus();
2082 if (oat_file_class_status == Class::kStatusVerified || oat_file_class_status == Class::kStatusInitialized) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002083 return true;
2084 }
jeffhao1ac29442012-03-26 11:37:32 -07002085 if (oat_file_class_status == Class::kStatusResolved) {
2086 // Compile time verification failed with a soft error. Compile time verification can fail
2087 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002088 // class ... {
2089 // Foo x;
2090 // .... () {
2091 // if (...) {
2092 // v1 gets assigned a type of resolved class Foo
2093 // } else {
2094 // v1 gets assigned a type of unresolved class Bar
2095 // }
2096 // iput x = v1
2097 // } }
2098 // when we merge v1 following the if-the-else it results in Conflict
2099 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2100 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2101 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2102 // at compile time).
2103 return false;
2104 }
jeffhao1ac29442012-03-26 11:37:32 -07002105 if (oat_file_class_status == Class::kStatusError) {
2106 // Compile time verification failed with a hard error. This is caused by invalid instructions
2107 // in the class. These errors are unrecoverable.
2108 return false;
2109 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002110 if (oat_file_class_status == Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002111 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2112 // not loading the class.
2113 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2114 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002115 return false;
2116 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002117 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002118 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2119
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002120 return false;
2121}
2122
2123void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
2124 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2125 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2126 }
2127 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2128 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2129 }
2130}
2131
2132void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* method) {
2133 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2134 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2135 if (code_item == NULL) {
2136 return; // native or abstract method
2137 }
2138 if (code_item->tries_size_ == 0) {
2139 return; // nothing to process
2140 }
2141 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2142 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2143 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2144 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2145 CatchHandlerIterator iterator(handlers_ptr);
2146 for (; iterator.HasNext(); iterator.Next()) {
2147 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2148 // unresolved exception types will be ignored by exception delivery
2149 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
2150 Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
2151 if (exception_type == NULL) {
2152 DCHECK(Thread::Current()->IsExceptionPending());
2153 Thread::Current()->ClearException();
2154 }
2155 }
2156 }
2157 handlers_ptr = iterator.EndDataPointer();
2158 }
2159}
2160
Ian Rogersc2b44472011-12-14 21:17:17 -08002161static void CheckProxyConstructor(Method* constructor);
2162static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype);
2163
Jesse Wilson95caa792011-10-12 18:14:17 -04002164Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002165 ClassLoader* loader, ObjectArray<Method>* methods,
2166 ObjectArray<ObjectArray<Class> >* throws) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002167 SirtRef<Class> klass(AllocClass(GetClassRoot(kJavaLangClass), sizeof(SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002168 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002169 DCHECK(klass->GetClass() != NULL);
Jesse Wilson95caa792011-10-12 18:14:17 -04002170 klass->SetObjectSize(sizeof(Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002171 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002172 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002173 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002174 klass->SetName(name);
Ian Rogers466bb252011-10-14 03:29:56 -07002175 Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002176 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002177
2178 klass->SetStatus(Class::kStatusIdx);
2179
2180 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2181
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002182 // Instance fields are inherited, but we add a couple of static fields...
2183 klass->SetSFields(AllocObjectArray<Field>(2));
2184 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2185 // our proxy, so Class.getInterfaces doesn't return the flattened set.
2186 SirtRef<Field> interfaces_sfield(AllocField());
2187 klass->SetStaticField(0, interfaces_sfield.get());
2188 interfaces_sfield->SetDexFieldIndex(0);
2189 interfaces_sfield->SetDeclaringClass(klass.get());
2190 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2191 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
2192 SirtRef<Field> throws_sfield(AllocField());
2193 klass->SetStaticField(1, throws_sfield.get());
2194 throws_sfield->SetDexFieldIndex(1);
2195 throws_sfield->SetDeclaringClass(klass.get());
2196 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002197
Ian Rogers466bb252011-10-14 03:29:56 -07002198 // Proxies have 1 direct method, the constructor
Jesse Wilson95caa792011-10-12 18:14:17 -04002199 klass->SetDirectMethods(AllocObjectArray<Method>(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002200 klass->SetDirectMethod(0, CreateProxyConstructor(klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002201
Ian Rogers466bb252011-10-14 03:29:56 -07002202 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002203 size_t num_virtual_methods = methods->GetLength();
2204 klass->SetVirtualMethods(AllocObjectArray<Method>(num_virtual_methods));
2205 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002206 SirtRef<Method> prototype(methods->Get(i));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002207 klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002208 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002209
2210 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
2211 klass->SetStatus(Class::kStatusLoaded); // Class is now effectively in the loaded state
2212 DCHECK(!Thread::Current()->IsExceptionPending());
2213
2214 // Link the fields and virtual methods, creating vtable and iftables
2215 if (!LinkClass(klass, interfaces)) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002216 klass->SetStatus(Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002217 return NULL;
2218 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002219 interfaces_sfield->SetObject(NULL, interfaces);
2220 throws_sfield->SetObject(NULL, throws);
Ian Rogersc2b44472011-12-14 21:17:17 -08002221 klass->SetStatus(Class::kStatusInitialized);
2222
2223 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002224 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002225 CHECK(klass->GetIFields() == NULL);
2226 CheckProxyConstructor(klass->GetDirectMethod(0));
2227 for (size_t i = 0; i < num_virtual_methods; ++i) {
2228 SirtRef<Method> prototype(methods->Get(i));
2229 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2230 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002231
2232 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2233 name->ToModifiedUtf8().c_str()));
2234 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2235
2236 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2237 name->ToModifiedUtf8().c_str()));
2238 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002239
2240 SynthesizedProxyClass* synth_proxy_class = down_cast<SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002241 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002242 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2243 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002244 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002245}
2246
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002247std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
2248 DCHECK(proxy_class->IsProxyClass());
2249 String* name = proxy_class->GetName();
2250 DCHECK(name != NULL);
2251 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2252}
2253
Ian Rogers16f93672012-02-14 12:29:06 -08002254Method* ClassLinker::FindMethodForProxy(const Class* proxy_class, const Method* proxy_method) {
2255 DCHECK(proxy_class->IsProxyClass());
2256 DCHECK(proxy_method->IsProxyMethod());
2257 // Locate the dex cache of the original interface/Object
2258 DexCache* dex_cache = NULL;
2259 {
2260 ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
2261 MutexLock mu(dex_lock_);
2262 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2263 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2264 dex_cache = dex_caches_[i];
2265 break;
2266 }
2267 }
2268 }
2269 CHECK(dex_cache != NULL);
2270 uint32_t method_idx = proxy_method->GetDexMethodIndex();
2271 Method* resolved_method = dex_cache->GetResolvedMethod(method_idx);
2272 CHECK(resolved_method != NULL);
2273 return resolved_method;
2274}
2275
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002276
2277Method* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002278 // Create constructor for Proxy that must initialize h
Ian Rogers466bb252011-10-14 03:29:56 -07002279 ObjectArray<Method>* proxy_direct_methods = proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002280 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Ian Rogers466bb252011-10-14 03:29:56 -07002281 Method* proxy_constructor = proxy_direct_methods->Get(2);
2282 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2283 // code_ too)
2284 Method* constructor = down_cast<Method*>(proxy_constructor->Clone());
2285 // Make this constructor public and fix the class to be our Proxy version
2286 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002287 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002288 return constructor;
2289}
2290
2291static void CheckProxyConstructor(Method* constructor) {
Ian Rogers466bb252011-10-14 03:29:56 -07002292 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002293 MethodHelper mh(constructor);
2294 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002295 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002296 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002297}
2298
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002299Method* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype) {
2300 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2301 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002302 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2303 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002304 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002305 // as necessary
2306 Method* method = down_cast<Method*>(prototype->Clone());
2307
2308 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2309 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002310 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002311 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002312
Ian Rogers466bb252011-10-14 03:29:56 -07002313 // At runtime the method looks like a reference and argument saving method, clone the code
2314 // related parameters from this method.
2315 Method* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
2316 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2317 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2318 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
2319 method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
Ian Rogers16f93672012-02-14 12:29:06 -08002320
Ian Rogersc2b44472011-12-14 21:17:17 -08002321 return method;
2322}
Jesse Wilson95caa792011-10-12 18:14:17 -04002323
Ian Rogersc2b44472011-12-14 21:17:17 -08002324static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype) {
Ian Rogers466bb252011-10-14 03:29:56 -07002325 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002326 CHECK(!prototype->IsFinal());
2327 CHECK(method->IsFinal());
2328 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002329
2330 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2331 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2332 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2333 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2334 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2335 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2336 method->GetDexCacheInitializedStaticStorage());
2337 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2338
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002339 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002340 MethodHelper mh2(prototype.get());
2341 CHECK_STREQ(mh.GetName(), mh2.GetName());
2342 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002343 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002344 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002345}
2346
Ian Rogers0045a292012-03-31 21:08:41 -07002347bool ClassLinker::InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002348 CHECK(klass->IsResolved() || klass->IsErroneous())
2349 << PrettyClass(klass) << " is " << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002350
Carl Shapirob5573532011-07-12 18:22:59 -07002351 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002352
Brian Carlstrom25c33252011-09-18 15:58:35 -07002353 Method* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002354 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002355 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002356 ObjectLock lock(klass);
2357
Brian Carlstromd1422f82011-09-28 11:37:09 -07002358 if (klass->GetStatus() == Class::kStatusInitialized) {
2359 return true;
2360 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002361
Brian Carlstromd1422f82011-09-28 11:37:09 -07002362 if (klass->IsErroneous()) {
2363 ThrowEarlierClassFailure(klass);
2364 return false;
2365 }
2366
2367 if (klass->GetStatus() == Class::kStatusResolved) {
jeffhao98eacac2011-09-14 16:11:53 -07002368 VerifyClass(klass);
2369 if (klass->GetStatus() != Class::kStatusVerified) {
Ian Rogers595799e2012-01-11 17:32:51 -08002370 CHECK(self->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002371 return false;
2372 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002373 }
2374
Brian Carlstrom25c33252011-09-18 15:58:35 -07002375 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2376 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002377 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002378 // don't bother going to kStatusInitializing. We return false so that
2379 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002380 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2381 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002382 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002383 }
2384
Brian Carlstromd1422f82011-09-28 11:37:09 -07002385 // If the class is kStatusInitializing, either this thread is
2386 // initializing higher up the stack or another thread has beat us
2387 // to initializing and we need to wait. Either way, this
2388 // invocation of InitializeClass will not be responsible for
2389 // running <clinit> and will return.
2390 if (klass->GetStatus() == Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002391 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002392 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002393 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002394 return true;
2395 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002396 // No. That's fine. Wait for another thread to finish initializing.
2397 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002398 }
2399
2400 if (!ValidateSuperClassDescriptors(klass)) {
2401 klass->SetStatus(Class::kStatusError);
2402 return false;
2403 }
2404
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002405 DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002406
Elliott Hughesdcc24742011-09-07 14:02:44 -07002407 klass->SetClinitThreadId(self->GetTid());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002408 klass->SetStatus(Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002409 }
2410
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002411 uint64_t t0 = NanoTime();
2412
Ian Rogers0045a292012-03-31 21:08:41 -07002413 if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002414 // Super class initialization failed, this can be because we can't run
2415 // super-class class initializers in which case we'll be verified.
2416 // Otherwise this class is erroneous.
2417 if (!can_run_clinit) {
2418 CHECK(klass->IsVerified());
2419 } else {
2420 CHECK(klass->IsErroneous());
2421 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002422 return false;
2423 }
2424
Ian Rogers0045a292012-03-31 21:08:41 -07002425 bool has_static_field_initializers = InitializeStaticFields(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002426
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002427 if (clinit != NULL) {
Elliott Hughesf5ecf062011-09-06 17:37:59 -07002428 clinit->Invoke(self, NULL, NULL, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002429 }
2430
Ian Rogers19846512012-02-24 11:42:47 -08002431 FixupStaticTrampolines(klass);
2432
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002433 uint64_t t1 = NanoTime();
2434
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002435 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002436 {
2437 ObjectLock lock(klass);
2438
2439 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002440 WrapExceptionInInitializer();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002441 klass->SetStatus(Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002442 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002443 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002444 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2445 RuntimeStats* thread_stats = self->GetStats();
2446 ++global_stats->class_init_count;
2447 ++thread_stats->class_init_count;
2448 global_stats->class_init_time_ns += (t1 - t0);
2449 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogers0045a292012-03-31 21:08:41 -07002450 // Set the class as initialized except if we can't initialize static fields and static field
2451 // initialization is necessary.
2452 if (!can_init_statics && has_static_field_initializers) {
2453 klass->SetStatus(Class::kStatusVerified); // Don't leave class in initializing state.
2454 success = false;
2455 } else {
2456 klass->SetStatus(Class::kStatusInitialized);
2457 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002458 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002459 ClassHelper kh(klass);
2460 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002461 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002462 }
2463 lock.NotifyAll();
2464 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002465 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002466}
2467
Brian Carlstromd1422f82011-09-28 11:37:09 -07002468bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock) {
2469 while (true) {
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002470 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002471 lock.Wait();
2472
2473 // When we wake up, repeat the test for init-in-progress. If
2474 // there's an exception pending (only possible if
2475 // "interruptShouldThrow" was set), bail out.
2476 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002477 WrapExceptionInInitializer();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002478 klass->SetStatus(Class::kStatusError);
2479 return false;
2480 }
2481 // Spurious wakeup? Go back to waiting.
2482 if (klass->GetStatus() == Class::kStatusInitializing) {
2483 continue;
2484 }
2485 if (klass->IsErroneous()) {
2486 // The caller wants an exception, but it was thrown in a
2487 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002488 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002489 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002490 return false;
2491 }
2492 if (klass->IsInitialized()) {
2493 return true;
2494 }
2495 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2496 }
2497 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2498}
2499
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002500bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
2501 if (klass->IsInterface()) {
2502 return true;
2503 }
2504 // begin with the methods local to the superclass
2505 if (klass->HasSuperClass() &&
2506 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
2507 const Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002508 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
2509 const Method* method = klass->GetVTable()->Get(i);
2510 if (method != super->GetVTable()->Get(i) &&
2511 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002512 ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
2513 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2514 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002515 return false;
2516 }
2517 }
2518 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002519 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
2520 InterfaceEntry* interface_entry = klass->GetIfTable()->Get(i);
2521 Class* interface = interface_entry->GetInterface();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002522 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2523 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002524 const Method* method = interface_entry->GetMethodArray()->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002525 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2526 method->GetDeclaringClass())) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002527 ThrowLinkageError("Class %s method %s resolves differently in interface %s",
2528 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2529 PrettyMethod(method).c_str(),
2530 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002531 return false;
2532 }
2533 }
2534 }
2535 }
2536 return true;
2537}
2538
Ian Rogers595799e2012-01-11 17:32:51 -08002539// Returns true if classes referenced by the signature of the method are the
2540// same classes in klass1 as they are in klass2.
2541bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const Method* method,
2542 const Class* klass1,
2543 const Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002544 if (klass1 == klass2) {
2545 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002546 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07002547 const DexFile& dex_file = FindDexFile(method->GetDeclaringClass()->GetDexCache());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002548 const DexFile::ProtoId& proto_id =
2549 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002550 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2551 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002552 if (descriptor == NULL) {
2553 break;
2554 }
2555 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2556 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002557 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002558 return false;
2559 }
2560 }
2561 }
2562 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002563 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002564 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002565 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002566 return false;
2567 }
2568 }
2569 return true;
2570}
2571
Ian Rogers595799e2012-01-11 17:32:51 -08002572// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2573bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
2574 const Class* klass1,
2575 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002576 CHECK(descriptor != NULL);
2577 CHECK(klass1 != NULL);
2578 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002579 if (klass1 == klass2) {
2580 return true;
2581 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002582 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002583 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002584 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002585 }
Ian Rogers595799e2012-01-11 17:32:51 -08002586 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
2587 if (found2 == NULL) {
2588 Thread::Current()->ClearException();
2589 }
2590 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002591}
2592
Ian Rogers0045a292012-03-31 21:08:41 -07002593bool ClassLinker::InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002594 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002595 if (!klass->IsInterface() && klass->HasSuperClass()) {
2596 Class* super_class = klass->GetSuperClass();
2597 if (super_class->GetStatus() != Class::kStatusInitialized) {
2598 CHECK(!super_class->IsInterface());
Elliott Hughes5f791332011-09-15 17:45:30 -07002599 Thread* self = Thread::Current();
2600 klass->MonitorEnter(self);
Ian Rogers0045a292012-03-31 21:08:41 -07002601 bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
Elliott Hughes5f791332011-09-15 17:45:30 -07002602 klass->MonitorExit(self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002603 // TODO: check for a pending exception
2604 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002605 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002606 // Don't set status to error when we can't run <clinit>.
2607 CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
2608 klass->SetStatus(Class::kStatusVerified);
2609 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002610 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002611 klass->SetStatus(Class::kStatusError);
2612 klass->NotifyAll();
2613 return false;
2614 }
2615 }
2616 }
2617 return true;
2618}
2619
Ian Rogers0045a292012-03-31 21:08:41 -07002620bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields) {
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002621 CHECK(c != NULL);
2622 if (c->IsInitialized()) {
2623 return true;
2624 }
2625
Elliott Hughes5f791332011-09-15 17:45:30 -07002626 Thread* self = Thread::Current();
Elliott Hughes4681c802011-09-25 18:04:37 -07002627 ScopedThreadStateChange tsc(self, Thread::kRunnable);
Ian Rogers0045a292012-03-31 21:08:41 -07002628 bool success = InitializeClass(c, can_run_clinit, can_init_fields);
Ian Rogers595799e2012-01-11 17:32:51 -08002629 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002630 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002631 }
2632 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002633}
2634
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002635void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Ian Rogers0571d352011-11-03 19:51:38 -07002636 Class* c, std::map<uint32_t, Field*>& field_map) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002637 const ClassLoader* cl = c->GetClassLoader();
2638 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002639 ClassDataItemIterator it(dex_file, class_data);
2640 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
2641 field_map[i] = ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002642 }
2643}
2644
Ian Rogers0045a292012-03-31 21:08:41 -07002645bool ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002646 size_t num_static_fields = klass->NumStaticFields();
2647 if (num_static_fields == 0) {
Ian Rogers0045a292012-03-31 21:08:41 -07002648 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002649 }
Brian Carlstromf615a612011-07-23 12:50:34 -07002650 DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002651 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002652 if (dex_cache == NULL) {
Ian Rogers0045a292012-03-31 21:08:41 -07002653 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002654 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002655 ClassHelper kh(klass);
2656 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002657 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002658 const DexFile& dex_file = kh.GetDexFile();
Ian Rogers0571d352011-11-03 19:51:38 -07002659 EncodedStaticFieldValueIterator it(dex_file, dex_cache, this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002660
Ian Rogers0571d352011-11-03 19:51:38 -07002661 if (it.HasNext()) {
2662 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
2663 std::map<uint32_t, Field*> field_map;
2664 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
2665 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
2666 it.ReadValueToField(field_map[i]);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002667 }
Ian Rogers0045a292012-03-31 21:08:41 -07002668 return true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002669 }
Ian Rogers0045a292012-03-31 21:08:41 -07002670 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002671}
2672
Ian Rogersc2b44472011-12-14 21:17:17 -08002673bool ClassLinker::LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002674 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002675 if (!LinkSuperClass(klass)) {
2676 return false;
2677 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002678 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002679 return false;
2680 }
2681 if (!LinkInstanceFields(klass)) {
2682 return false;
2683 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07002684 if (!LinkStaticFields(klass)) {
2685 return false;
2686 }
2687 CreateReferenceInstanceOffsets(klass);
2688 CreateReferenceStaticOffsets(klass);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002689 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
2690 klass->SetStatus(Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002691 return true;
2692}
2693
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002694bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002695 CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002696 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
2697 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08002698 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002699 uint16_t super_class_idx = class_def->superclass_idx_;
2700 if (super_class_idx != DexFile::kDexNoIndex16) {
2701 Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002702 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07002703 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002704 return false;
2705 }
Ian Rogersbe125a92012-01-11 15:19:49 -08002706 // Verify
2707 if (!klass->CanAccess(super_class)) {
2708 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2709 "Class %s extended by class %s is inaccessible",
2710 PrettyDescriptor(super_class).c_str(),
2711 PrettyDescriptor(klass.get()).c_str());
2712 return false;
2713 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002714 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002715 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002716 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
2717 if (interfaces != NULL) {
2718 for (size_t i = 0; i < interfaces->Size(); i++) {
2719 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
2720 Class* interface = ResolveType(dex_file, idx, klass.get());
2721 if (interface == NULL) {
2722 DCHECK(Thread::Current()->IsExceptionPending());
2723 return false;
2724 }
2725 // Verify
2726 if (!klass->CanAccess(interface)) {
2727 // TODO: the RI seemed to ignore this in my testing.
2728 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2729 "Interface %s implemented by class %s is inaccessible",
2730 PrettyDescriptor(interface).c_str(),
2731 PrettyDescriptor(klass.get()).c_str());
2732 return false;
2733 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002734 }
2735 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002736 // Mark the class as loaded.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002737 klass->SetStatus(Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002738 return true;
2739}
2740
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002741bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002742 CHECK(!klass->IsPrimitive());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002743 Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002744 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002745 if (super != NULL) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002746 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002747 "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002748 return false;
2749 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002750 return true;
2751 }
2752 if (super == NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002753 ThrowLinkageError("No superclass defined for class %s", PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002754 return false;
2755 }
2756 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002757 if (super->IsFinal() || super->IsInterface()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002758 Thread* self = Thread::Current();
2759 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002760 "Superclass %s of %s is %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002761 PrettyDescriptor(super).c_str(),
2762 PrettyDescriptor(klass.get()).c_str(),
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002763 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002764 return false;
2765 }
2766 if (!klass->CanAccess(super)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002767 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002768 "Superclass %s is inaccessible by %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002769 PrettyDescriptor(super).c_str(),
2770 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002771 return false;
2772 }
Elliott Hughes20cde902011-10-04 17:37:27 -07002773
2774 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
2775 if (super->IsFinalizable()) {
2776 klass->SetFinalizable();
2777 }
2778
Elliott Hughes2da50362011-10-10 16:57:08 -07002779 // Inherit reference flags (if any) from the superclass.
2780 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
2781 if (reference_flags != 0) {
2782 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
2783 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002784 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07002785 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002786 ThrowLinkageError("Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002787 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002788 return false;
2789 }
Elliott Hughes2da50362011-10-10 16:57:08 -07002790
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002791#ifndef NDEBUG
2792 // Ensure super classes are fully resolved prior to resolving fields..
2793 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002794 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002795 super = super->GetSuperClass();
2796 }
2797#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002798 return true;
2799}
2800
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002801// Populate the class vtable and itable. Compute return type indices.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002802bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002803 if (klass->IsInterface()) {
2804 // No vtable.
2805 size_t count = klass->NumVirtualMethods();
2806 if (!IsUint(16, count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08002807 ThrowClassFormatError("Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002808 return false;
2809 }
Carl Shapiro565f5072011-07-10 13:39:43 -07002810 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002811 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002812 }
jeffhaobdb76512011-09-07 11:43:16 -07002813 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002814 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002815 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07002816 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002817 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002818 }
2819 return true;
2820}
2821
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002822bool ClassLinker::LinkVirtualMethods(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002823 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002824 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
2825 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002826 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002827 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08002828 SirtRef<ObjectArray<Method> > vtable(klass->GetSuperClass()->GetVTable()->CopyOf(max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002829 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002830 MethodHelper local_mh(NULL, this);
2831 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002832 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002833 Method* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002834 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002835 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002836 for (; j < actual_count; ++j) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002837 Method* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002838 super_mh.ChangeMethod(super_method);
2839 if (local_mh.HasSameNameAndSignature(&super_mh)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002840 // Verify
2841 if (super_method->IsFinal()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002842 MethodHelper mh(local_method);
Elliott Hughese555dc02011-09-25 10:46:35 -07002843 ThrowLinkageError("Method %s.%s overrides final method in class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002844 PrettyDescriptor(klass.get()).c_str(),
2845 mh.GetName(), mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002846 return false;
2847 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002848 vtable->Set(j, local_method);
2849 local_method->SetMethodIndex(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002850 break;
2851 }
2852 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002853 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002854 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002855 vtable->Set(actual_count, local_method);
2856 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002857 actual_count += 1;
2858 }
2859 }
2860 if (!IsUint(16, actual_count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08002861 ThrowClassFormatError("Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002862 return false;
2863 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002864 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002865 CHECK_LE(actual_count, max_count);
2866 if (actual_count < max_count) {
Ian Rogers30fab402012-01-23 15:43:46 -08002867 vtable.reset(vtable->CopyOf(actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002868 }
Ian Rogers30fab402012-01-23 15:43:46 -08002869 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002870 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002871 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002872 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002873 if (!IsUint(16, num_virtual_methods)) {
Elliott Hughese555dc02011-09-25 10:46:35 -07002874 ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002875 return false;
2876 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002877 SirtRef<ObjectArray<Method> > vtable(AllocObjectArray<Method>(num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002878 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002879 Method* virtual_method = klass->GetVirtualMethodDuringLinking(i);
2880 vtable->Set(i, virtual_method);
2881 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002882 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002883 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002884 }
2885 return true;
2886}
2887
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002888bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002889 size_t super_ifcount;
2890 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002891 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002892 } else {
2893 super_ifcount = 0;
2894 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002895 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002896 ClassHelper kh(klass.get(), this);
2897 uint32_t num_interfaces = interfaces == NULL ? kh.NumInterfaces() : interfaces->GetLength();
2898 ifcount += num_interfaces;
2899 for (size_t i = 0; i < num_interfaces; i++) {
2900 Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
2901 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002902 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002903 if (ifcount == 0) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002904 // TODO: enable these asserts with klass status validation
Elliott Hughesf5a7a472011-10-07 14:31:02 -07002905 // DCHECK_EQ(klass->GetIfTableCount(), 0);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002906 // DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002907 return true;
2908 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002909 SirtRef<ObjectArray<InterfaceEntry> > iftable(AllocObjectArray<InterfaceEntry>(ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002910 if (super_ifcount != 0) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002911 ObjectArray<InterfaceEntry>* super_iftable = klass->GetSuperClass()->GetIfTable();
2912 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogersb52b01a2012-01-12 17:01:38 -08002913 Class* super_interface = super_iftable->Get(i)->GetInterface();
2914 iftable->Set(i, AllocInterfaceEntry(super_interface));
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002915 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002916 }
2917 // Flatten the interface inheritance hierarchy.
2918 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002919 for (size_t i = 0; i < num_interfaces; i++) {
2920 Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002921 DCHECK(interface != NULL);
2922 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002923 ClassHelper ih(interface);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002924 Thread* self = Thread::Current();
2925 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002926 "Class %s implements non-interface class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002927 PrettyDescriptor(klass.get()).c_str(),
2928 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002929 return false;
2930 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08002931 // Check if interface is already in iftable
2932 bool duplicate = false;
2933 for (size_t j = 0; j < idx; j++) {
2934 Class* existing_interface = iftable->Get(j)->GetInterface();
2935 if (existing_interface == interface) {
2936 duplicate = true;
2937 break;
2938 }
2939 }
2940 if (!duplicate) {
2941 // Add this non-duplicate interface.
2942 iftable->Set(idx++, AllocInterfaceEntry(interface));
2943 // Add this interface's non-duplicate super-interfaces.
2944 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
2945 Class* super_interface = interface->GetIfTable()->Get(j)->GetInterface();
2946 bool super_duplicate = false;
2947 for (size_t k = 0; k < idx; k++) {
2948 Class* existing_interface = iftable->Get(k)->GetInterface();
2949 if (existing_interface == super_interface) {
2950 super_duplicate = true;
2951 break;
2952 }
2953 }
2954 if (!super_duplicate) {
2955 iftable->Set(idx++, AllocInterfaceEntry(super_interface));
2956 }
2957 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002958 }
2959 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08002960 // Shrink iftable in case duplicates were found
2961 if (idx < ifcount) {
2962 iftable.reset(iftable->CopyOf(idx));
2963 ifcount = idx;
2964 } else {
2965 CHECK_EQ(idx, ifcount);
2966 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002967 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07002968
2969 // If we're an interface, we don't need the vtable pointers, so we're done.
2970 if (klass->IsInterface() /*|| super_ifcount == ifcount*/) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002971 return true;
2972 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002973 std::vector<Method*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002974 MethodHelper vtable_mh(NULL, this);
2975 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002976 for (size_t i = 0; i < ifcount; ++i) {
2977 InterfaceEntry* interface_entry = iftable->Get(i);
2978 Class* interface = interface_entry->GetInterface();
2979 ObjectArray<Method>* method_array = AllocObjectArray<Method>(interface->NumVirtualMethods());
2980 interface_entry->SetMethodArray(method_array);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002981 ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002982 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
2983 Method* interface_method = interface->GetVirtualMethod(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002984 interface_mh.ChangeMethod(interface_method);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002985 int32_t k;
Elliott Hughes4681c802011-09-25 18:04:37 -07002986 // For each method listed in the interface's method list, find the
2987 // matching method in our class's method list. We want to favor the
2988 // subclass over the superclass, which just requires walking
2989 // back from the end of the vtable. (This only matters if the
2990 // superclass defines a private method and this class redefines
2991 // it -- otherwise it would use the same vtable slot. In .dex files
2992 // those don't end up in the virtual method table, so it shouldn't
2993 // matter which direction we go. We walk it backward anyway.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002994 for (k = vtable->GetLength() - 1; k >= 0; --k) {
2995 Method* vtable_method = vtable->Get(k);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002996 vtable_mh.ChangeMethod(vtable_method);
2997 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07002998 if (!vtable_method->IsPublic()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002999 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003000 "Implementation not public: %s", PrettyMethod(vtable_method).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003001 return false;
3002 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003003 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003004 break;
3005 }
3006 }
3007 if (k < 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003008 SirtRef<Method> miranda_method(NULL);
Elliott Hughes4681c802011-09-25 18:04:37 -07003009 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003010 Method* mir_method = miranda_list[mir];
3011 vtable_mh.ChangeMethod(mir_method);
3012 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003013 miranda_method.reset(miranda_list[mir]);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003014 break;
3015 }
3016 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003017 if (miranda_method.get() == NULL) {
Elliott Hughes4681c802011-09-25 18:04:37 -07003018 // point the interface table at a phantom slot
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003019 miranda_method.reset(AllocMethod());
3020 memcpy(miranda_method.get(), interface_method, sizeof(Method));
3021 miranda_list.push_back(miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003022 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003023 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003024 }
3025 }
3026 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003027 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003028 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003029 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07003030 klass->SetVirtualMethods((old_method_count == 0)
3031 ? AllocObjectArray<Method>(new_method_count)
3032 : klass->GetVirtualMethods()->CopyOf(new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003033
Ian Rogers30fab402012-01-23 15:43:46 -08003034 SirtRef<ObjectArray<Method> > vtable(klass->GetVTableDuringLinking());
3035 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003036 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003037 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers30fab402012-01-23 15:43:46 -08003038 vtable.reset(vtable->CopyOf(new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07003039 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07003040 Method* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003041 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003042 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3043 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3044 klass->SetVirtualMethod(old_method_count + i, method);
3045 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003046 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003047 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003048 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003049 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003050
3051 ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
3052 for (int i = 0; i < vtable->GetLength(); ++i) {
3053 CHECK(vtable->Get(i) != NULL);
3054 }
3055
3056// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3057
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003058 return true;
3059}
3060
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003061bool ClassLinker::LinkInstanceFields(SirtRef<Class>& klass) {
3062 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003063 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003064}
3065
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003066bool ClassLinker::LinkStaticFields(SirtRef<Class>& klass) {
3067 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003068 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003069 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003070 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003071 return success;
3072}
3073
Brian Carlstromdbc05252011-09-09 01:59:59 -07003074struct LinkFieldsComparator {
Elliott Hughesba8eee12012-01-24 20:25:24 -08003075 explicit LinkFieldsComparator(FieldHelper* fh) : fh_(fh) {}
Elliott Hughes3b6baaa2011-10-14 19:13:56 -07003076 bool operator()(const Field* field1, const Field* field2) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003077 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003078 fh_->ChangeField(field1);
3079 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3080 fh_->ChangeField(field2);
3081 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003082 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3083 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3084 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3085 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003086 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3087 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3088 if (order1 != order2) {
3089 return order1 < order2;
3090 }
3091
3092 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003093 fh_->ChangeField(field1);
3094 StringPiece name1(fh_->GetName());
3095 fh_->ChangeField(field2);
3096 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003097 return name1 < name2;
3098 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003099
3100 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003101};
3102
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003103bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003104 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003105 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003106
3107 ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003108 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003109
3110 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003111 size_t size;
3112 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003113 if (is_static) {
3114 size = klass->GetClassSize();
3115 field_offset = Class::FieldsOffset();
3116 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003117 Class* super_class = klass->GetSuperClass();
3118 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003119 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003120 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003121 }
3122 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003123 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003124
Brian Carlstromdbc05252011-09-09 01:59:59 -07003125 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003126
Brian Carlstromdbc05252011-09-09 01:59:59 -07003127 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003128 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromdbc05252011-09-09 01:59:59 -07003129 std::deque<Field*> grouped_and_sorted_fields;
3130 for (size_t i = 0; i < num_fields; i++) {
3131 grouped_and_sorted_fields.push_back(fields->Get(i));
3132 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003133 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003134 std::sort(grouped_and_sorted_fields.begin(),
3135 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003136 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003137
3138 // References should be at the front.
3139 size_t current_field = 0;
3140 size_t num_reference_fields = 0;
3141 for (; current_field < num_fields; current_field++) {
3142 Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003143 fh.ChangeField(field);
3144 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003145 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003146 if (isPrimitive) {
3147 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003148 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003149 grouped_and_sorted_fields.pop_front();
3150 num_reference_fields++;
3151 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003152 field->SetOffset(field_offset);
3153 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003154 }
3155
3156 // Now we want to pack all of the double-wide fields together. If
3157 // we're not aligned, though, we want to shuffle one 32-bit field
3158 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003159 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003160 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
3161 Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003162 fh.ChangeField(field);
3163 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003164 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3165 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003166 continue;
3167 }
3168 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003169 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003170 // drop the consumed field
3171 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3172 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003173 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003174 // whether we found a 32-bit field for padding or not, we advance
3175 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003176 }
3177
3178 // Alignment is good, shuffle any double-wide fields forward, and
3179 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003180 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003181 while (!grouped_and_sorted_fields.empty()) {
3182 Field* field = grouped_and_sorted_fields.front();
3183 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003184 fh.ChangeField(field);
3185 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003186 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003187 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003188 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003189 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003190 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003191 ? sizeof(uint64_t)
3192 : sizeof(uint32_t)));
3193 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003194 }
3195
Elliott Hughesadb460d2011-10-05 17:02:34 -07003196 // 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 -08003197 std::string descriptor(ClassHelper(klass.get(), this).GetDescriptor());
3198 if (!is_static && descriptor == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003199 // We know there are no non-reference fields in the Reference classes, and we know
3200 // that 'referent' is alphabetically last, so this is easy...
3201 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003202 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003203 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003204 --num_reference_fields;
3205 }
3206
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003207#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003208 // Make sure that all reference fields appear before
3209 // non-reference fields, and all double-wide fields are aligned.
3210 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003211 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003212 Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003213 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003214 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003215 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003216 << " field=" << PrettyField(field)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003217 << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
3218 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003219 fh.ChangeField(field);
3220 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003221 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003222 if (descriptor == "Ljava/lang/ref/Reference;" && StringPiece(fh.GetName()) == "referent") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003223 is_primitive = true; // We lied above, so we have to expect a lie here.
3224 }
3225 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003226 if (!seen_non_ref) {
3227 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003228 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003229 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003230 } else {
3231 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003232 }
3233 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003234 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003235 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003236 }
3237#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003238 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003239 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003240 if (is_static) {
3241 klass->SetNumReferenceStaticFields(num_reference_fields);
3242 klass->SetClassSize(size);
3243 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003244 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003245 if (!klass->IsVariableSize()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003246 klass->SetObjectSize(size);
3247 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003248 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003249 return true;
3250}
3251
3252// Set the bitmap of reference offsets, refOffsets, from the ifields
3253// list.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003254void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003255 uint32_t reference_offsets = 0;
3256 Class* super_class = klass->GetSuperClass();
3257 if (super_class != NULL) {
3258 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003259 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003260 if (reference_offsets == CLASS_WALK_SUPER) {
3261 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003262 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003263 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003264 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003265 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003266}
3267
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003268void ClassLinker::CreateReferenceStaticOffsets(SirtRef<Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003269 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003270}
3271
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003272void ClassLinker::CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003273 uint32_t reference_offsets) {
3274 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003275 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3276 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003277 const ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003278 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003279 // All of the fields that contain object references are guaranteed
3280 // to be at the beginning of the fields list.
3281 for (size_t i = 0; i < num_reference_fields; ++i) {
3282 // Note that byte_offset is the offset from the beginning of
3283 // object, not the offset into instance data
3284 const Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003285 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003286 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3287 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3288 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003289 CHECK_NE(new_bit, 0U);
3290 reference_offsets |= new_bit;
3291 } else {
3292 reference_offsets = CLASS_WALK_SUPER;
3293 break;
3294 }
3295 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003296 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003297 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003298 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003299 } else {
3300 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003301 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003302}
3303
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003304String* ClassLinker::ResolveString(const DexFile& dex_file,
Elliott Hughescf4c6c42011-09-01 15:16:42 -07003305 uint32_t string_idx, DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003306 DCHECK(dex_cache != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003307 String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003308 if (resolved != NULL) {
3309 return resolved;
3310 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003311 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3312 int32_t utf16_length = dex_file.GetStringLength(string_id);
3313 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom928bf022011-10-11 02:48:14 -07003314 String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003315 dex_cache->SetResolvedString(string_idx, string);
3316 return string;
3317}
3318
3319Class* ClassLinker::ResolveType(const DexFile& dex_file,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003320 uint16_t type_idx,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003321 DexCache* dex_cache,
3322 const ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003323 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003324 Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003325 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003326 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003327 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003328 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003329 // TODO: we used to throw here if resolved's class loader was not the
3330 // boot class loader. This was to permit different classes with the
3331 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003332 dex_cache->SetResolvedType(type_idx, resolved);
3333 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08003334 CHECK(Thread::Current()->IsExceptionPending())
3335 << "Expected pending exception for failed resolution of: " << descriptor;
jeffhao8cd6dda2012-02-22 10:15:34 -08003336 // Convert a ClassNotFoundException to a NoClassDefFoundError
3337 if (Thread::Current()->GetException()->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
3338 Thread::Current()->ClearException();
3339 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
3340 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003341 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003342 }
3343 return resolved;
3344}
3345
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003346Method* ClassLinker::ResolveMethod(const DexFile& dex_file,
3347 uint32_t method_idx,
3348 DexCache* dex_cache,
3349 const ClassLoader* class_loader,
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003350 bool is_direct) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003351 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003352 Method* resolved = dex_cache->GetResolvedMethod(method_idx);
3353 if (resolved != NULL) {
3354 return resolved;
3355 }
3356 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
3357 Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
3358 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003359 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003360 return NULL;
3361 }
3362
Brian Carlstrom7540ff42011-09-04 16:38:46 -07003363 if (is_direct) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003364 resolved = klass->FindDirectMethod(dex_cache, method_idx);
Brian Carlstrom7540ff42011-09-04 16:38:46 -07003365 } else if (klass->IsInterface()) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003366 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003367 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003368 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003369 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003370
3371 if (resolved == NULL) {
3372 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3373 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3374 if (is_direct) {
3375 resolved = klass->FindDirectMethod(name, signature);
3376 } else if (klass->IsInterface()) {
3377 resolved = klass->FindInterfaceMethod(name, signature);
3378 } else {
3379 resolved = klass->FindVirtualMethod(name, signature);
jeffhao8cd6dda2012-02-22 10:15:34 -08003380 // If a virtual method isn't found, search the direct methods. This can
3381 // happen when trying to access private methods directly, and allows the
3382 // proper exception to be thrown in the caller.
3383 if (resolved == NULL) {
3384 resolved = klass->FindDirectMethod(name, signature);
3385 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003386 }
3387 if (resolved == NULL) {
3388 ThrowNoSuchMethodError(is_direct, klass, name, signature);
3389 return NULL;
3390 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003391 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003392 dex_cache->SetResolvedMethod(method_idx, resolved);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003393 return resolved;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003394}
3395
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003396Field* ClassLinker::ResolveField(const DexFile& dex_file,
3397 uint32_t field_idx,
3398 DexCache* dex_cache,
3399 const ClassLoader* class_loader,
3400 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003401 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003402 Field* resolved = dex_cache->GetResolvedField(field_idx);
3403 if (resolved != NULL) {
3404 return resolved;
3405 }
3406 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3407 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3408 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003409 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003410 return NULL;
3411 }
3412
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003413 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003414 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003415 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003416 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003417 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003418
3419 if (resolved == NULL) {
3420 const char* name = dex_file.GetFieldName(field_id);
3421 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3422 if (is_static) {
3423 resolved = klass->FindStaticField(name, type);
3424 } else {
3425 resolved = klass->FindInstanceField(name, type);
3426 }
3427 if (resolved == NULL) {
3428 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3429 return NULL;
3430 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003431 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003432 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003433 return resolved;
3434}
3435
3436Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3437 uint32_t field_idx,
3438 DexCache* dex_cache,
3439 const ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003440 DCHECK(dex_cache != NULL);
Ian Rogersb067ac22011-12-13 18:05:09 -08003441 Field* resolved = dex_cache->GetResolvedField(field_idx);
3442 if (resolved != NULL) {
3443 return resolved;
3444 }
3445 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3446 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3447 if (klass == NULL) {
3448 DCHECK(Thread::Current()->IsExceptionPending());
3449 return NULL;
3450 }
3451
3452 const char* name = dex_file.GetFieldName(field_id);
3453 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3454 resolved = klass->FindField(name, type);
3455 if (resolved != NULL) {
3456 dex_cache->SetResolvedField(field_idx, resolved);
3457 } else {
3458 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003459 }
3460 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003461}
3462
Ian Rogers19846512012-02-24 11:42:47 -08003463const char* ClassLinker::MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length) {
Ian Rogersad25ac52011-10-04 19:13:33 -07003464 Class* declaring_class = referrer->GetDeclaringClass();
3465 DexCache* dex_cache = declaring_class->GetDexCache();
3466 const DexFile& dex_file = FindDexFile(dex_cache);
3467 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003468 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003469}
3470
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003471void ClassLinker::DumpAllClasses(int flags) const {
3472 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3473 // lock held, because it might need to resolve a field's type, which would try to take the lock.
3474 std::vector<Class*> all_classes;
3475 {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003476 MutexLock mu(classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003477 typedef Table::const_iterator It; // TODO: C++0x auto
3478 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3479 all_classes.push_back(it->second);
3480 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003481 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3482 all_classes.push_back(it->second);
3483 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003484 }
3485
3486 for (size_t i = 0; i < all_classes.size(); ++i) {
3487 all_classes[i]->DumpClass(std::cerr, flags);
3488 }
3489}
3490
Elliott Hughescac6cc72011-11-03 20:31:21 -07003491void ClassLinker::DumpForSigQuit(std::ostream& os) const {
3492 MutexLock mu(classes_lock_);
3493 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3494 << classes_.size() << " allocated classes\n";
3495}
3496
Elliott Hughese27955c2011-08-26 15:21:24 -07003497size_t ClassLinker::NumLoadedClasses() const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003498 MutexLock mu(classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003499 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003500}
3501
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003502pid_t ClassLinker::GetClassesLockOwner() {
3503 return classes_lock_.GetOwner();
3504}
3505
3506pid_t ClassLinker::GetDexLockOwner() {
3507 return dex_lock_.GetOwner();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003508}
3509
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003510void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
3511 DCHECK(!init_done_);
3512
3513 DCHECK(klass != NULL);
3514 DCHECK(klass->GetClassLoader() == NULL);
3515
3516 DCHECK(class_roots_ != NULL);
3517 DCHECK(class_roots_->Get(class_root) == NULL);
3518 class_roots_->Set(class_root, klass);
3519}
3520
Logan Chien0c717dd2012-03-28 18:31:07 +08003521void ClassLinker::RelocateExecutable() {
3522 for (size_t i = 0; i < oat_files_.size(); ++i) {
3523 const_cast<OatFile*>(oat_files_[i])->RelocateExecutable();
3524 }
3525}
3526
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003527} // namespace art