blob: 1edfe1ab0335c0e697feaafdd72f803d05ea79bf [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 "heap.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070036#include "intern_table.h"
Ian Rogers0571d352011-11-03 19:51:38 -070037#include "leb128.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070038#include "logging.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070039#include "oat_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070040#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080041#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080042#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070043#include "runtime.h"
Ian Rogers466bb252011-10-14 03:29:56 -070044#include "runtime_support.h"
TDYa1275bb86012012-04-11 05:57:28 -070045#if defined(ART_USE_LLVM_COMPILER)
46#include "compiler_llvm/runtime_support_llvm.h"
47#endif
Elliott Hughes4d0207c2011-10-03 19:14:34 -070048#include "ScopedLocalRef.h"
Brian Carlstroma663ea52011-08-19 23:33:41 -070049#include "space.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070050#include "stack_indirect_reference_table.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070051#include "stl_util.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070052#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070053#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070054#include "utils.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070055
56namespace art {
57
Elliott Hughes0512f022012-03-15 22:10:52 -070058static void ThrowNoClassDefFoundError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
59static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070060 va_list args;
61 va_start(args, fmt);
62 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
63 va_end(args);
64}
65
Elliott Hughes0512f022012-03-15 22:10:52 -070066static void ThrowClassFormatError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
67static void ThrowClassFormatError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070068 va_list args;
69 va_start(args, fmt);
Elliott Hughese555dc02011-09-25 10:46:35 -070070 Thread::Current()->ThrowNewExceptionV("Ljava/lang/ClassFormatError;", fmt, args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -070071 va_end(args);
72}
73
Elliott Hughes0512f022012-03-15 22:10:52 -070074static void ThrowLinkageError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
75static void ThrowLinkageError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070076 va_list args;
77 va_start(args, fmt);
78 Thread::Current()->ThrowNewExceptionV("Ljava/lang/LinkageError;", fmt, args);
79 va_end(args);
80}
81
Elliott Hughes0512f022012-03-15 22:10:52 -070082static void ThrowNoSuchMethodError(bool is_direct, Class* c, const StringPiece& name,
83 const StringPiece& signature) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080084 ClassHelper kh(c);
Elliott Hughes3b6baaa2011-10-14 19:13:56 -070085 std::ostringstream msg;
Ian Rogersc8b306f2012-02-17 21:34:44 -080086 msg << "no " << (is_direct ? "direct" : "virtual") << " method " << name << signature
Ian Rogers9f1ab122011-12-12 08:52:43 -080087 << " in class " << kh.GetDescriptor() << " or its superclasses";
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080088 std::string location(kh.GetLocation());
89 if (!location.empty()) {
90 msg << " (defined in " << location << ")";
Elliott Hughescc5f9a92011-09-28 19:17:29 -070091 }
Elliott Hughes5cb5ad22011-10-02 12:13:39 -070092 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
Elliott Hughescc5f9a92011-09-28 19:17:29 -070093}
94
Elliott Hughes0512f022012-03-15 22:10:52 -070095static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
96 const StringPiece& name) {
Ian Rogers9f1ab122011-12-12 08:52:43 -080097 ClassHelper kh(c);
98 std::ostringstream msg;
Ian Rogersb067ac22011-12-13 18:05:09 -080099 msg << "no " << scope << "field " << name << " of type " << type
Ian Rogers9f1ab122011-12-12 08:52:43 -0800100 << " in class " << kh.GetDescriptor() << " or its superclasses";
101 std::string location(kh.GetLocation());
102 if (!location.empty()) {
103 msg << " (defined in " << location << ")";
104 }
105 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
106}
107
Elliott Hughes0512f022012-03-15 22:10:52 -0700108static void ThrowNullPointerException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
109static void ThrowNullPointerException(const char* fmt, ...) {
Ian Rogerscab01012012-01-10 17:35:46 -0800110 va_list args;
111 va_start(args, fmt);
112 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NullPointerException;", fmt, args);
113 va_end(args);
114}
115
Elliott Hughes0512f022012-03-15 22:10:52 -0700116static void ThrowEarlierClassFailure(Class* c) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700117 /*
118 * The class failed to initialize on a previous attempt, so we want to throw
119 * a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
120 * failed in verification, in which case v2 5.4.1 says we need to re-throw
121 * the previous error.
122 */
123 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
124
Brian Carlstrom4d9716c2012-01-30 01:49:33 -0800125 CHECK(c->IsErroneous()) << PrettyClass(c);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700126 if (c->GetVerifyErrorClass() != NULL) {
127 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800128 ClassHelper ve_ch(c->GetVerifyErrorClass());
129 std::string error_descriptor(ve_ch.GetDescriptor());
130 Thread::Current()->ThrowNewException(error_descriptor.c_str(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700131 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800132 ThrowNoClassDefFoundError("%s", PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700133 }
134}
135
Elliott Hughes0512f022012-03-15 22:10:52 -0700136static void WrapExceptionInInitializer() {
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700137 JNIEnv* env = Thread::Current()->GetJniEnv();
138
139 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
140 CHECK(cause.get() != NULL);
141
142 env->ExceptionClear();
143
144 // TODO: add java.lang.Error to JniConstants?
145 ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/Error"));
146 CHECK(error_class.get() != NULL);
147 if (env->IsInstanceOf(cause.get(), error_class.get())) {
148 // We only wrap non-Error exceptions; an Error can just be used as-is.
149 env->Throw(cause.get());
150 return;
151 }
152
153 // TODO: add java.lang.ExceptionInInitializerError to JniConstants?
154 ScopedLocalRef<jclass> eiie_class(env, env->FindClass("java/lang/ExceptionInInitializerError"));
155 CHECK(eiie_class.get() != NULL);
156
157 jmethodID mid = env->GetMethodID(eiie_class.get(), "<init>" , "(Ljava/lang/Throwable;)V");
158 CHECK(mid != NULL);
159
160 ScopedLocalRef<jthrowable> eiie(env,
161 reinterpret_cast<jthrowable>(env->NewObject(eiie_class.get(), mid, cause.get())));
162 env->Throw(eiie.get());
163}
164
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800165static size_t Hash(const char* s) {
166 // This is the java.lang.String hashcode for convenience, not interoperability.
167 size_t hash = 0;
168 for (; *s != '\0'; ++s) {
169 hash = hash * 31 + *s;
170 }
171 return hash;
172}
173
Elliott Hughes418d20f2011-09-22 14:00:39 -0700174const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700175 "Ljava/lang/Class;",
176 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700177 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700178 "[Ljava/lang/Object;",
179 "Ljava/lang/String;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700180 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700181 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700182 "Ljava/lang/reflect/Field;",
183 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700184 "Ljava/lang/reflect/Proxy;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700185 "Ljava/lang/ClassLoader;",
186 "Ldalvik/system/BaseDexClassLoader;",
187 "Ldalvik/system/PathClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800188 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800189 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700190 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700191 "Z",
192 "B",
193 "C",
194 "D",
195 "F",
196 "I",
197 "J",
198 "S",
199 "V",
200 "[Z",
201 "[B",
202 "[C",
203 "[D",
204 "[F",
205 "[I",
206 "[J",
207 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700208 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700209};
210
Brian Carlstroma004aa92012-02-08 18:05:09 -0800211ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
212 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700213 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800214 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800215 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700216 return class_linker.release();
217}
218
Brian Carlstroma004aa92012-02-08 18:05:09 -0800219ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800220 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700221 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700222 return class_linker.release();
223}
224
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800225ClassLinker::ClassLinker(InternTable* intern_table)
226 : dex_lock_("ClassLinker dex lock"),
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700227 classes_lock_("ClassLinker classes lock"),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700228 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700229 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700230 init_done_(false),
231 intern_table_(intern_table) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700232 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700233}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700234
Brian Carlstroma004aa92012-02-08 18:05:09 -0800235void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
236 VLOG(startup) << "ClassLinker::Init";
237 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700238
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700239 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700240
Elliott Hughes30646832011-10-13 16:59:46 -0700241 // java_lang_Class comes first, it's needed for AllocClass
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800242 Heap* heap = Runtime::Current()->GetHeap();
243 SirtRef<Class> java_lang_Class(down_cast<Class*>(heap->AllocObject(NULL, sizeof(ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700244 CHECK(java_lang_Class.get() != NULL);
245 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700246 java_lang_Class->SetClassSize(sizeof(ClassClass));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700247 // AllocClass(Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700248
Elliott Hughes418d20f2011-09-22 14:00:39 -0700249 // Class[] is used for reflection support.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700250 SirtRef<Class> class_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
251 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700252
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700253 // java_lang_Object comes next so that object_array_class can be created
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700254 SirtRef<Class> java_lang_Object(AllocClass(java_lang_Class.get(), sizeof(Class)));
255 CHECK(java_lang_Object.get() != NULL);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700256 // backfill Object as the super class of Class
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700257 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700258 java_lang_Object->SetStatus(Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700259
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700260 // Object[] next to hold class roots
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700261 SirtRef<Class> object_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
262 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700263
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700264 // Setup the char class to be used for char[]
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700265 SirtRef<Class> char_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700266
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700267 // Setup the char[] class to be used for String
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700268 SirtRef<Class> char_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
269 char_array_class->SetComponentType(char_class.get());
270 CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700271
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700272 // Setup String
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700273 SirtRef<Class> java_lang_String(AllocClass(java_lang_Class.get(), sizeof(StringClass)));
274 String::SetClass(java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700275 java_lang_String->SetObjectSize(sizeof(String));
276 java_lang_String->SetStatus(Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400277
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700278 // Create storage for root classes, save away our work so far (requires
279 // descriptors)
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700280 class_roots_ = ObjectArray<Class>::Alloc(object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700281 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700282 SetClassRoot(kJavaLangClass, java_lang_Class.get());
283 SetClassRoot(kJavaLangObject, java_lang_Object.get());
284 SetClassRoot(kClassArrayClass, class_array_class.get());
285 SetClassRoot(kObjectArrayClass, object_array_class.get());
286 SetClassRoot(kCharArrayClass, char_array_class.get());
287 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700288
289 // Setup the primitive type classes.
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700290 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass("Z", Primitive::kPrimBoolean));
291 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass("B", Primitive::kPrimByte));
292 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass("S", Primitive::kPrimShort));
293 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass("I", Primitive::kPrimInt));
294 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass("J", Primitive::kPrimLong));
295 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass("F", Primitive::kPrimFloat));
296 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass("D", Primitive::kPrimDouble));
297 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass("V", Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700298
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700299 // Create array interface entries to populate once we can load system classes
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700300 array_iftable_ = AllocObjectArray<InterfaceEntry>(2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700301
302 // Create int array type for AllocDexCache (done in AppendToBootClassPath)
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700303 SirtRef<Class> int_array_class(AllocClass(java_lang_Class.get(), sizeof(Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700304 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700305 IntArray::SetArrayClass(int_array_class.get());
306 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700307
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700308 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700309
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700310 // setup boot_class_path_ and register class_path now that we can
311 // use AllocObjectArray to create DexCache instances
Brian Carlstroma004aa92012-02-08 18:05:09 -0800312 CHECK_NE(0U, boot_class_path.size());
313 for (size_t i = 0; i != boot_class_path.size(); ++i) {
314 const DexFile* dex_file = boot_class_path[i];
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700315 CHECK(dex_file != NULL);
316 AppendToBootClassPath(*dex_file);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700317 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700318
Elliott Hughes80609252011-09-23 17:24:51 -0700319 // Constructor, Field, and Method are necessary so that FindClass can link members
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700320 SirtRef<Class> java_lang_reflect_Constructor(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700321 CHECK(java_lang_reflect_Constructor.get() != NULL);
Elliott Hughes80609252011-09-23 17:24:51 -0700322 java_lang_reflect_Constructor->SetObjectSize(sizeof(Method));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700323 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
Elliott Hughes80609252011-09-23 17:24:51 -0700324 java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
325
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700326 SirtRef<Class> java_lang_reflect_Field(AllocClass(java_lang_Class.get(), sizeof(FieldClass)));
327 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700328 java_lang_reflect_Field->SetObjectSize(sizeof(Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700329 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700330 java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700331 Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700332
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700333 SirtRef<Class> java_lang_reflect_Method(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700334 CHECK(java_lang_reflect_Method.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700335 java_lang_reflect_Method->SetObjectSize(sizeof(Method));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700336 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700337 java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700338 Method::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700339
340 // now we can use FindSystemClass
341
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700342 // run char class through InitializePrimitiveClass to finish init
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700343 InitializePrimitiveClass(char_class.get(), "C", Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700344 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700345
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700346 // Object and String need to be rerun through FindSystemClass to finish init
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700347 java_lang_Object->SetStatus(Class::kStatusNotReady);
348 Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700349 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700350 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(Object));
351 java_lang_String->SetStatus(Class::kStatusNotReady);
352 Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700353 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700354 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
355
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700356 // Setup the primitive array type classes - can't be done until Object has a vtable
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700357 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
358 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
359
360 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
361 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
362
363 Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700364 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700365
366 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
367 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
368
369 Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700370 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700371
372 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
373 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
374
375 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
376 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
377
378 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
379 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
380
Elliott Hughes418d20f2011-09-22 14:00:39 -0700381 Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700382 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700383
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700384 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700385 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700386
387 // Setup the single, global copies of "interfaces" and "iftable"
388 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
389 CHECK(java_lang_Cloneable != NULL);
390 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
391 CHECK(java_io_Serializable != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700392 // We assume that Cloneable/Serializable don't have superinterfaces --
393 // normally we'd have to crawl up and explicitly list all of the
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700394 // supers as well.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800395 array_iftable_->Set(0, AllocInterfaceEntry(java_lang_Cloneable));
396 array_iftable_->Set(1, AllocInterfaceEntry(java_io_Serializable));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700397
Elliott Hughes418d20f2011-09-22 14:00:39 -0700398 // Sanity check Class[] and Object[]'s interfaces
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800399 ClassHelper kh(class_array_class.get(), this);
400 CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
401 CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
402 kh.ChangeClass(object_array_class.get());
403 CHECK_EQ(java_lang_Cloneable, kh.GetInterface(0));
404 CHECK_EQ(java_io_Serializable, kh.GetInterface(1));
Elliott Hughes80609252011-09-23 17:24:51 -0700405 // run Class, Constructor, Field, and Method through FindSystemClass.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700406 // this initializes their dex_cache_ fields and register them in classes_.
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700407 Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700408 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700409
Elliott Hughes80609252011-09-23 17:24:51 -0700410 java_lang_reflect_Constructor->SetStatus(Class::kStatusNotReady);
411 Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700412 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700413
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700414 java_lang_reflect_Field->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700415 Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700416 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700417
418 java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700419 Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700420 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700421
Ian Rogers466bb252011-10-14 03:29:56 -0700422 // End of special init trickery, subsequent classes may be loaded via FindSystemClass
423
424 // Create java.lang.reflect.Proxy root
425 Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
426 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
427
Brian Carlstrom1f870082011-08-23 16:02:11 -0700428 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700429 Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
430 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700431 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700432 java_lang_ref_FinalizerReference->SetAccessFlags(
433 java_lang_ref_FinalizerReference->GetAccessFlags() |
434 kAccClassIsReference | kAccClassIsFinalizerReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700435 Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700436 java_lang_ref_PhantomReference->SetAccessFlags(
437 java_lang_ref_PhantomReference->GetAccessFlags() |
438 kAccClassIsReference | kAccClassIsPhantomReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700439 Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700440 java_lang_ref_SoftReference->SetAccessFlags(
441 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700442 Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700443 java_lang_ref_WeakReference->SetAccessFlags(
444 java_lang_ref_WeakReference->GetAccessFlags() |
445 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700446
Brian Carlstromaded5f72011-10-07 17:15:04 -0700447 // Setup the ClassLoaders, verifying the object_size_
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700448 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
Brian Carlstromaded5f72011-10-07 17:15:04 -0700449 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700450 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
451
452 Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
453 CHECK_EQ(dalvik_system_BaseDexClassLoader->GetObjectSize(), sizeof(BaseDexClassLoader));
454 SetClassRoot(kDalvikSystemBaseDexClassLoader, dalvik_system_BaseDexClassLoader);
455
456 Class* dalvik_system_PathClassLoader = FindSystemClass("Ldalvik/system/PathClassLoader;");
457 CHECK_EQ(dalvik_system_PathClassLoader->GetObjectSize(), sizeof(PathClassLoader));
458 SetClassRoot(kDalvikSystemPathClassLoader, dalvik_system_PathClassLoader);
459 PathClassLoader::SetClass(dalvik_system_PathClassLoader);
460
jeffhao8cd6dda2012-02-22 10:15:34 -0800461 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
462 // java.lang.StackTraceElement as a convenience
Ian Rogers5167c972012-02-03 10:41:20 -0800463 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
464 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800465 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700466 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
467 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700468 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700469
Brian Carlstroma663ea52011-08-19 23:33:41 -0700470 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700471
Brian Carlstroma004aa92012-02-08 18:05:09 -0800472 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700473}
474
475void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800476 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700477
478 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700479 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700480 // as the types of the field can't be resolved prior to the runtime being
481 // fully initialized
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700482 Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700483 Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700484 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
485
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800486 Heap* heap = Runtime::Current()->GetHeap();
487 heap->SetWellKnownClasses(java_lang_ref_FinalizerReference, java_lang_ref_ReferenceQueue);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700488
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800489 const DexFile& java_lang_dex = FindDexFile(java_lang_ref_Reference->GetDexCache());
490
Brian Carlstrom16192862011-09-12 17:50:06 -0700491 Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800492 FieldHelper fh(pendingNext, this);
493 CHECK_STREQ(fh.GetName(), "pendingNext");
494 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
495 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700496
497 Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800498 fh.ChangeField(queue);
499 CHECK_STREQ(fh.GetName(), "queue");
500 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
501 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700502
503 Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800504 fh.ChangeField(queueNext);
505 CHECK_STREQ(fh.GetName(), "queueNext");
506 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
507 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700508
509 Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800510 fh.ChangeField(referent);
511 CHECK_STREQ(fh.GetName(), "referent");
512 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
513 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700514
515 Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800516 fh.ChangeField(zombie);
517 CHECK_STREQ(fh.GetName(), "zombie");
518 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
519 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700520
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800521 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700522 queue->GetOffset(),
523 queueNext->GetOffset(),
524 pendingNext->GetOffset(),
525 zombie->GetOffset());
526
Brian Carlstroma663ea52011-08-19 23:33:41 -0700527 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700528 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700529 ClassRoot class_root = static_cast<ClassRoot>(i);
530 Class* klass = GetClassRoot(class_root);
531 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700532 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700533 // note SetClassRoot does additional validation.
534 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700535 }
536
Elliott Hughes92f14b22011-10-06 12:29:54 -0700537 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700538
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700539 // disable the slow paths in FindClass and CreatePrimitiveClass now
540 // that Object, Class, and Object[] are setup
541 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700542
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800543 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700544}
545
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700546void ClassLinker::RunRootClinits() {
547 Thread* self = Thread::Current();
548 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
549 Class* c = GetClassRoot(ClassRoot(i));
550 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700551 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -0700552 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700553 }
554 }
555}
556
Brian Carlstromd601af82012-01-06 10:15:19 -0800557bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
558 int oat_fd,
559 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800560 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700561 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800562 const char* dex2oat = dex2oat_string.c_str();
563
Brian Carlstroma004aa92012-02-08 18:05:09 -0800564 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800565
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800566 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800567 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700568 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800569 const char* boot_image_option = boot_image_option_string.c_str();
570
571 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800572 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800573 const char* dex_file_option = dex_file_option_string.c_str();
574
Brian Carlstromd601af82012-01-06 10:15:19 -0800575 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800576 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800577 const char* oat_fd_option = oat_fd_option_string.c_str();
578
Brian Carlstroma004aa92012-02-08 18:05:09 -0800579 std::string oat_location_option_string("--oat-location=");
580 oat_location_option_string += oat_cache_filename;
581 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800582
jeffhao262bf462011-10-20 18:36:32 -0700583 // fork and exec dex2oat
584 pid_t pid = fork();
585 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800586 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800587
588 // change process groups, so we don't get reaped by ProcessManager
589 setpgid(0, 0);
590
jeffhao10037c82012-01-23 15:06:23 -0800591 VLOG(class_linker) << dex2oat
592 << " --runtime-arg -Xms64m"
593 << " --runtime-arg -Xmx64m"
594 << " --runtime-arg -classpath"
595 << " --runtime-arg " << class_path
596 << " " << boot_image_option
597 << " " << dex_file_option
598 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800599 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800600
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800601 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700602 "--runtime-arg", "-Xms64m",
603 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500604 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800605 "--runtime-arg", class_path,
606 boot_image_option,
607 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800608 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800609 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700610 NULL);
611
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800612 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800613 return false;
jeffhao262bf462011-10-20 18:36:32 -0700614 } else {
615 // wait for dex2oat to finish
616 int status;
617 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
618 if (got_pid != pid) {
619 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800620 return false;
jeffhao262bf462011-10-20 18:36:32 -0700621 }
622 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800623 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
624 return false;
jeffhao262bf462011-10-20 18:36:32 -0700625 }
626 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800627 return true;
jeffhao262bf462011-10-20 18:36:32 -0700628}
629
Brian Carlstrom866c8622012-01-06 16:35:13 -0800630void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
631 MutexLock mu(dex_lock_);
632 RegisterOatFileLocked(oat_file);
633}
634
635void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
636 dex_lock_.AssertHeld();
637 oat_files_.push_back(&oat_file);
638}
639
Ian Rogers30fab402012-01-23 15:43:46 -0800640OatFile* ClassLinker::OpenOat(const ImageSpace* space) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700641 MutexLock mu(dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700642 const Runtime* runtime = Runtime::Current();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700643 const ImageHeader& image_header = space->GetImageHeader();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800644 // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
645 // check the down cast
646 String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700647 std::string oat_filename;
648 oat_filename += runtime->GetHostPrefix();
649 oat_filename += oat_location->ToModifiedUtf8();
Logan Chien0c717dd2012-03-28 18:31:07 +0800650 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename,
651 image_header.GetOatBegin(),
652 OatFile::kRelocNone);
Ian Rogers30fab402012-01-23 15:43:46 -0800653 VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700654 if (oat_file == NULL) {
Brian Carlstroma9f19782011-10-13 00:14:47 -0700655 LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700656 return NULL;
657 }
658 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
659 uint32_t image_oat_checksum = image_header.GetOatChecksum();
660 if (oat_checksum != image_oat_checksum) {
Brian Carlstrom866c8622012-01-06 16:35:13 -0800661 LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700662 << " to expected oat checksum " << std::hex << oat_checksum
663 << " in image";
664 return NULL;
665 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800666 RegisterOatFileLocked(*oat_file);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800667 VLOG(startup) << "ClassLinker::OpenOat exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700668 return oat_file;
669}
670
Brian Carlstromae826982011-11-09 01:33:42 -0800671const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800672 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800673}
674
Brian Carlstroma004aa92012-02-08 18:05:09 -0800675const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800676 for (size_t i = 0; i < oat_files_.size(); i++) {
677 const OatFile* oat_file = oat_files_[i];
678 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800679 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800680 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800681 return oat_file;
682 }
683 }
684 return NULL;
685}
686
Brian Carlstromd601af82012-01-06 10:15:19 -0800687class LockedFd {
688 public:
689 static LockedFd* CreateAndLock(std::string& name, mode_t mode) {
690 int fd = open(name.c_str(), O_CREAT | O_RDWR, mode);
691 if (fd == -1) {
692 PLOG(ERROR) << "Failed to open file '" << name << "'";
693 return NULL;
694 }
695 fchmod(fd, mode);
696
697 LOG(INFO) << "locking file " << name << " (fd=" << fd << ")";
698 // try to lock non-blocking so we can log if we need may need to block
699 int result = flock(fd, LOCK_EX | LOCK_NB);
700 if (result == -1) {
701 LOG(WARNING) << "sleeping while locking file " << name;
702 // retry blocking
703 result = flock(fd, LOCK_EX);
704 }
705 if (result == -1) {
706 PLOG(ERROR) << "Failed to lock file '" << name << "'";
707 close(fd);
708 return NULL;
709 }
710 return new LockedFd(fd);
711 }
712
713 int GetFd() const {
714 return fd_;
715 }
716
717 ~LockedFd() {
718 if (fd_ != -1) {
719 int result = flock(fd_, LOCK_UN);
720 if (result == -1) {
721 PLOG(WARNING) << "flock(" << fd_ << ", LOCK_UN) failed";
722 }
723 close(fd_);
724 }
725 }
726
727 private:
728 explicit LockedFd(int fd) : fd_(fd) {}
729
730 int fd_;
731};
732
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800733static const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
734 uint32_t dex_location_checksum,
735 const std::string& oat_location) {
Logan Chien0c717dd2012-03-28 18:31:07 +0800736 UniquePtr<OatFile> oat_file(
737 OatFile::Open(oat_location, oat_location, NULL, OatFile::kRelocAll));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800738 if (oat_file.get() == NULL) {
739 return NULL;
740 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700741 Runtime* runtime = Runtime::Current();
742 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
743 if (oat_file->GetOatHeader().GetImageFileLocationChecksum() != image_header.GetOatChecksum()) {
744 return NULL;
745 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800746 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
747 if (oat_dex_file == NULL) {
748 return NULL;
749 }
750 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
751 return NULL;
752 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700753 runtime->GetClassLinker()->RegisterOatFile(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800754 return oat_dex_file->OpenDexFile();
755}
756
757const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
758 const std::string& oat_location) {
759 uint32_t dex_location_checksum;
760 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
761 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
762 return NULL;
763 }
764
765 // Check if we already have an up-to-date output file
766 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
767 dex_location_checksum,
768 oat_location);
769 if (dex_file != NULL) {
770 return dex_file;
771 }
772
773 // Generate the output oat file for the dex file
774 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
775 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
776 if (file.get() == NULL) {
777 LOG(ERROR) << "Failed to create oat file: " << oat_location;
778 return NULL;
779 }
780 if (!class_linker->GenerateOatFile(dex_location, file->Fd(), oat_location)) {
781 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
782 return NULL;
783 }
784 // Open the oat from file descriptor we passed to GenerateOatFile
785 if (lseek(file->Fd(), 0, SEEK_SET) != 0) {
786 LOG(ERROR) << "Failed to seek to start of generated oat file: " << oat_location;
787 return NULL;
788 }
Logan Chien0c717dd2012-03-28 18:31:07 +0800789 const OatFile* oat_file =
790 OatFile::Open(*file.get(), oat_location, NULL, OatFile::kRelocAll);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800791 if (oat_file == NULL) {
792 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
793 return NULL;
794 }
795 class_linker->RegisterOatFile(*oat_file);
796 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
797 if (oat_dex_file == NULL) {
798 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
799 return NULL;
800 }
801 return oat_dex_file->OpenDexFile();
802}
803
804const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700805 MutexLock mu(dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800806
Brian Carlstroma004aa92012-02-08 18:05:09 -0800807 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800808 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800809 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800810 }
811
Brian Carlstroma004aa92012-02-08 18:05:09 -0800812 // Look for an existing file next to dex, assuming its up-to-date if found
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800813 std::string oat_filename(OatFile::DexFilenameToOatFilename(dex_location));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800814 const OatFile* oat_file = FindOatFileFromOatLocation(oat_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800815 if (oat_file != NULL) {
816 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800817 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
818 return oat_dex_file->OpenDexFile();
819 }
820 // Look for an existing file in the art-cache, validating the result if found
821 // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
822 std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
823 oat_file = FindOatFileFromOatLocation(cache_location);
824 if (oat_file != NULL) {
825 uint32_t dex_location_checksum;
826 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
827 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
828 return NULL;
829 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700830
831 Runtime* runtime = Runtime::Current();
832 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
833 uint32_t image_checksum = image_header.GetOatChecksum();
834 bool image_check = (oat_file->GetOatHeader().GetImageFileLocationChecksum() == image_checksum);
835
Brian Carlstroma004aa92012-02-08 18:05:09 -0800836 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
837 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700838 bool dex_check = (dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum());
839
840 if (image_check && dex_check) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800841 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Elliott Hughesed6d78e2011-10-25 17:35:14 -0700842 }
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700843 if (!image_check) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700844 std::string image_file(image_header.GetImageRoot(
845 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
846 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
847 << " checksum ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
848 << ") mismatch with " << image_file
849 << " (" << std::hex << image_checksum << ")--- regenerating";
850 }
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700851 if (!dex_check) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700852 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
853 << " checksum ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
854 << ") mismatch with " << dex_location
855 << " (" << std::hex << dex_location_checksum << ")--- regenerating";
856 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800857 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700858 PLOG(FATAL) << "Failed to remove obsolete .oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800859 }
jeffhao262bf462011-10-20 18:36:32 -0700860 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800861 LOG(INFO) << "Failed to open oat file from " << oat_filename << " or " << cache_location << ".";
862
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800863 // Try to generate oat file if it wasn't found or was obsolete.
864 std::string oat_cache_filename(GetArtCacheFilenameOrDie(oat_filename));
865 return FindOrCreateOatFileForDexLocation(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700866}
867
Brian Carlstromae826982011-11-09 01:33:42 -0800868const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700869 for (size_t i = 0; i < oat_files_.size(); i++) {
870 const OatFile* oat_file = oat_files_[i];
871 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800872 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700873 return oat_file;
874 }
875 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700876 return NULL;
877}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700878
Brian Carlstromae826982011-11-09 01:33:42 -0800879const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800880 MutexLock mu(dex_lock_);
881 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
882 if (oat_file != NULL) {
883 return oat_file;
884 }
885
Logan Chien0c717dd2012-03-28 18:31:07 +0800886 oat_file = OatFile::Open(oat_location, oat_location, NULL,
887 OatFile::kRelocAll);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700888 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800889 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700890 }
Brian Carlstromae826982011-11-09 01:33:42 -0800891 CHECK(oat_file != NULL) << oat_location;
jeffhaof6174e82012-01-31 16:14:17 -0800892 RegisterOatFileLocked(*oat_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700893 return oat_file;
894}
895
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700896void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800897 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700898 CHECK(!init_done_);
899
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800900 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700901 ImageSpace* space = heap->GetImageSpace();
902 OatFile* oat_file = OpenOat(space);
903 CHECK(oat_file != NULL) << "Failed to open oat file for image";
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700904 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationChecksum(), 0U);
905 CHECK(oat_file->GetOatHeader().GetImageFileLocation() == "");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700906 Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
907 ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700908
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700909 // Special case of setting up the String class early so that we can test arbitrary objects
910 // as being Strings or not
911 Class* java_lang_String = space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)
912 ->AsObjectArray<Class>()->Get(kJavaLangString);
913 String::SetClass(java_lang_String);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800914
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700915 CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
916 static_cast<uint32_t>(dex_caches->GetLength()));
917 for (int i = 0; i < dex_caches->GetLength(); i++) {
918 SirtRef<DexCache> dex_cache(dex_caches->Get(i));
919 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
920 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
921 const DexFile* dex_file = oat_dex_file->OpenDexFile();
922 if (dex_file == NULL) {
923 LOG(FATAL) << "Failed to open dex file " << dex_file_location
924 << " from within oat file " << oat_file->GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700925 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700926
927 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
928
929 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700930 }
931
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800932 HeapBitmap* heap_bitmap = heap->GetLiveBits();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700933 DCHECK(heap_bitmap != NULL);
934
Brian Carlstroma663ea52011-08-19 23:33:41 -0700935 // reinit clases_ table
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700936 heap_bitmap->Walk(InitFromImageCallback, this);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700937
938 // reinit class_roots_
Ian Rogers30fab402012-01-23 15:43:46 -0800939 Object* class_roots_object =
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700940 heap->GetImageSpace()->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots);
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700941 class_roots_ = class_roots_object->AsObjectArray<Class>();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700942
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800943 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -0700944 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
945 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800946 // String class root was set above
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700947 Field::SetClass(GetClassRoot(kJavaLangReflectField));
Elliott Hughes80609252011-09-23 17:24:51 -0700948 Method::SetClasses(GetClassRoot(kJavaLangReflectConstructor), GetClassRoot(kJavaLangReflectMethod));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700949 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
950 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
951 CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
952 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
953 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
954 IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
955 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
956 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700957 PathClassLoader::SetClass(GetClassRoot(kDalvikSystemPathClassLoader));
Ian Rogers5167c972012-02-03 10:41:20 -0800958 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700959 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700960
961 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700962
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800963 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700964}
965
Brian Carlstrom78128a62011-09-15 17:21:19 -0700966void ClassLinker::InitFromImageCallback(Object* obj, void* arg) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700967 DCHECK(obj != NULL);
968 DCHECK(arg != NULL);
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700969 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700970
Elliott Hughesdbb40792011-11-18 17:05:22 -0800971 if (obj->GetClass()->IsStringClass()) {
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700972 class_linker->intern_table_->RegisterStrong(obj->AsString());
Brian Carlstromc74255f2011-09-11 22:47:39 -0700973 return;
974 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700975 if (obj->IsClass()) {
976 // restore class to ClassLinker::classes_ table
977 Class* klass = obj->AsClass();
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800978 ClassHelper kh(klass, class_linker);
Brian Carlstrom07bb8552012-01-18 22:10:50 -0800979 Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
980 DCHECK(existing == NULL) << kh.GetDescriptor();
Brian Carlstroma663ea52011-08-19 23:33:41 -0700981 return;
982 }
Brian Carlstroma663ea52011-08-19 23:33:41 -0700983}
984
985// Keep in sync with InitCallback. Anything we visit, we need to
986// reinit references to when reinitializing a ClassLinker from a
987// mapped image.
Elliott Hughes410c0c82011-09-01 17:58:25 -0700988void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
989 visitor(class_roots_, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700990
991 for (size_t i = 0; i < dex_caches_.size(); i++) {
Elliott Hughes410c0c82011-09-01 17:58:25 -0700992 visitor(dex_caches_[i], arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700993 }
994
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700995 {
Brian Carlstrom47d237a2011-10-18 15:08:33 -0700996 MutexLock mu(classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700997 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700998 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -0700999 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001000 }
Ian Rogers5d76c432011-10-31 21:42:49 -07001001 // Note. we deliberately ignore the class roots in the image (held in image_classes_)
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001002 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001003
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001004 visitor(array_iftable_, arg);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001005}
1006
Elliott Hughesa2155262011-11-16 16:26:58 -08001007void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
1008 MutexLock mu(classes_lock_);
1009 typedef Table::const_iterator It; // TODO: C++0x auto
1010 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
1011 if (!visitor(it->second, arg)) {
1012 return;
1013 }
1014 }
1015 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
1016 if (!visitor(it->second, arg)) {
1017 return;
1018 }
1019 }
1020}
1021
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001022ClassLinker::~ClassLinker() {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001023 String::ResetClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001024 Field::ResetClass();
Elliott Hughes80609252011-09-23 17:24:51 -07001025 Method::ResetClasses();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001026 BooleanArray::ResetArrayClass();
1027 ByteArray::ResetArrayClass();
1028 CharArray::ResetArrayClass();
1029 DoubleArray::ResetArrayClass();
1030 FloatArray::ResetArrayClass();
1031 IntArray::ResetArrayClass();
1032 LongArray::ResetArrayClass();
1033 ShortArray::ResetArrayClass();
1034 PathClassLoader::ResetClass();
Ian Rogers5167c972012-02-03 10:41:20 -08001035 Throwable::ResetClass();
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001036 StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001037 STLDeleteElements(&boot_class_path_);
1038 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001039}
1040
1041DexCache* ClassLinker::AllocDexCache(const DexFile& dex_file) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001042 SirtRef<DexCache> dex_cache(down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::LengthAsArray())));
1043 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001044 return NULL;
1045 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001046 SirtRef<String> location(intern_table_->InternStrong(dex_file.GetLocation().c_str()));
1047 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001048 return NULL;
1049 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001050 SirtRef<ObjectArray<String> > strings(AllocObjectArray<String>(dex_file.NumStringIds()));
1051 if (strings.get() == NULL) {
1052 return NULL;
1053 }
1054 SirtRef<ObjectArray<Class> > types(AllocClassArray(dex_file.NumTypeIds()));
1055 if (types.get() == NULL) {
1056 return NULL;
1057 }
1058 SirtRef<ObjectArray<Method> > methods(AllocObjectArray<Method>(dex_file.NumMethodIds()));
1059 if (methods.get() == NULL) {
1060 return NULL;
1061 }
1062 SirtRef<ObjectArray<Field> > fields(AllocObjectArray<Field>(dex_file.NumFieldIds()));
1063 if (fields.get() == NULL) {
1064 return NULL;
1065 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001066 SirtRef<ObjectArray<StaticStorageBase> > initialized_static_storage(AllocObjectArray<StaticStorageBase>(dex_file.NumTypeIds()));
1067 if (initialized_static_storage.get() == NULL) {
1068 return NULL;
1069 }
1070
1071 dex_cache->Init(location.get(),
1072 strings.get(),
1073 types.get(),
1074 methods.get(),
1075 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001076 initialized_static_storage.get());
1077 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001078}
1079
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001080InterfaceEntry* ClassLinker::AllocInterfaceEntry(Class* interface) {
1081 DCHECK(interface->IsInterface());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001082 SirtRef<ObjectArray<Object> > array(AllocObjectArray<Object>(InterfaceEntry::LengthAsArray()));
1083 SirtRef<InterfaceEntry> interface_entry(down_cast<InterfaceEntry*>(array.get()));
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001084 interface_entry->SetInterface(interface);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001085 return interface_entry.get();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001086}
1087
Brian Carlstrom4873d462011-08-21 15:23:39 -07001088Class* ClassLinker::AllocClass(Class* java_lang_Class, size_t class_size) {
1089 DCHECK_GE(class_size, sizeof(Class));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001090 Heap* heap = Runtime::Current()->GetHeap();
1091 SirtRef<Class> klass(heap->AllocObject(java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001092 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001093 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001094 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001095}
1096
Brian Carlstrom4873d462011-08-21 15:23:39 -07001097Class* ClassLinker::AllocClass(size_t class_size) {
1098 return AllocClass(GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001099}
1100
Jesse Wilson35baaab2011-08-10 16:18:03 -04001101Field* ClassLinker::AllocField() {
Brian Carlstrom1f870082011-08-23 16:02:11 -07001102 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject());
Brian Carlstroma0808032011-07-18 00:39:23 -07001103}
1104
1105Method* ClassLinker::AllocMethod() {
Brian Carlstrom1f870082011-08-23 16:02:11 -07001106 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001107}
1108
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001109ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(size_t length) {
1110 return ObjectArray<StackTraceElement>::Alloc(
1111 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1112 length);
1113}
1114
Brian Carlstromaded5f72011-10-07 17:15:04 -07001115Class* EnsureResolved(Class* klass) {
1116 DCHECK(klass != NULL);
1117 // Wait for the class if it has not already been linked.
Carl Shapirob5573532011-07-12 18:22:59 -07001118 Thread* self = Thread::Current();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001119 if (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001120 ObjectLock lock(klass);
1121 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001122 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001123 self->ThrowNewException("Ljava/lang/ClassCircularityError;",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001124 PrettyDescriptor(klass).c_str());
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001125 klass->SetStatus(Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001126 return NULL;
1127 }
1128 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001129 while (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001130 lock.Wait();
1131 }
1132 }
1133 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001134 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001135 return NULL;
1136 }
1137 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001138 CHECK(klass->IsResolved()) << PrettyClass(klass);
1139 CHECK(!self->IsExceptionPending())
1140 << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException());
1141 return klass;
1142}
1143
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001144Class* ClassLinker::FindSystemClass(const char* descriptor) {
1145 return FindClass(descriptor, NULL);
1146}
1147
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001148Class* ClassLinker::FindClass(const char* descriptor, const ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001149 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001150 Thread* self = Thread::Current();
1151 DCHECK(self != NULL);
1152 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001153 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001154 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1155 // for primitive classes that aren't backed by dex files.
1156 return FindPrimitiveClass(descriptor[0]);
1157 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001158 // Find the class in the loaded classes table.
1159 Class* klass = LookupClass(descriptor, class_loader);
1160 if (klass != NULL) {
1161 return EnsureResolved(klass);
1162 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001163 // Class is not yet loaded.
1164 if (descriptor[0] == '[') {
1165 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001166
Jesse Wilson47daf872011-11-23 11:42:45 -05001167 } else if (class_loader == NULL) {
1168 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1169 if (pair.second != NULL) {
1170 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1171 }
1172
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001173 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001174 // first try the boot class path
1175 Class* system_class = FindSystemClass(descriptor);
1176 if (system_class != NULL) {
1177 return system_class;
1178 }
1179 CHECK(self->IsExceptionPending());
1180 self->ClearException();
1181
1182 // next try the compile time class path
Brian Carlstromaded5f72011-10-07 17:15:04 -07001183 const std::vector<const DexFile*>& class_path
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001184 = Runtime::Current()->GetCompileTimeClassPath(class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001185 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001186 if (pair.second != NULL) {
1187 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001188 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001189
1190 } else {
Elliott Hughes95572412011-12-13 18:14:20 -08001191 std::string class_name_string(DescriptorToDot(descriptor));
Elliott Hughes34e06962012-04-09 13:55:55 -07001192 ScopedThreadStateChange tsc(self, kNative);
Elliott Hughes748382f2012-01-26 18:07:38 -08001193 JNIEnv* env = self->GetJniEnv();
Jesse Wilson47daf872011-11-23 11:42:45 -05001194 ScopedLocalRef<jclass> c(env, AddLocalReference<jclass>(env, GetClassRoot(kJavaLangClassLoader)));
1195 CHECK(c.get() != NULL);
1196 // TODO: cache method?
1197 jmethodID mid = env->GetMethodID(c.get(), "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
1198 CHECK(mid != NULL);
1199 ScopedLocalRef<jobject> class_name_object(env, env->NewStringUTF(class_name_string.c_str()));
1200 if (class_name_object.get() == NULL) {
1201 return NULL;
1202 }
1203 ScopedLocalRef<jobject> class_loader_object(env, AddLocalReference<jobject>(env, class_loader));
Elliott Hughes9c750f92012-04-05 12:07:59 -07001204 CHECK(class_loader_object.get() != NULL);
Ian Rogers761bfa82012-01-11 10:14:05 -08001205 ScopedLocalRef<jobject> result(env, env->CallObjectMethod(class_loader_object.get(), mid,
1206 class_name_object.get()));
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001207 if (env->ExceptionCheck()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001208 // If the ClassLoader threw, pass that exception up.
1209 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001210 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001211 // broken loader - throw NPE to be compatible with Dalvik
1212 ThrowNullPointerException("ClassLoader.loadClass returned null for %s",
1213 class_name_string.c_str());
1214 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001215 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08001216 // success, return Class*
Ian Rogers6b0870d2011-12-15 19:38:12 -08001217 return Decode<Class*>(env, result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001218 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001219 }
1220
Elliott Hughes82914b62012-04-09 15:56:29 -07001221 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001222 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001223}
1224
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001225Class* ClassLinker::DefineClass(const StringPiece& descriptor,
Brian Carlstromaded5f72011-10-07 17:15:04 -07001226 const ClassLoader* class_loader,
1227 const DexFile& dex_file,
1228 const DexFile::ClassDef& dex_class_def) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001229 SirtRef<Class> klass(NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001230 // Load the class from the dex file.
1231 if (!init_done_) {
1232 // finish up init of hand crafted class_roots_
1233 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001234 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001235 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001236 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001237 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001238 klass.reset(GetClassRoot(kJavaLangString));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001239 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001240 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001241 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001242 klass.reset(GetClassRoot(kJavaLangReflectField));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001243 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001244 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001245 } else {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001246 klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001247 }
1248 } else {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001249 klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001250 }
1251 klass->SetDexCache(FindDexCache(dex_file));
1252 LoadClass(dex_file, dex_class_def, klass, class_loader);
1253 // Check for a pending exception during load
1254 Thread* self = Thread::Current();
1255 if (self->IsExceptionPending()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001256 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001257 return NULL;
1258 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001259 ObjectLock lock(klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001260 klass->SetClinitThreadId(self->GetTid());
1261 // Add the newly loaded class to the loaded classes table.
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001262 SirtRef<Class> existing(InsertClass(descriptor, klass.get(), false));
1263 if (existing.get() != NULL) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001264 // We failed to insert because we raced with another thread.
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001265 return EnsureResolved(existing.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001266 }
1267 // Finish loading (if necessary) by finding parents
1268 CHECK(!klass->IsLoaded());
1269 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1270 // Loading failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001271 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001272 lock.NotifyAll();
1273 return NULL;
1274 }
1275 CHECK(klass->IsLoaded());
1276 // Link the class (if necessary)
1277 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001278 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001279 // Linking failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001280 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001281 lock.NotifyAll();
1282 return NULL;
1283 }
1284 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001285
1286 /*
1287 * We send CLASS_PREPARE events to the debugger from here. The
1288 * definition of "preparation" is creating the static fields for a
1289 * class and initializing them to the standard default values, but not
1290 * executing any code (that comes later, during "initialization").
1291 *
1292 * We did the static preparation in LinkClass.
1293 *
1294 * The class has been prepared and resolved but possibly not yet verified
1295 * at this point.
1296 */
1297 Dbg::PostClassPrepare(klass.get());
1298
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001299 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001300}
1301
Brian Carlstrom4873d462011-08-21 15:23:39 -07001302// Precomputes size that will be needed for Class, matching LinkStaticFields
1303size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1304 const DexFile::ClassDef& dex_class_def) {
1305 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001306 size_t num_ref = 0;
1307 size_t num_32 = 0;
1308 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001309 if (class_data != NULL) {
1310 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1311 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001312 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001313 char c = descriptor[0];
1314 if (c == 'L' || c == '[') {
1315 num_ref++;
1316 } else if (c == 'J' || c == 'D') {
1317 num_64++;
1318 } else {
1319 num_32++;
1320 }
1321 }
1322 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001323 // start with generic class data
1324 size_t size = sizeof(Class);
1325 // follow with reference fields which must be contiguous at start
1326 size += (num_ref * sizeof(uint32_t));
1327 // if there are 64-bit fields to add, make sure they are aligned
1328 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
1329 if (num_32 != 0) {
1330 // use an available 32-bit field for padding
1331 num_32--;
1332 }
1333 size += sizeof(uint32_t); // either way, we are adding a word
1334 DCHECK_EQ(size, RoundUp(size, 8));
1335 }
1336 // tack on any 64-bit fields now that alignment is assured
1337 size += (num_64 * sizeof(uint64_t));
1338 // tack on any remaining 32-bit fields
1339 size += (num_32 * sizeof(uint32_t));
1340 return size;
1341}
1342
Ian Rogers19846512012-02-24 11:42:47 -08001343const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1344 DCHECK(descriptor != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001345 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1346 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1347 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1348 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1349 uint32_t class_def_index;
1350 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1351 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1352 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1353 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1354 return oat_class;
1355}
1356
TDYa12785321912012-04-01 15:24:56 -07001357const OatFile::OatMethod ClassLinker::GetOatMethodFor(const Method* method) {
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);
TDYa12785321912012-04-01 15:24:56 -07001383 return oat_class->GetOatMethod(oat_method_index);
1384}
1385
1386// Special case to get oat code without overwriting a trampoline.
1387const void* ClassLinker::GetOatCodeFor(const Method* method) {
TDYa127ccffd9e2012-04-08 14:37:03 -07001388 CHECK(Runtime::Current()->IsCompiler() || method->GetDeclaringClass()->IsInitializing());
TDYa12785321912012-04-01 15:24:56 -07001389 return GetOatMethodFor(method).GetCode();
1390}
1391
1392void ClassLinker::LinkOatCodeFor(Method* method) {
1393 Class* declaring_class = method->GetDeclaringClass();
1394 ClassHelper kh(declaring_class);
1395 const OatFile* oat_file = FindOpenedOatFileForDexFile(kh.GetDexFile());
1396 if (oat_file != NULL) {
1397 // NOTE: We have to check the availability of OatFile first. Because
1398 // GetOatMethodFor(...) will try to find the OatFile and there's
1399 // an assert in GetOatMethodFor(...). Besides, due to the return
1400 // type of OatClass::GetOatMethod(...), we can't return a failure value
1401 // back.
1402
1403 // TODO: Remove this workaround.
1404 GetOatMethodFor(method).LinkMethodPointers(method);
1405 }
Ian Rogers19846512012-02-24 11:42:47 -08001406}
1407
1408void ClassLinker::FixupStaticTrampolines(Class* klass) {
1409 ClassHelper kh(klass);
1410 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1411 CHECK(dex_class_def != NULL);
1412 const DexFile& dex_file = kh.GetDexFile();
1413 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1414 if (class_data == NULL) {
1415 return; // no fields or methods - for example a marker interface
1416 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001417 if (!Runtime::Current()->IsStarted() || Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001418 // OAT file unavailable
1419 return;
1420 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001421 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1422 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001423 ClassDataItemIterator it(dex_file, class_data);
1424 // Skip fields
1425 while (it.HasNextStaticField()) {
1426 it.Next();
1427 }
1428 while (it.HasNextInstanceField()) {
1429 it.Next();
1430 }
1431 size_t method_index = 0;
1432 // Link the code of methods skipped by LinkCode
1433 const void* trampoline = Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData();
1434 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1435 Method* method = klass->GetDirectMethod(i);
jeffhaob5e81852012-03-12 11:15:45 -07001436 if (Runtime::Current()->IsMethodTracingActive()) {
1437 Trace* tracer = Runtime::Current()->GetTracer();
1438 if (tracer->GetSavedCodeFromMap(method) == trampoline) {
1439 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1440 tracer->ResetSavedCode(method);
1441 method->SetCode(code);
1442 tracer->SaveAndUpdateCode(method);
1443 }
1444 } else if (method->GetCode() == trampoline) {
Ian Rogers19846512012-02-24 11:42:47 -08001445 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1446 CHECK(code != NULL);
1447 method->SetCode(code);
1448 }
1449 method_index++;
1450 }
1451}
1452
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001453void LinkCode(SirtRef<Method>& method, const OatFile::OatClass* oat_class, uint32_t method_index) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001454 // Every kind of method should at least get an invoke stub from the oat_method.
1455 // non-abstract methods also get their code pointers.
1456 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstromae826982011-11-09 01:33:42 -08001457 oat_method.LinkMethodPointers(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001458
Ian Rogers19846512012-02-24 11:42:47 -08001459 Runtime* runtime = Runtime::Current();
Brian Carlstrom92827a52011-10-10 15:50:01 -07001460 if (method->IsAbstract()) {
Ian Rogers19846512012-02-24 11:42:47 -08001461 method->SetCode(runtime->GetAbstractMethodErrorStubArray()->GetData());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001462 return;
1463 }
Ian Rogers19846512012-02-24 11:42:47 -08001464
1465 if (method->IsStatic() && !method->IsConstructor()) {
1466 // For static methods excluding the class initializer, install the trampoline
1467 method->SetCode(runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData());
Ian Rogers0d6de042012-02-29 08:50:26 -08001468 }
1469 if (method->IsNative()) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001470 // unregistering restores the dlsym lookup stub
Ian Rogers19846512012-02-24 11:42:47 -08001471 method->UnregisterNative(Thread::Current());
jeffhao26c0a1a2012-01-17 16:28:33 -08001472 }
1473
1474 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhao26c0a1a2012-01-17 16:28:33 -08001475 Trace* tracer = Runtime::Current()->GetTracer();
jeffhaob5e81852012-03-12 11:15:45 -07001476 tracer->SaveAndUpdateCode(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001477 }
1478}
1479
Brian Carlstromf615a612011-07-23 12:50:34 -07001480void ClassLinker::LoadClass(const DexFile& dex_file,
1481 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001482 SirtRef<Class>& klass,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001483 const ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001484 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001485 CHECK(klass->GetDexCache() != NULL);
1486 CHECK_EQ(Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001487 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001488 CHECK(descriptor != NULL);
1489
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001490 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001491 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001492 // Make sure that none of our runtime-only flags are set.
1493 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001494 klass->SetAccessFlags(access_flags);
1495 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001496 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001497 klass->SetStatus(Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001498
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001499 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001500
Ian Rogers0571d352011-11-03 19:51:38 -07001501 // Load fields fields.
1502 const byte* class_data = dex_file.GetClassData(dex_class_def);
1503 if (class_data == NULL) {
1504 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001505 }
Ian Rogers0571d352011-11-03 19:51:38 -07001506 ClassDataItemIterator it(dex_file, class_data);
1507 if (it.NumStaticFields() != 0) {
1508 klass->SetSFields(AllocObjectArray<Field>(it.NumStaticFields()));
1509 }
1510 if (it.NumInstanceFields() != 0) {
1511 klass->SetIFields(AllocObjectArray<Field>(it.NumInstanceFields()));
1512 }
1513 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
1514 SirtRef<Field> sfield(AllocField());
1515 klass->SetStaticField(i, sfield.get());
1516 LoadField(dex_file, it, klass, sfield);
1517 }
1518 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
1519 SirtRef<Field> ifield(AllocField());
1520 klass->SetInstanceField(i, ifield.get());
1521 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001522 }
1523
Brian Carlstromf5822582012-03-19 22:34:31 -07001524 UniquePtr<const OatFile::OatClass> oat_class;
1525 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1526 oat_class.reset(GetOatClass(dex_file, descriptor));
1527 }
Ian Rogers19846512012-02-24 11:42:47 -08001528
Ian Rogers0571d352011-11-03 19:51:38 -07001529 // Load methods.
1530 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001531 // TODO: append direct methods to class object
Ian Rogers0571d352011-11-03 19:51:38 -07001532 klass->SetDirectMethods(AllocObjectArray<Method>(it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001533 }
Ian Rogers0571d352011-11-03 19:51:38 -07001534 if (it.NumVirtualMethods() != 0) {
1535 // TODO: append direct methods to class object
1536 klass->SetVirtualMethods(AllocObjectArray<Method>(it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001537 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001538 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001539 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
1540 SirtRef<Method> method(AllocMethod());
1541 klass->SetDirectMethod(i, method.get());
1542 LoadMethod(dex_file, it, klass, method);
1543 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001544 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001545 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001546 method->SetMethodIndex(class_def_method_index);
1547 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001548 }
1549 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
1550 SirtRef<Method> method(AllocMethod());
1551 klass->SetVirtualMethod(i, method.get());
1552 LoadMethod(dex_file, it, klass, method);
Ian Rogersfb6adba2012-03-04 21:51:51 -08001553 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001554 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001555 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001556 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001557 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001558 }
1559 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001560}
1561
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001562void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Ian Rogers0571d352011-11-03 19:51:38 -07001563 SirtRef<Class>& klass, SirtRef<Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001564 uint32_t field_idx = it.GetMemberIndex();
1565 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001566 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001567 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001568}
1569
Ian Rogers0571d352011-11-03 19:51:38 -07001570void ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
1571 SirtRef<Class>& klass, SirtRef<Method>& dst) {
Ian Rogers19846512012-02-24 11:42:47 -08001572 uint32_t dex_method_idx = it.GetMemberIndex();
1573 dst->SetDexMethodIndex(dex_method_idx);
1574 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001575 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001576
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001577
1578 StringPiece method_name(dex_file.GetMethodName(method_id));
1579 if (method_name == "<init>") {
Elliott Hughes80609252011-09-23 17:24:51 -07001580 dst->SetClass(GetClassRoot(kJavaLangReflectConstructor));
1581 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001582
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001583 if (method_name == "finalize") {
1584 // Create the prototype for a signature of "()V"
1585 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1586 if (void_string_id != NULL) {
1587 const DexFile::TypeId* void_type_id =
1588 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1589 if (void_type_id != NULL) {
1590 std::vector<uint16_t> no_args;
1591 const DexFile::ProtoId* finalizer_proto =
1592 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1593 if (finalizer_proto != NULL) {
1594 // We have the prototype in the dex file
1595 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1596 klass->SetFinalizable();
1597 } else {
1598 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1599 // The Enum class declares a "final" finalize() method to prevent subclasses from
1600 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1601 // subclasses, so we exclude it here.
1602 // We also want to avoid setting the flag on Object, where we know that finalize() is
1603 // empty.
1604 if (klass_descriptor != "Ljava/lang/Object;" &&
1605 klass_descriptor != "Ljava/lang/Enum;") {
1606 klass->SetFinalizable();
1607 }
1608 }
1609 }
1610 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001611 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001612 }
Ian Rogers0571d352011-11-03 19:51:38 -07001613 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001614 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001615
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001616 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001617 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001618 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001619 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001620}
1621
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001622void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001623 SirtRef<DexCache> dex_cache(AllocDexCache(dex_file));
1624 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001625}
1626
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001627void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
1628 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001629 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001630 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001631}
1632
Brian Carlstromaded5f72011-10-07 17:15:04 -07001633bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001634 dex_lock_.AssertHeld();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001635 for (size_t i = 0; i != dex_files_.size(); ++i) {
1636 if (dex_files_[i] == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001637 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001638 }
1639 }
1640 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001641}
1642
Brian Carlstromaded5f72011-10-07 17:15:04 -07001643bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001644 MutexLock mu(dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001645 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001646}
1647
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001648void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001649 dex_lock_.AssertHeld();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001650 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001651 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001652 dex_files_.push_back(&dex_file);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001653 dex_caches_.push_back(dex_cache.get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001654}
1655
Brian Carlstromaded5f72011-10-07 17:15:04 -07001656void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001657 {
1658 MutexLock mu(dex_lock_);
1659 if (IsDexFileRegisteredLocked(dex_file)) {
1660 return;
1661 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001662 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001663 // Don't alloc while holding the lock, since allocation may need to
1664 // suspend all threads and another thread may need the dex_lock_ to
1665 // get to a suspend point.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001666 SirtRef<DexCache> dex_cache(AllocDexCache(dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001667 {
1668 MutexLock mu(dex_lock_);
1669 if (IsDexFileRegisteredLocked(dex_file)) {
1670 return;
1671 }
1672 RegisterDexFileLocked(dex_file, dex_cache);
1673 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001674}
1675
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001676void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001677 MutexLock mu(dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001678 RegisterDexFileLocked(dex_file, dex_cache);
1679}
1680
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001681const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
Ian Rogers466bb252011-10-14 03:29:56 -07001682 CHECK(dex_cache != NULL);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001683 MutexLock mu(dex_lock_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001684 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1685 if (dex_caches_[i] == dex_cache) {
Ian Rogers19846512012-02-24 11:42:47 -08001686 return *dex_files_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001687 }
1688 }
Elliott Hughes7b9d9962012-04-20 18:48:18 -07001689 LOG(FATAL) << "Failed to find DexFile for DexCache " << dex_cache->GetLocation()->ToModifiedUtf8();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001690 return *dex_files_[-1];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001691}
1692
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001693DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001694 MutexLock mu(dex_lock_);
Brian Carlstromf615a612011-07-23 12:50:34 -07001695 for (size_t i = 0; i != dex_files_.size(); ++i) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001696 if (dex_files_[i] == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001697 return dex_caches_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001698 }
1699 }
Elliott Hughes7b9d9962012-04-20 18:48:18 -07001700 LOG(FATAL) << "Failed to find DexCache for DexFile " << dex_file.GetLocation();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001701 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001702}
1703
Ian Rogers19846512012-02-24 11:42:47 -08001704void ClassLinker::FixupDexCaches(Method* resolution_method) const {
1705 MutexLock mu(dex_lock_);
1706 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1707 dex_caches_[i]->Fixup(resolution_method);
1708 }
1709}
1710
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001711Class* ClassLinker::InitializePrimitiveClass(Class* primitive_class,
1712 const char* descriptor,
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001713 Primitive::Type type) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001714 // TODO: deduce one argument from the other
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001715 CHECK(primitive_class != NULL);
1716 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001717 primitive_class->SetPrimitiveType(type);
1718 primitive_class->SetStatus(Class::kStatusInitialized);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001719 Class* existing = InsertClass(descriptor, primitive_class, false);
1720 CHECK(existing == NULL) << "InitPrimitiveClass(" << descriptor << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001721 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001722}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001723
Brian Carlstrombe977852011-07-19 14:54:54 -07001724// Create an array class (i.e. the class object for the array, not the
1725// array itself). "descriptor" looks like "[C" or "[[[[B" or
1726// "[Ljava/lang/String;".
1727//
1728// If "descriptor" refers to an array of primitives, look up the
1729// primitive type's internally-generated class object.
1730//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001731// "class_loader" is the class loader of the class that's referring to
1732// us. It's used to ensure that we're looking for the element type in
1733// the right context. It does NOT become the class loader for the
1734// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001735//
1736// Returns NULL with an exception raised on failure.
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001737Class* ClassLinker::CreateArrayClass(const std::string& descriptor, const ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001738 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001739
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001740 // Identify the underlying component type
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001741 Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001742 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001743 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001744 return NULL;
1745 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001746
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001747 // See if the component type is already loaded. Array classes are
1748 // always associated with the class loader of their underlying
1749 // element type -- an array of Strings goes with the loader for
1750 // java/lang/String -- so we need to look for it there. (The
1751 // caller should have checked for the existence of the class
1752 // before calling here, but they did so with *their* class loader,
1753 // not the component type's loader.)
1754 //
1755 // If we find it, the caller adds "loader" to the class' initiating
1756 // loader list, which should prevent us from going through this again.
1757 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001758 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001759 // are the same, because our caller (FindClass) just did the
1760 // lookup. (Even if we get this wrong we still have correct behavior,
1761 // because we effectively do this lookup again when we add the new
1762 // class to the hash table --- necessary because of possible races with
1763 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001764 if (class_loader != component_type->GetClassLoader()) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001765 Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001766 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001767 return new_class;
1768 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001769 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001770
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001771 // Fill out the fields in the Class.
1772 //
1773 // It is possible to execute some methods against arrays, because
1774 // all arrays are subclasses of java_lang_Object_, so we need to set
1775 // up a vtable. We can just point at the one in java_lang_Object_.
1776 //
1777 // Array classes are simple enough that we don't need to do a full
1778 // link step.
1779
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001780 SirtRef<Class> new_class(NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001781 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001782 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07001783 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001784 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07001785 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001786 new_class.reset(GetClassRoot(kObjectArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001787 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001788 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001789 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001790 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001791 }
1792 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001793 if (new_class.get() == NULL) {
1794 new_class.reset(AllocClass(sizeof(Class)));
1795 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001796 return NULL;
1797 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001798 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001799 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001800 DCHECK(new_class->GetComponentType() != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001801 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001802 new_class->SetSuperClass(java_lang_Object);
1803 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001804 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001805 new_class->SetClassLoader(component_type->GetClassLoader());
1806 new_class->SetStatus(Class::kStatusInitialized);
1807 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001808 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001809
1810
1811 // All arrays have java/lang/Cloneable and java/io/Serializable as
1812 // interfaces. We need to set that up here, so that stuff like
1813 // "instanceof" works right.
1814 //
1815 // Note: The GC could run during the call to FindSystemClass,
1816 // so we need to make sure the class object is GC-valid while we're in
1817 // there. Do this by clearing the interface list so the GC will just
1818 // think that the entries are null.
1819
1820
1821 // Use the single, global copies of "interfaces" and "iftable"
1822 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07001823 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001824 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001825
1826 // Inherit access flags from the component type. Arrays can't be
1827 // used as a superclass or interface, so we want to add "final"
1828 // and remove "interface".
1829 //
1830 // Don't inherit any non-standard flags (e.g., kAccFinal)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001831 // from component_type. We assume that the array class does not
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001832 // override finalize().
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001833 new_class->SetAccessFlags(((new_class->GetComponentType()->GetAccessFlags() &
1834 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001835
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001836 Class* existing = InsertClass(descriptor, new_class.get(), false);
1837 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001838 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001839 }
1840 // Another thread must have loaded the class after we
1841 // started but before we finished. Abandon what we've
1842 // done.
1843 //
1844 // (Yes, this happens.)
1845
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001846 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001847}
1848
1849Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001850 switch (Primitive::GetType(type)) {
1851 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001852 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001853 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001854 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001855 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001856 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001857 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001858 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001859 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001860 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001861 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001862 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001863 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001864 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001865 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001866 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001867 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001868 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001869 case Primitive::kPrimNot:
1870 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07001871 }
Elliott Hughesbd935992011-08-22 11:59:34 -07001872 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001873 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07001874 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001875}
1876
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001877Class* ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass, bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001878 if (VLOG_IS_ON(class_linker)) {
Brian Carlstromae826982011-11-09 01:33:42 -08001879 DexCache* dex_cache = klass->GetDexCache();
1880 std::string source;
1881 if (dex_cache != NULL) {
1882 source += " from ";
1883 source += dex_cache->GetLocation()->ToModifiedUtf8();
1884 }
1885 LOG(INFO) << "Loaded class " << descriptor << source;
1886 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001887 size_t hash = StringPieceHash()(descriptor);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001888 MutexLock mu(classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001889 Table& classes = image_class ? image_classes_ : classes_;
1890 Class* existing = LookupClass(descriptor.data(), klass->GetClassLoader(), hash, classes);
1891#ifndef NDEBUG
1892 // Check we don't have the class in the other table in error
1893 Table& other_classes = image_class ? classes_ : image_classes_;
1894 CHECK(LookupClass(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
1895#endif
1896 if (existing != NULL) {
1897 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07001898 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001899 classes.insert(std::make_pair(hash, klass));
1900 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001901}
1902
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001903bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
1904 size_t hash = Hash(descriptor);
Brian Carlstromae826982011-11-09 01:33:42 -08001905 MutexLock mu(classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08001906 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08001907 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001908 ClassHelper kh;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001909 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08001910 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001911 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001912 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08001913 classes_.erase(it);
1914 return true;
1915 }
1916 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001917 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08001918 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001919 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001920 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08001921 image_classes_.erase(it);
1922 return true;
1923 }
1924 }
1925 return false;
1926}
1927
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001928Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
1929 size_t hash = Hash(descriptor);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001930 MutexLock mu(classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07001931 // TODO: determine if its better to search classes_ or image_classes_ first
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001932 Class* klass = LookupClass(descriptor, class_loader, hash, classes_);
1933 if (klass != NULL) {
1934 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001935 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001936 return LookupClass(descriptor, class_loader, hash, image_classes_);
1937}
1938
1939Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader,
1940 size_t hash, const Table& classes) {
1941 ClassHelper kh(NULL, this);
1942 typedef Table::const_iterator It; // TODO: C++0x auto
1943 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers5d76c432011-10-31 21:42:49 -07001944 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001945 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001946 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001947#ifndef NDEBUG
1948 for (++it; it != end && it->first == hash; ++it) {
Ian Rogersd85016c2012-02-03 18:27:34 -08001949 Class* klass2 = it->second;
1950 kh.ChangeClass(klass2);
1951 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001952 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08001953 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001954 }
1955#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07001956 return klass;
1957 }
1958 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001959 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001960}
1961
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001962void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001963 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001964 size_t hash = Hash(descriptor);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001965 MutexLock mu(classes_lock_);
1966 typedef Table::const_iterator It; // TODO: C++0x auto
1967 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001968 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001969 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001970 Class* klass = it->second;
1971 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001972 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001973 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001974 }
1975 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001976 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001977 Class* klass = it->second;
1978 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001979 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001980 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001981 }
1982 }
1983}
1984
TDYa1273db52852012-04-01 15:11:43 -07001985#if !defined(NDEBUG) && !defined(ART_USE_LLVM_COMPILER)
Ian Rogersc20a83e2012-01-18 18:15:32 -08001986static void CheckMethodsHaveGcMaps(Class* klass) {
1987 if (!Runtime::Current()->IsStarted()) {
1988 return;
1989 }
1990 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
1991 Method* method = klass->GetDirectMethod(i);
1992 if (!method->IsNative() && !method->IsAbstract()) {
1993 CHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
1994 }
1995 }
1996 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
1997 Method* method = klass->GetVirtualMethod(i);
1998 if (!method->IsNative() && !method->IsAbstract()) {
1999 CHECK(method->GetGcMap() != NULL) << PrettyMethod(method);
2000 }
2001 }
2002}
2003#else
Elliott Hughes1bac54f2012-03-16 12:48:31 -07002004static void CheckMethodsHaveGcMaps(Class*) {
Ian Rogersc20a83e2012-01-18 18:15:32 -08002005}
2006#endif
2007
jeffhao98eacac2011-09-14 16:11:53 -07002008void ClassLinker::VerifyClass(Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002009 // TODO: assert that the monitor on the Class is held
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002010 ObjectLock lock(klass);
2011
jeffhao98eacac2011-09-14 16:11:53 -07002012 if (klass->IsVerified()) {
2013 return;
2014 }
2015
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002016 // The class might already be erroneous if we attempted to verify a subclass
2017 if (klass->IsErroneous()) {
2018 ThrowEarlierClassFailure(klass);
2019 return;
2020 }
2021
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002022 CHECK_EQ(klass->GetStatus(), Class::kStatusResolved) << PrettyClass(klass);
jeffhao98eacac2011-09-14 16:11:53 -07002023 klass->SetStatus(Class::kStatusVerifying);
jeffhao98eacac2011-09-14 16:11:53 -07002024
Ian Rogers1c5eb702012-02-01 09:18:34 -08002025 // Verify super class
2026 Class* super = klass->GetSuperClass();
2027 std::string error_msg;
2028 if (super != NULL) {
2029 // Acquire lock to prevent races on verifying the super class
2030 ObjectLock lock(super);
2031
2032 if (!super->IsVerified() && !super->IsErroneous()) {
2033 Runtime::Current()->GetClassLinker()->VerifyClass(super);
2034 }
2035 if (!super->IsVerified()) {
2036 error_msg = "Rejecting class ";
2037 error_msg += PrettyDescriptor(klass);
2038 error_msg += " that attempts to sub-class erroneous class ";
2039 error_msg += PrettyDescriptor(super);
2040 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
2041 Thread* self = Thread::Current();
2042 SirtRef<Throwable> cause(self->GetException());
2043 if (cause.get() != NULL) {
2044 self->ClearException();
2045 }
2046 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2047 if (cause.get() != NULL) {
2048 self->GetException()->SetCause(cause.get());
2049 }
2050 CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
2051 klass->SetStatus(Class::kStatusError);
2052 return;
2053 }
2054 }
2055
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002056 // Try to use verification information from the oat file, otherwise do runtime verification.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002057 const DexFile& dex_file = FindDexFile(klass->GetDexCache());
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002058 Class::Status oat_file_class_status(Class::kStatusNotReady);
2059 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
Ian Rogers776ac1f2012-04-13 23:36:36 -07002060 bool verified = preverified || verifier::MethodVerifier::VerifyClass(klass, error_msg);
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002061 if (verified) {
2062 if (!preverified && oat_file_class_status == Class::kStatusError) {
2063 LOG(FATAL) << "Verification failed hard on class " << PrettyDescriptor(klass)
2064 << " at compile time, but succeeded at runtime! The verifier must be broken.";
2065 }
Ian Rogersc4762272012-02-01 15:55:55 -08002066 DCHECK(!Thread::Current()->IsExceptionPending());
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002067 // Make sure all classes referenced by catch blocks are resolved
2068 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002069 klass->SetStatus(Class::kStatusVerified);
Ian Rogersc20a83e2012-01-18 18:15:32 -08002070 // Sanity check that a verified class has GC maps on all methods
2071 CheckMethodsHaveGcMaps(klass);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002072 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002073 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002074 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2075 << " because: " << error_msg;
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002076 Thread* self = Thread::Current();
Ian Rogersc4762272012-02-01 15:55:55 -08002077 CHECK(!self->IsExceptionPending());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002078 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2079 CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002080 klass->SetStatus(Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002081 }
jeffhao98eacac2011-09-14 16:11:53 -07002082}
2083
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002084bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
2085 Class::Status& oat_file_class_status) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002086 if (!Runtime::Current()->IsStarted()) {
2087 return false;
2088 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002089 if (Runtime::Current()->UseCompileTimeClassPath()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002090 return false;
2091 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002092 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2093 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002094 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002095 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002096 const char* descriptor = ClassHelper(klass).GetDescriptor();
2097 uint32_t class_def_index;
2098 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002099 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002100 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002101 CHECK(oat_class.get() != NULL)
2102 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002103 oat_file_class_status = oat_class->GetStatus();
2104 if (oat_file_class_status == Class::kStatusVerified || oat_file_class_status == Class::kStatusInitialized) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002105 return true;
2106 }
jeffhao1ac29442012-03-26 11:37:32 -07002107 if (oat_file_class_status == Class::kStatusResolved) {
2108 // Compile time verification failed with a soft error. Compile time verification can fail
2109 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002110 // class ... {
2111 // Foo x;
2112 // .... () {
2113 // if (...) {
2114 // v1 gets assigned a type of resolved class Foo
2115 // } else {
2116 // v1 gets assigned a type of unresolved class Bar
2117 // }
2118 // iput x = v1
2119 // } }
2120 // when we merge v1 following the if-the-else it results in Conflict
2121 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2122 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2123 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2124 // at compile time).
2125 return false;
2126 }
jeffhao1ac29442012-03-26 11:37:32 -07002127 if (oat_file_class_status == Class::kStatusError) {
2128 // Compile time verification failed with a hard error. This is caused by invalid instructions
2129 // in the class. These errors are unrecoverable.
2130 return false;
2131 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002132 if (oat_file_class_status == Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002133 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2134 // not loading the class.
2135 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2136 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002137 return false;
2138 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002139 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002140 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2141
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002142 return false;
2143}
2144
2145void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
2146 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2147 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2148 }
2149 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2150 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2151 }
2152}
2153
2154void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* method) {
2155 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2156 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2157 if (code_item == NULL) {
2158 return; // native or abstract method
2159 }
2160 if (code_item->tries_size_ == 0) {
2161 return; // nothing to process
2162 }
2163 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2164 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2165 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2166 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2167 CatchHandlerIterator iterator(handlers_ptr);
2168 for (; iterator.HasNext(); iterator.Next()) {
2169 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2170 // unresolved exception types will be ignored by exception delivery
2171 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
2172 Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
2173 if (exception_type == NULL) {
2174 DCHECK(Thread::Current()->IsExceptionPending());
2175 Thread::Current()->ClearException();
2176 }
2177 }
2178 }
2179 handlers_ptr = iterator.EndDataPointer();
2180 }
2181}
2182
Ian Rogersc2b44472011-12-14 21:17:17 -08002183static void CheckProxyConstructor(Method* constructor);
2184static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype);
2185
Jesse Wilson95caa792011-10-12 18:14:17 -04002186Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002187 ClassLoader* loader, ObjectArray<Method>* methods,
2188 ObjectArray<ObjectArray<Class> >* throws) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002189 SirtRef<Class> klass(AllocClass(GetClassRoot(kJavaLangClass), sizeof(SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002190 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002191 DCHECK(klass->GetClass() != NULL);
Jesse Wilson95caa792011-10-12 18:14:17 -04002192 klass->SetObjectSize(sizeof(Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002193 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002194 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002195 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002196 klass->SetName(name);
Ian Rogers466bb252011-10-14 03:29:56 -07002197 Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002198 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002199
2200 klass->SetStatus(Class::kStatusIdx);
2201
2202 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2203
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002204 // Instance fields are inherited, but we add a couple of static fields...
2205 klass->SetSFields(AllocObjectArray<Field>(2));
2206 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2207 // our proxy, so Class.getInterfaces doesn't return the flattened set.
2208 SirtRef<Field> interfaces_sfield(AllocField());
2209 klass->SetStaticField(0, interfaces_sfield.get());
2210 interfaces_sfield->SetDexFieldIndex(0);
2211 interfaces_sfield->SetDeclaringClass(klass.get());
2212 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2213 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
2214 SirtRef<Field> throws_sfield(AllocField());
2215 klass->SetStaticField(1, throws_sfield.get());
2216 throws_sfield->SetDexFieldIndex(1);
2217 throws_sfield->SetDeclaringClass(klass.get());
2218 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002219
Ian Rogers466bb252011-10-14 03:29:56 -07002220 // Proxies have 1 direct method, the constructor
Jesse Wilson95caa792011-10-12 18:14:17 -04002221 klass->SetDirectMethods(AllocObjectArray<Method>(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002222 klass->SetDirectMethod(0, CreateProxyConstructor(klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002223
Ian Rogers466bb252011-10-14 03:29:56 -07002224 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002225 size_t num_virtual_methods = methods->GetLength();
2226 klass->SetVirtualMethods(AllocObjectArray<Method>(num_virtual_methods));
2227 for (size_t i = 0; i < num_virtual_methods; ++i) {
TDYa127f4404052012-04-11 08:53:03 -07002228#if defined(ART_USE_LLVM_COMPILER)
2229 Method* method = methods->Get(i);
2230 // Ensure link.
2231 // TODO: Remove this after fixing the link problem by in-place linking.
2232 if (method->GetCode() == NULL || method->GetInvokeStub() == NULL) {
2233 Runtime::Current()->GetClassLinker()->LinkOatCodeFor(methods->Get(i));
2234 }
2235#endif
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002236 SirtRef<Method> prototype(methods->Get(i));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002237 klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002238 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002239
2240 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
2241 klass->SetStatus(Class::kStatusLoaded); // Class is now effectively in the loaded state
2242 DCHECK(!Thread::Current()->IsExceptionPending());
2243
2244 // Link the fields and virtual methods, creating vtable and iftables
2245 if (!LinkClass(klass, interfaces)) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002246 klass->SetStatus(Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002247 return NULL;
2248 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002249 interfaces_sfield->SetObject(NULL, interfaces);
2250 throws_sfield->SetObject(NULL, throws);
Ian Rogersc2b44472011-12-14 21:17:17 -08002251 klass->SetStatus(Class::kStatusInitialized);
2252
2253 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002254 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002255 CHECK(klass->GetIFields() == NULL);
2256 CheckProxyConstructor(klass->GetDirectMethod(0));
2257 for (size_t i = 0; i < num_virtual_methods; ++i) {
2258 SirtRef<Method> prototype(methods->Get(i));
2259 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2260 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002261
2262 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2263 name->ToModifiedUtf8().c_str()));
2264 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2265
2266 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2267 name->ToModifiedUtf8().c_str()));
2268 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002269
2270 SynthesizedProxyClass* synth_proxy_class = down_cast<SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002271 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002272 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2273 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002274 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002275}
2276
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002277std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
2278 DCHECK(proxy_class->IsProxyClass());
2279 String* name = proxy_class->GetName();
2280 DCHECK(name != NULL);
2281 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2282}
2283
Ian Rogers16f93672012-02-14 12:29:06 -08002284Method* ClassLinker::FindMethodForProxy(const Class* proxy_class, const Method* proxy_method) {
2285 DCHECK(proxy_class->IsProxyClass());
2286 DCHECK(proxy_method->IsProxyMethod());
2287 // Locate the dex cache of the original interface/Object
2288 DexCache* dex_cache = NULL;
2289 {
2290 ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
2291 MutexLock mu(dex_lock_);
2292 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2293 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2294 dex_cache = dex_caches_[i];
2295 break;
2296 }
2297 }
2298 }
2299 CHECK(dex_cache != NULL);
2300 uint32_t method_idx = proxy_method->GetDexMethodIndex();
2301 Method* resolved_method = dex_cache->GetResolvedMethod(method_idx);
2302 CHECK(resolved_method != NULL);
2303 return resolved_method;
2304}
2305
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002306
2307Method* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002308 // Create constructor for Proxy that must initialize h
Ian Rogers466bb252011-10-14 03:29:56 -07002309 ObjectArray<Method>* proxy_direct_methods = proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002310 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Ian Rogers466bb252011-10-14 03:29:56 -07002311 Method* proxy_constructor = proxy_direct_methods->Get(2);
TDYa1275bb86012012-04-11 05:57:28 -07002312#if defined(ART_USE_LLVM_COMPILER)
2313 // Ensure link.
2314 // TODO: Remove this after fixing the link problem by in-place linking.
2315 art_fix_stub_from_code(proxy_constructor);
2316#endif
Ian Rogers466bb252011-10-14 03:29:56 -07002317 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2318 // code_ too)
2319 Method* constructor = down_cast<Method*>(proxy_constructor->Clone());
2320 // Make this constructor public and fix the class to be our Proxy version
2321 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002322 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002323 return constructor;
2324}
2325
2326static void CheckProxyConstructor(Method* constructor) {
Ian Rogers466bb252011-10-14 03:29:56 -07002327 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002328 MethodHelper mh(constructor);
2329 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002330 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002331 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002332}
2333
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002334Method* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype) {
2335 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2336 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002337 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2338 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002339 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002340 // as necessary
2341 Method* method = down_cast<Method*>(prototype->Clone());
2342
2343 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2344 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002345 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002346 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002347
Ian Rogers466bb252011-10-14 03:29:56 -07002348 // At runtime the method looks like a reference and argument saving method, clone the code
2349 // related parameters from this method.
2350 Method* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
2351 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2352 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2353 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
TDYa1275bb86012012-04-11 05:57:28 -07002354#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers466bb252011-10-14 03:29:56 -07002355 method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
TDYa1275bb86012012-04-11 05:57:28 -07002356#else
2357 method->SetCode(reinterpret_cast<const void*>(
2358 static_cast<uintptr_t>(compiler_llvm::special_stub::kProxyStub)));
2359#endif
Ian Rogers16f93672012-02-14 12:29:06 -08002360
Ian Rogersc2b44472011-12-14 21:17:17 -08002361 return method;
2362}
Jesse Wilson95caa792011-10-12 18:14:17 -04002363
Ian Rogersc2b44472011-12-14 21:17:17 -08002364static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype) {
Ian Rogers466bb252011-10-14 03:29:56 -07002365 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002366 CHECK(!prototype->IsFinal());
2367 CHECK(method->IsFinal());
2368 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002369
2370 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2371 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2372 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2373 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2374 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2375 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2376 method->GetDexCacheInitializedStaticStorage());
2377 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2378
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002379 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002380 MethodHelper mh2(prototype.get());
2381 CHECK_STREQ(mh.GetName(), mh2.GetName());
2382 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002383 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002384 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002385}
2386
Ian Rogers0045a292012-03-31 21:08:41 -07002387bool ClassLinker::InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002388 CHECK(klass->IsResolved() || klass->IsErroneous())
2389 << PrettyClass(klass) << " is " << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002390
Carl Shapirob5573532011-07-12 18:22:59 -07002391 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002392
Brian Carlstrom25c33252011-09-18 15:58:35 -07002393 Method* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002394 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002395 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002396 ObjectLock lock(klass);
2397
Brian Carlstromd1422f82011-09-28 11:37:09 -07002398 if (klass->GetStatus() == Class::kStatusInitialized) {
2399 return true;
2400 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002401
Brian Carlstromd1422f82011-09-28 11:37:09 -07002402 if (klass->IsErroneous()) {
2403 ThrowEarlierClassFailure(klass);
2404 return false;
2405 }
2406
2407 if (klass->GetStatus() == Class::kStatusResolved) {
jeffhao98eacac2011-09-14 16:11:53 -07002408 VerifyClass(klass);
2409 if (klass->GetStatus() != Class::kStatusVerified) {
Ian Rogers595799e2012-01-11 17:32:51 -08002410 CHECK(self->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002411 return false;
2412 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002413 }
2414
Brian Carlstrom25c33252011-09-18 15:58:35 -07002415 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2416 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002417 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002418 // don't bother going to kStatusInitializing. We return false so that
2419 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002420 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2421 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002422 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002423 }
2424
Brian Carlstromd1422f82011-09-28 11:37:09 -07002425 // If the class is kStatusInitializing, either this thread is
2426 // initializing higher up the stack or another thread has beat us
2427 // to initializing and we need to wait. Either way, this
2428 // invocation of InitializeClass will not be responsible for
2429 // running <clinit> and will return.
2430 if (klass->GetStatus() == Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002431 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002432 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002433 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002434 return true;
2435 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002436 // No. That's fine. Wait for another thread to finish initializing.
2437 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002438 }
2439
2440 if (!ValidateSuperClassDescriptors(klass)) {
2441 klass->SetStatus(Class::kStatusError);
2442 return false;
2443 }
2444
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002445 DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002446
Elliott Hughesdcc24742011-09-07 14:02:44 -07002447 klass->SetClinitThreadId(self->GetTid());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002448 klass->SetStatus(Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002449 }
2450
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002451 uint64_t t0 = NanoTime();
2452
Ian Rogers0045a292012-03-31 21:08:41 -07002453 if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002454 // Super class initialization failed, this can be because we can't run
2455 // super-class class initializers in which case we'll be verified.
2456 // Otherwise this class is erroneous.
2457 if (!can_run_clinit) {
2458 CHECK(klass->IsVerified());
2459 } else {
2460 CHECK(klass->IsErroneous());
2461 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002462 return false;
2463 }
2464
Ian Rogers0045a292012-03-31 21:08:41 -07002465 bool has_static_field_initializers = InitializeStaticFields(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002466
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002467 if (clinit != NULL) {
Elliott Hughesf5ecf062011-09-06 17:37:59 -07002468 clinit->Invoke(self, NULL, NULL, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002469 }
2470
Ian Rogers19846512012-02-24 11:42:47 -08002471 FixupStaticTrampolines(klass);
2472
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002473 uint64_t t1 = NanoTime();
2474
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002475 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002476 {
2477 ObjectLock lock(klass);
2478
2479 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002480 WrapExceptionInInitializer();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002481 klass->SetStatus(Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002482 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002483 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002484 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2485 RuntimeStats* thread_stats = self->GetStats();
2486 ++global_stats->class_init_count;
2487 ++thread_stats->class_init_count;
2488 global_stats->class_init_time_ns += (t1 - t0);
2489 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogers0045a292012-03-31 21:08:41 -07002490 // Set the class as initialized except if we can't initialize static fields and static field
2491 // initialization is necessary.
2492 if (!can_init_statics && has_static_field_initializers) {
2493 klass->SetStatus(Class::kStatusVerified); // Don't leave class in initializing state.
2494 success = false;
2495 } else {
2496 klass->SetStatus(Class::kStatusInitialized);
2497 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002498 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002499 ClassHelper kh(klass);
2500 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002501 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002502 }
2503 lock.NotifyAll();
2504 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002505 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002506}
2507
Brian Carlstromd1422f82011-09-28 11:37:09 -07002508bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock) {
2509 while (true) {
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002510 CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002511 lock.Wait();
2512
2513 // When we wake up, repeat the test for init-in-progress. If
2514 // there's an exception pending (only possible if
2515 // "interruptShouldThrow" was set), bail out.
2516 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002517 WrapExceptionInInitializer();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002518 klass->SetStatus(Class::kStatusError);
2519 return false;
2520 }
2521 // Spurious wakeup? Go back to waiting.
2522 if (klass->GetStatus() == Class::kStatusInitializing) {
2523 continue;
2524 }
2525 if (klass->IsErroneous()) {
2526 // The caller wants an exception, but it was thrown in a
2527 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002528 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002529 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002530 return false;
2531 }
2532 if (klass->IsInitialized()) {
2533 return true;
2534 }
2535 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2536 }
2537 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2538}
2539
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002540bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
2541 if (klass->IsInterface()) {
2542 return true;
2543 }
2544 // begin with the methods local to the superclass
2545 if (klass->HasSuperClass() &&
2546 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
2547 const Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002548 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
2549 const Method* method = klass->GetVTable()->Get(i);
2550 if (method != super->GetVTable()->Get(i) &&
2551 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002552 ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
2553 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2554 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002555 return false;
2556 }
2557 }
2558 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002559 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
2560 InterfaceEntry* interface_entry = klass->GetIfTable()->Get(i);
2561 Class* interface = interface_entry->GetInterface();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002562 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2563 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002564 const Method* method = interface_entry->GetMethodArray()->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002565 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2566 method->GetDeclaringClass())) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002567 ThrowLinkageError("Class %s method %s resolves differently in interface %s",
2568 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2569 PrettyMethod(method).c_str(),
2570 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002571 return false;
2572 }
2573 }
2574 }
2575 }
2576 return true;
2577}
2578
Ian Rogers595799e2012-01-11 17:32:51 -08002579// Returns true if classes referenced by the signature of the method are the
2580// same classes in klass1 as they are in klass2.
2581bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const Method* method,
2582 const Class* klass1,
2583 const Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002584 if (klass1 == klass2) {
2585 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002586 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07002587 const DexFile& dex_file = FindDexFile(method->GetDeclaringClass()->GetDexCache());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002588 const DexFile::ProtoId& proto_id =
2589 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002590 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2591 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002592 if (descriptor == NULL) {
2593 break;
2594 }
2595 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2596 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002597 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002598 return false;
2599 }
2600 }
2601 }
2602 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002603 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002604 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002605 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002606 return false;
2607 }
2608 }
2609 return true;
2610}
2611
Ian Rogers595799e2012-01-11 17:32:51 -08002612// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2613bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
2614 const Class* klass1,
2615 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002616 CHECK(descriptor != NULL);
2617 CHECK(klass1 != NULL);
2618 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002619 if (klass1 == klass2) {
2620 return true;
2621 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002622 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002623 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002624 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002625 }
Ian Rogers595799e2012-01-11 17:32:51 -08002626 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
2627 if (found2 == NULL) {
2628 Thread::Current()->ClearException();
2629 }
2630 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002631}
2632
Ian Rogers0045a292012-03-31 21:08:41 -07002633bool ClassLinker::InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002634 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002635 if (!klass->IsInterface() && klass->HasSuperClass()) {
2636 Class* super_class = klass->GetSuperClass();
2637 if (super_class->GetStatus() != Class::kStatusInitialized) {
2638 CHECK(!super_class->IsInterface());
Elliott Hughes5f791332011-09-15 17:45:30 -07002639 Thread* self = Thread::Current();
2640 klass->MonitorEnter(self);
Ian Rogers0045a292012-03-31 21:08:41 -07002641 bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
Elliott Hughes5f791332011-09-15 17:45:30 -07002642 klass->MonitorExit(self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002643 // TODO: check for a pending exception
2644 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002645 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002646 // Don't set status to error when we can't run <clinit>.
2647 CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
2648 klass->SetStatus(Class::kStatusVerified);
2649 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002650 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002651 klass->SetStatus(Class::kStatusError);
2652 klass->NotifyAll();
2653 return false;
2654 }
2655 }
2656 }
2657 return true;
2658}
2659
Ian Rogers0045a292012-03-31 21:08:41 -07002660bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields) {
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002661 CHECK(c != NULL);
2662 if (c->IsInitialized()) {
2663 return true;
2664 }
2665
Elliott Hughes5f791332011-09-15 17:45:30 -07002666 Thread* self = Thread::Current();
Elliott Hughes34e06962012-04-09 13:55:55 -07002667 ScopedThreadStateChange tsc(self, kRunnable);
Ian Rogers0045a292012-03-31 21:08:41 -07002668 bool success = InitializeClass(c, can_run_clinit, can_init_fields);
Ian Rogers595799e2012-01-11 17:32:51 -08002669 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002670 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002671 }
2672 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002673}
2674
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002675void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Elliott Hughesa0e18062012-04-13 15:59:59 -07002676 Class* c, SafeMap<uint32_t, Field*>& field_map) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002677 const ClassLoader* cl = c->GetClassLoader();
2678 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002679 ClassDataItemIterator it(dex_file, class_data);
2680 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002681 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002682 }
2683}
2684
Ian Rogers0045a292012-03-31 21:08:41 -07002685bool ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002686 size_t num_static_fields = klass->NumStaticFields();
2687 if (num_static_fields == 0) {
Ian Rogers0045a292012-03-31 21:08:41 -07002688 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002689 }
Brian Carlstromf615a612011-07-23 12:50:34 -07002690 DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002691 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002692 if (dex_cache == NULL) {
Ian Rogers0045a292012-03-31 21:08:41 -07002693 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002694 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002695 ClassHelper kh(klass);
2696 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002697 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002698 const DexFile& dex_file = kh.GetDexFile();
Ian Rogers0571d352011-11-03 19:51:38 -07002699 EncodedStaticFieldValueIterator it(dex_file, dex_cache, this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002700
Ian Rogers0571d352011-11-03 19:51:38 -07002701 if (it.HasNext()) {
2702 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
Elliott Hughesa0e18062012-04-13 15:59:59 -07002703 SafeMap<uint32_t, Field*> field_map;
Ian Rogers0571d352011-11-03 19:51:38 -07002704 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
2705 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002706 it.ReadValueToField(field_map.Get(i));
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002707 }
Ian Rogers0045a292012-03-31 21:08:41 -07002708 return true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002709 }
Ian Rogers0045a292012-03-31 21:08:41 -07002710 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002711}
2712
Ian Rogersc2b44472011-12-14 21:17:17 -08002713bool ClassLinker::LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002714 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002715 if (!LinkSuperClass(klass)) {
2716 return false;
2717 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002718 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002719 return false;
2720 }
2721 if (!LinkInstanceFields(klass)) {
2722 return false;
2723 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07002724 if (!LinkStaticFields(klass)) {
2725 return false;
2726 }
2727 CreateReferenceInstanceOffsets(klass);
2728 CreateReferenceStaticOffsets(klass);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002729 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
2730 klass->SetStatus(Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002731 return true;
2732}
2733
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002734bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002735 CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002736 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
2737 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08002738 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002739 uint16_t super_class_idx = class_def->superclass_idx_;
2740 if (super_class_idx != DexFile::kDexNoIndex16) {
2741 Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002742 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07002743 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002744 return false;
2745 }
Ian Rogersbe125a92012-01-11 15:19:49 -08002746 // Verify
2747 if (!klass->CanAccess(super_class)) {
2748 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2749 "Class %s extended by class %s is inaccessible",
2750 PrettyDescriptor(super_class).c_str(),
2751 PrettyDescriptor(klass.get()).c_str());
2752 return false;
2753 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002754 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002755 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002756 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
2757 if (interfaces != NULL) {
2758 for (size_t i = 0; i < interfaces->Size(); i++) {
2759 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
2760 Class* interface = ResolveType(dex_file, idx, klass.get());
2761 if (interface == NULL) {
2762 DCHECK(Thread::Current()->IsExceptionPending());
2763 return false;
2764 }
2765 // Verify
2766 if (!klass->CanAccess(interface)) {
2767 // TODO: the RI seemed to ignore this in my testing.
2768 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2769 "Interface %s implemented by class %s is inaccessible",
2770 PrettyDescriptor(interface).c_str(),
2771 PrettyDescriptor(klass.get()).c_str());
2772 return false;
2773 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002774 }
2775 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002776 // Mark the class as loaded.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002777 klass->SetStatus(Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002778 return true;
2779}
2780
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002781bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002782 CHECK(!klass->IsPrimitive());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002783 Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002784 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002785 if (super != NULL) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002786 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002787 "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002788 return false;
2789 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002790 return true;
2791 }
2792 if (super == NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002793 ThrowLinkageError("No superclass defined for class %s", PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002794 return false;
2795 }
2796 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002797 if (super->IsFinal() || super->IsInterface()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002798 Thread* self = Thread::Current();
2799 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002800 "Superclass %s of %s is %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002801 PrettyDescriptor(super).c_str(),
2802 PrettyDescriptor(klass.get()).c_str(),
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002803 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002804 return false;
2805 }
2806 if (!klass->CanAccess(super)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002807 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002808 "Superclass %s is inaccessible by %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002809 PrettyDescriptor(super).c_str(),
2810 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002811 return false;
2812 }
Elliott Hughes20cde902011-10-04 17:37:27 -07002813
2814 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
2815 if (super->IsFinalizable()) {
2816 klass->SetFinalizable();
2817 }
2818
Elliott Hughes2da50362011-10-10 16:57:08 -07002819 // Inherit reference flags (if any) from the superclass.
2820 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
2821 if (reference_flags != 0) {
2822 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
2823 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002824 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07002825 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002826 ThrowLinkageError("Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002827 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002828 return false;
2829 }
Elliott Hughes2da50362011-10-10 16:57:08 -07002830
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002831#ifndef NDEBUG
2832 // Ensure super classes are fully resolved prior to resolving fields..
2833 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002834 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002835 super = super->GetSuperClass();
2836 }
2837#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002838 return true;
2839}
2840
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002841// Populate the class vtable and itable. Compute return type indices.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002842bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002843 if (klass->IsInterface()) {
2844 // No vtable.
2845 size_t count = klass->NumVirtualMethods();
2846 if (!IsUint(16, count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08002847 ThrowClassFormatError("Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002848 return false;
2849 }
Carl Shapiro565f5072011-07-10 13:39:43 -07002850 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002851 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002852 }
jeffhaobdb76512011-09-07 11:43:16 -07002853 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002854 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002855 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07002856 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002857 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002858 }
2859 return true;
2860}
2861
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002862bool ClassLinker::LinkVirtualMethods(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002863 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002864 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
2865 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002866 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002867 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08002868 SirtRef<ObjectArray<Method> > vtable(klass->GetSuperClass()->GetVTable()->CopyOf(max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002869 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002870 MethodHelper local_mh(NULL, this);
2871 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002872 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002873 Method* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002874 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002875 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002876 for (; j < actual_count; ++j) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002877 Method* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002878 super_mh.ChangeMethod(super_method);
2879 if (local_mh.HasSameNameAndSignature(&super_mh)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002880 // Verify
2881 if (super_method->IsFinal()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002882 MethodHelper mh(local_method);
Elliott Hughese555dc02011-09-25 10:46:35 -07002883 ThrowLinkageError("Method %s.%s overrides final method in class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002884 PrettyDescriptor(klass.get()).c_str(),
2885 mh.GetName(), mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002886 return false;
2887 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002888 vtable->Set(j, local_method);
2889 local_method->SetMethodIndex(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002890 break;
2891 }
2892 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07002893 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002894 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002895 vtable->Set(actual_count, local_method);
2896 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002897 actual_count += 1;
2898 }
2899 }
2900 if (!IsUint(16, actual_count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08002901 ThrowClassFormatError("Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002902 return false;
2903 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002904 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002905 CHECK_LE(actual_count, max_count);
2906 if (actual_count < max_count) {
Ian Rogers30fab402012-01-23 15:43:46 -08002907 vtable.reset(vtable->CopyOf(actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002908 }
Ian Rogers30fab402012-01-23 15:43:46 -08002909 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002910 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002911 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002912 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002913 if (!IsUint(16, num_virtual_methods)) {
Elliott Hughese555dc02011-09-25 10:46:35 -07002914 ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002915 return false;
2916 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002917 SirtRef<ObjectArray<Method> > vtable(AllocObjectArray<Method>(num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07002918 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002919 Method* virtual_method = klass->GetVirtualMethodDuringLinking(i);
2920 vtable->Set(i, virtual_method);
2921 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002922 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002923 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002924 }
2925 return true;
2926}
2927
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002928bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002929 size_t super_ifcount;
2930 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002931 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002932 } else {
2933 super_ifcount = 0;
2934 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002935 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002936 ClassHelper kh(klass.get(), this);
2937 uint32_t num_interfaces = interfaces == NULL ? kh.NumInterfaces() : interfaces->GetLength();
2938 ifcount += num_interfaces;
2939 for (size_t i = 0; i < num_interfaces; i++) {
2940 Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
2941 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002942 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07002943 if (ifcount == 0) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002944 // TODO: enable these asserts with klass status validation
Elliott Hughesf5a7a472011-10-07 14:31:02 -07002945 // DCHECK_EQ(klass->GetIfTableCount(), 0);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002946 // DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002947 return true;
2948 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002949 SirtRef<ObjectArray<InterfaceEntry> > iftable(AllocObjectArray<InterfaceEntry>(ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002950 if (super_ifcount != 0) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002951 ObjectArray<InterfaceEntry>* super_iftable = klass->GetSuperClass()->GetIfTable();
2952 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogersb52b01a2012-01-12 17:01:38 -08002953 Class* super_interface = super_iftable->Get(i)->GetInterface();
2954 iftable->Set(i, AllocInterfaceEntry(super_interface));
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002955 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002956 }
2957 // Flatten the interface inheritance hierarchy.
2958 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002959 for (size_t i = 0; i < num_interfaces; i++) {
2960 Class* interface = interfaces == NULL ? kh.GetInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002961 DCHECK(interface != NULL);
2962 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002963 ClassHelper ih(interface);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002964 Thread* self = Thread::Current();
2965 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002966 "Class %s implements non-interface class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002967 PrettyDescriptor(klass.get()).c_str(),
2968 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002969 return false;
2970 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08002971 // Check if interface is already in iftable
2972 bool duplicate = false;
2973 for (size_t j = 0; j < idx; j++) {
2974 Class* existing_interface = iftable->Get(j)->GetInterface();
2975 if (existing_interface == interface) {
2976 duplicate = true;
2977 break;
2978 }
2979 }
2980 if (!duplicate) {
2981 // Add this non-duplicate interface.
2982 iftable->Set(idx++, AllocInterfaceEntry(interface));
2983 // Add this interface's non-duplicate super-interfaces.
2984 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
2985 Class* super_interface = interface->GetIfTable()->Get(j)->GetInterface();
2986 bool super_duplicate = false;
2987 for (size_t k = 0; k < idx; k++) {
2988 Class* existing_interface = iftable->Get(k)->GetInterface();
2989 if (existing_interface == super_interface) {
2990 super_duplicate = true;
2991 break;
2992 }
2993 }
2994 if (!super_duplicate) {
2995 iftable->Set(idx++, AllocInterfaceEntry(super_interface));
2996 }
2997 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002998 }
2999 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003000 // Shrink iftable in case duplicates were found
3001 if (idx < ifcount) {
3002 iftable.reset(iftable->CopyOf(idx));
3003 ifcount = idx;
3004 } else {
3005 CHECK_EQ(idx, ifcount);
3006 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003007 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003008
3009 // If we're an interface, we don't need the vtable pointers, so we're done.
3010 if (klass->IsInterface() /*|| super_ifcount == ifcount*/) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003011 return true;
3012 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003013 std::vector<Method*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003014 MethodHelper vtable_mh(NULL, this);
3015 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003016 for (size_t i = 0; i < ifcount; ++i) {
3017 InterfaceEntry* interface_entry = iftable->Get(i);
3018 Class* interface = interface_entry->GetInterface();
3019 ObjectArray<Method>* method_array = AllocObjectArray<Method>(interface->NumVirtualMethods());
3020 interface_entry->SetMethodArray(method_array);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003021 ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003022 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
3023 Method* interface_method = interface->GetVirtualMethod(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003024 interface_mh.ChangeMethod(interface_method);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003025 int32_t k;
Elliott Hughes4681c802011-09-25 18:04:37 -07003026 // For each method listed in the interface's method list, find the
3027 // matching method in our class's method list. We want to favor the
3028 // subclass over the superclass, which just requires walking
3029 // back from the end of the vtable. (This only matters if the
3030 // superclass defines a private method and this class redefines
3031 // it -- otherwise it would use the same vtable slot. In .dex files
3032 // those don't end up in the virtual method table, so it shouldn't
3033 // matter which direction we go. We walk it backward anyway.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003034 for (k = vtable->GetLength() - 1; k >= 0; --k) {
3035 Method* vtable_method = vtable->Get(k);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003036 vtable_mh.ChangeMethod(vtable_method);
3037 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07003038 if (!vtable_method->IsPublic()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07003039 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003040 "Implementation not public: %s", PrettyMethod(vtable_method).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003041 return false;
3042 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003043 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003044 break;
3045 }
3046 }
3047 if (k < 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003048 SirtRef<Method> miranda_method(NULL);
Elliott Hughes4681c802011-09-25 18:04:37 -07003049 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003050 Method* mir_method = miranda_list[mir];
3051 vtable_mh.ChangeMethod(mir_method);
3052 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003053 miranda_method.reset(miranda_list[mir]);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003054 break;
3055 }
3056 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003057 if (miranda_method.get() == NULL) {
Elliott Hughes4681c802011-09-25 18:04:37 -07003058 // point the interface table at a phantom slot
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003059 miranda_method.reset(AllocMethod());
3060 memcpy(miranda_method.get(), interface_method, sizeof(Method));
3061 miranda_list.push_back(miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003062 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003063 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003064 }
3065 }
3066 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003067 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003068 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003069 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07003070 klass->SetVirtualMethods((old_method_count == 0)
3071 ? AllocObjectArray<Method>(new_method_count)
3072 : klass->GetVirtualMethods()->CopyOf(new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003073
Ian Rogers30fab402012-01-23 15:43:46 -08003074 SirtRef<ObjectArray<Method> > vtable(klass->GetVTableDuringLinking());
3075 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003076 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003077 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers30fab402012-01-23 15:43:46 -08003078 vtable.reset(vtable->CopyOf(new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07003079 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07003080 Method* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003081 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003082 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3083 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3084 klass->SetVirtualMethod(old_method_count + i, method);
3085 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003086 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003087 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003088 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003089 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003090
3091 ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
3092 for (int i = 0; i < vtable->GetLength(); ++i) {
3093 CHECK(vtable->Get(i) != NULL);
3094 }
3095
3096// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3097
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003098 return true;
3099}
3100
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003101bool ClassLinker::LinkInstanceFields(SirtRef<Class>& klass) {
3102 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003103 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003104}
3105
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003106bool ClassLinker::LinkStaticFields(SirtRef<Class>& klass) {
3107 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003108 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003109 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003110 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003111 return success;
3112}
3113
Brian Carlstromdbc05252011-09-09 01:59:59 -07003114struct LinkFieldsComparator {
Elliott Hughesba8eee12012-01-24 20:25:24 -08003115 explicit LinkFieldsComparator(FieldHelper* fh) : fh_(fh) {}
Elliott Hughes3b6baaa2011-10-14 19:13:56 -07003116 bool operator()(const Field* field1, const Field* field2) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003117 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003118 fh_->ChangeField(field1);
3119 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3120 fh_->ChangeField(field2);
3121 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003122 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3123 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3124 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3125 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003126 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3127 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3128 if (order1 != order2) {
3129 return order1 < order2;
3130 }
3131
3132 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003133 fh_->ChangeField(field1);
3134 StringPiece name1(fh_->GetName());
3135 fh_->ChangeField(field2);
3136 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003137 return name1 < name2;
3138 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003139
3140 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003141};
3142
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003143bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003144 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003145 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003146
3147 ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003148 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003149
3150 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003151 size_t size;
3152 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003153 if (is_static) {
3154 size = klass->GetClassSize();
3155 field_offset = Class::FieldsOffset();
3156 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003157 Class* super_class = klass->GetSuperClass();
3158 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003159 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003160 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003161 }
3162 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003163 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003164
Brian Carlstromdbc05252011-09-09 01:59:59 -07003165 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003166
Brian Carlstromdbc05252011-09-09 01:59:59 -07003167 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003168 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromdbc05252011-09-09 01:59:59 -07003169 std::deque<Field*> grouped_and_sorted_fields;
3170 for (size_t i = 0; i < num_fields; i++) {
3171 grouped_and_sorted_fields.push_back(fields->Get(i));
3172 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003173 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003174 std::sort(grouped_and_sorted_fields.begin(),
3175 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003176 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003177
3178 // References should be at the front.
3179 size_t current_field = 0;
3180 size_t num_reference_fields = 0;
3181 for (; current_field < num_fields; current_field++) {
3182 Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003183 fh.ChangeField(field);
3184 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003185 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003186 if (isPrimitive) {
3187 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003188 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003189 grouped_and_sorted_fields.pop_front();
3190 num_reference_fields++;
3191 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003192 field->SetOffset(field_offset);
3193 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003194 }
3195
3196 // Now we want to pack all of the double-wide fields together. If
3197 // we're not aligned, though, we want to shuffle one 32-bit field
3198 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003199 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003200 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
3201 Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003202 fh.ChangeField(field);
3203 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003204 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3205 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003206 continue;
3207 }
3208 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003209 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003210 // drop the consumed field
3211 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3212 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003213 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003214 // whether we found a 32-bit field for padding or not, we advance
3215 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003216 }
3217
3218 // Alignment is good, shuffle any double-wide fields forward, and
3219 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003220 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003221 while (!grouped_and_sorted_fields.empty()) {
3222 Field* field = grouped_and_sorted_fields.front();
3223 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003224 fh.ChangeField(field);
3225 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003226 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003227 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003228 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003229 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003230 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003231 ? sizeof(uint64_t)
3232 : sizeof(uint32_t)));
3233 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003234 }
3235
Elliott Hughesadb460d2011-10-05 17:02:34 -07003236 // 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 -08003237 std::string descriptor(ClassHelper(klass.get(), this).GetDescriptor());
3238 if (!is_static && descriptor == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003239 // We know there are no non-reference fields in the Reference classes, and we know
3240 // that 'referent' is alphabetically last, so this is easy...
3241 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003242 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003243 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003244 --num_reference_fields;
3245 }
3246
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003247#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003248 // Make sure that all reference fields appear before
3249 // non-reference fields, and all double-wide fields are aligned.
3250 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003251 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003252 Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003253 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003254 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003255 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003256 << " field=" << PrettyField(field)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003257 << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
3258 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003259 fh.ChangeField(field);
3260 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003261 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003262 if (descriptor == "Ljava/lang/ref/Reference;" && StringPiece(fh.GetName()) == "referent") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003263 is_primitive = true; // We lied above, so we have to expect a lie here.
3264 }
3265 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003266 if (!seen_non_ref) {
3267 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003268 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003269 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003270 } else {
3271 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003272 }
3273 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003274 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003275 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003276 }
3277#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003278 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003279 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003280 if (is_static) {
3281 klass->SetNumReferenceStaticFields(num_reference_fields);
3282 klass->SetClassSize(size);
3283 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003284 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003285 if (!klass->IsVariableSize()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003286 klass->SetObjectSize(size);
3287 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003288 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003289 return true;
3290}
3291
3292// Set the bitmap of reference offsets, refOffsets, from the ifields
3293// list.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003294void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003295 uint32_t reference_offsets = 0;
3296 Class* super_class = klass->GetSuperClass();
3297 if (super_class != NULL) {
3298 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003299 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003300 if (reference_offsets == CLASS_WALK_SUPER) {
3301 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003302 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003303 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003304 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003305 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003306}
3307
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003308void ClassLinker::CreateReferenceStaticOffsets(SirtRef<Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003309 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003310}
3311
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003312void ClassLinker::CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003313 uint32_t reference_offsets) {
3314 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003315 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3316 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003317 const ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003318 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003319 // All of the fields that contain object references are guaranteed
3320 // to be at the beginning of the fields list.
3321 for (size_t i = 0; i < num_reference_fields; ++i) {
3322 // Note that byte_offset is the offset from the beginning of
3323 // object, not the offset into instance data
3324 const Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003325 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003326 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3327 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3328 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003329 CHECK_NE(new_bit, 0U);
3330 reference_offsets |= new_bit;
3331 } else {
3332 reference_offsets = CLASS_WALK_SUPER;
3333 break;
3334 }
3335 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003336 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003337 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003338 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003339 } else {
3340 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003341 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003342}
3343
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003344String* ClassLinker::ResolveString(const DexFile& dex_file,
Elliott Hughescf4c6c42011-09-01 15:16:42 -07003345 uint32_t string_idx, DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003346 DCHECK(dex_cache != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003347 String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003348 if (resolved != NULL) {
3349 return resolved;
3350 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003351 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3352 int32_t utf16_length = dex_file.GetStringLength(string_id);
3353 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom928bf022011-10-11 02:48:14 -07003354 String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003355 dex_cache->SetResolvedString(string_idx, string);
3356 return string;
3357}
3358
3359Class* ClassLinker::ResolveType(const DexFile& dex_file,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003360 uint16_t type_idx,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003361 DexCache* dex_cache,
3362 const ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003363 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003364 Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003365 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003366 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003367 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003368 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003369 // TODO: we used to throw here if resolved's class loader was not the
3370 // boot class loader. This was to permit different classes with the
3371 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003372 dex_cache->SetResolvedType(type_idx, resolved);
3373 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08003374 CHECK(Thread::Current()->IsExceptionPending())
3375 << "Expected pending exception for failed resolution of: " << descriptor;
jeffhao8cd6dda2012-02-22 10:15:34 -08003376 // Convert a ClassNotFoundException to a NoClassDefFoundError
3377 if (Thread::Current()->GetException()->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
3378 Thread::Current()->ClearException();
3379 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
3380 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003381 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003382 }
3383 return resolved;
3384}
3385
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003386Method* ClassLinker::ResolveMethod(const DexFile& dex_file,
3387 uint32_t method_idx,
3388 DexCache* dex_cache,
3389 const ClassLoader* class_loader,
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003390 bool is_direct) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003391 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003392 Method* resolved = dex_cache->GetResolvedMethod(method_idx);
3393 if (resolved != NULL) {
3394 return resolved;
3395 }
3396 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
3397 Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
3398 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003399 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003400 return NULL;
3401 }
3402
Brian Carlstrom7540ff42011-09-04 16:38:46 -07003403 if (is_direct) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003404 resolved = klass->FindDirectMethod(dex_cache, method_idx);
Brian Carlstrom7540ff42011-09-04 16:38:46 -07003405 } else if (klass->IsInterface()) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003406 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003407 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003408 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003409 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003410
3411 if (resolved == NULL) {
3412 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3413 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3414 if (is_direct) {
3415 resolved = klass->FindDirectMethod(name, signature);
3416 } else if (klass->IsInterface()) {
3417 resolved = klass->FindInterfaceMethod(name, signature);
3418 } else {
3419 resolved = klass->FindVirtualMethod(name, signature);
jeffhao8cd6dda2012-02-22 10:15:34 -08003420 // If a virtual method isn't found, search the direct methods. This can
3421 // happen when trying to access private methods directly, and allows the
3422 // proper exception to be thrown in the caller.
3423 if (resolved == NULL) {
3424 resolved = klass->FindDirectMethod(name, signature);
3425 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003426 }
3427 if (resolved == NULL) {
3428 ThrowNoSuchMethodError(is_direct, klass, name, signature);
3429 return NULL;
3430 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003431 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003432 dex_cache->SetResolvedMethod(method_idx, resolved);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003433 return resolved;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003434}
3435
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003436Field* ClassLinker::ResolveField(const DexFile& dex_file,
3437 uint32_t field_idx,
3438 DexCache* dex_cache,
3439 const ClassLoader* class_loader,
3440 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003441 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003442 Field* resolved = dex_cache->GetResolvedField(field_idx);
3443 if (resolved != NULL) {
3444 return resolved;
3445 }
3446 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3447 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3448 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003449 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003450 return NULL;
3451 }
3452
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003453 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003454 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003455 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003456 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003457 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003458
3459 if (resolved == NULL) {
3460 const char* name = dex_file.GetFieldName(field_id);
3461 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3462 if (is_static) {
3463 resolved = klass->FindStaticField(name, type);
3464 } else {
3465 resolved = klass->FindInstanceField(name, type);
3466 }
3467 if (resolved == NULL) {
3468 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3469 return NULL;
3470 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003471 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003472 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003473 return resolved;
3474}
3475
3476Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3477 uint32_t field_idx,
3478 DexCache* dex_cache,
3479 const ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003480 DCHECK(dex_cache != NULL);
Ian Rogersb067ac22011-12-13 18:05:09 -08003481 Field* resolved = dex_cache->GetResolvedField(field_idx);
3482 if (resolved != NULL) {
3483 return resolved;
3484 }
3485 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3486 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3487 if (klass == NULL) {
3488 DCHECK(Thread::Current()->IsExceptionPending());
3489 return NULL;
3490 }
3491
3492 const char* name = dex_file.GetFieldName(field_id);
3493 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3494 resolved = klass->FindField(name, type);
3495 if (resolved != NULL) {
3496 dex_cache->SetResolvedField(field_idx, resolved);
3497 } else {
3498 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003499 }
3500 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003501}
3502
Ian Rogers19846512012-02-24 11:42:47 -08003503const char* ClassLinker::MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length) {
Ian Rogersad25ac52011-10-04 19:13:33 -07003504 Class* declaring_class = referrer->GetDeclaringClass();
3505 DexCache* dex_cache = declaring_class->GetDexCache();
3506 const DexFile& dex_file = FindDexFile(dex_cache);
3507 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003508 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003509}
3510
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003511void ClassLinker::DumpAllClasses(int flags) const {
3512 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3513 // lock held, because it might need to resolve a field's type, which would try to take the lock.
3514 std::vector<Class*> all_classes;
3515 {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003516 MutexLock mu(classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003517 typedef Table::const_iterator It; // TODO: C++0x auto
3518 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3519 all_classes.push_back(it->second);
3520 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003521 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3522 all_classes.push_back(it->second);
3523 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003524 }
3525
3526 for (size_t i = 0; i < all_classes.size(); ++i) {
3527 all_classes[i]->DumpClass(std::cerr, flags);
3528 }
3529}
3530
Elliott Hughescac6cc72011-11-03 20:31:21 -07003531void ClassLinker::DumpForSigQuit(std::ostream& os) const {
3532 MutexLock mu(classes_lock_);
3533 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3534 << classes_.size() << " allocated classes\n";
3535}
3536
Elliott Hughese27955c2011-08-26 15:21:24 -07003537size_t ClassLinker::NumLoadedClasses() const {
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003538 MutexLock mu(classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003539 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003540}
3541
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003542pid_t ClassLinker::GetClassesLockOwner() {
3543 return classes_lock_.GetOwner();
3544}
3545
3546pid_t ClassLinker::GetDexLockOwner() {
3547 return dex_lock_.GetOwner();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003548}
3549
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003550void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
3551 DCHECK(!init_done_);
3552
3553 DCHECK(klass != NULL);
3554 DCHECK(klass->GetClassLoader() == NULL);
3555
3556 DCHECK(class_roots_ != NULL);
3557 DCHECK(class_roots_->Get(class_root) == NULL);
3558 class_roots_->Set(class_root, klass);
3559}
3560
Logan Chien0c717dd2012-03-28 18:31:07 +08003561void ClassLinker::RelocateExecutable() {
3562 for (size_t i = 0; i < oat_files_.size(); ++i) {
3563 const_cast<OatFile*>(oat_files_[i])->RelocateExecutable();
3564 }
3565}
3566
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003567} // namespace art