blob: c43c39778ed8ec65d9aef42387b1c5308dfc2a56 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "class_linker.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070018
Brian Carlstromd601af82012-01-06 10:15:19 -080019#include <fcntl.h>
20#include <sys/file.h>
21#include <sys/stat.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080022#include <sys/types.h>
23#include <sys/wait.h>
24
Brian Carlstromdbc05252011-09-09 01:59:59 -070025#include <deque>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070026#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070027#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070028#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070029
Elliott Hughes1aa246d2012-12-13 09:29:36 -080030#include "base/casts.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080031#include "base/logging.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080032#include "base/stl_util.h"
Elliott Hughes76160052012-12-12 16:31:20 -080033#include "base/unix_file/fd_file.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070034#include "class_loader.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080035#include "debugger.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070036#include "dex_cache.h"
Elliott Hughes90a33692011-08-30 13:27:07 -070037#include "dex_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070038#include "heap.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070039#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070040#include "interpreter/interpreter.h"
Ian Rogers0571d352011-11-03 19:51:38 -070041#include "leb128.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080042#include "oat.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070043#include "oat_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070044#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080045#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080046#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070047#include "runtime.h"
Ian Rogers466bb252011-10-14 03:29:56 -070048#include "runtime_support.h"
TDYa1275bb86012012-04-11 05:57:28 -070049#if defined(ART_USE_LLVM_COMPILER)
50#include "compiler_llvm/runtime_support_llvm.h"
51#endif
Elliott Hughes4d0207c2011-10-03 19:14:34 -070052#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070053#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070054#include "sirt_ref.h"
Mathieu Chartier7469ebf2012-09-24 16:28:36 -070055#include "gc/space.h"
56#include "gc/space_bitmap.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070057#include "stack_indirect_reference_table.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070058#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070059#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070060#include "utils.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070061#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070062
63namespace art {
64
Ian Rogers00f7d0e2012-07-19 15:28:27 -070065static void ThrowNoClassDefFoundError(const char* fmt, ...)
66 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070067 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070068static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070069 va_list args;
70 va_start(args, fmt);
71 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
72 va_end(args);
73}
74
Ian Rogers00f7d0e2012-07-19 15:28:27 -070075static void ThrowClassFormatError(const char* fmt, ...)
76 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070077 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070078static void ThrowClassFormatError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070079 va_list args;
80 va_start(args, fmt);
Elliott Hughese555dc02011-09-25 10:46:35 -070081 Thread::Current()->ThrowNewExceptionV("Ljava/lang/ClassFormatError;", fmt, args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -070082 va_end(args);
83}
84
Ian Rogers00f7d0e2012-07-19 15:28:27 -070085static void ThrowLinkageError(const char* fmt, ...)
86 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070087 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070088static void ThrowLinkageError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070089 va_list args;
90 va_start(args, fmt);
91 Thread::Current()->ThrowNewExceptionV("Ljava/lang/LinkageError;", fmt, args);
92 va_end(args);
93}
94
Elliott Hughes0512f022012-03-15 22:10:52 -070095static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
Ian Rogers00f7d0e2012-07-19 15:28:27 -070096 const StringPiece& name)
Ian Rogersb726dcb2012-09-05 08:57:23 -070097 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers9f1ab122011-12-12 08:52:43 -080098 ClassHelper kh(c);
99 std::ostringstream msg;
Ian Rogers08f753d2012-08-24 14:35:25 -0700100 msg << "No " << scope << "field " << name << " of type " << type
Ian Rogers9f1ab122011-12-12 08:52:43 -0800101 << " in class " << kh.GetDescriptor() << " or its superclasses";
102 std::string location(kh.GetLocation());
103 if (!location.empty()) {
104 msg << " (defined in " << location << ")";
105 }
106 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
107}
108
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700109static void ThrowNullPointerException(const char* fmt, ...)
110 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -0700111 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -0700112static void ThrowNullPointerException(const char* fmt, ...) {
Ian Rogerscab01012012-01-10 17:35:46 -0800113 va_list args;
114 va_start(args, fmt);
115 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NullPointerException;", fmt, args);
116 va_end(args);
117}
118
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700119static void ThrowEarlierClassFailure(Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700120 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -0700121 // The class failed to initialize on a previous attempt, so we want to throw
122 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
123 // failed in verification, in which case v2 5.4.1 says we need to re-throw
124 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -0700125 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
126 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
127 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700128
Elliott Hughes5c599942012-06-13 16:45:05 -0700129 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700130 if (c->GetVerifyErrorClass() != NULL) {
131 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800132 ClassHelper ve_ch(c->GetVerifyErrorClass());
133 std::string error_descriptor(ve_ch.GetDescriptor());
134 Thread::Current()->ThrowNewException(error_descriptor.c_str(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700135 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800136 ThrowNoClassDefFoundError("%s", PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700137 }
138}
139
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700140static void WrapExceptionInInitializer()
Ian Rogersb726dcb2012-09-05 08:57:23 -0700141 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700142 Thread* self = Thread::Current();
143 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700144
145 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
146 CHECK(cause.get() != NULL);
147
148 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700149 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
150 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700151
Elliott Hughesa4f94742012-05-29 16:28:38 -0700152 // We only wrap non-Error exceptions; an Error can just be used as-is.
153 if (!is_error) {
154 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700155 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700156}
157
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800158static size_t Hash(const char* s) {
159 // This is the java.lang.String hashcode for convenience, not interoperability.
160 size_t hash = 0;
161 for (; *s != '\0'; ++s) {
162 hash = hash * 31 + *s;
163 }
164 return hash;
165}
166
Elliott Hughes418d20f2011-09-22 14:00:39 -0700167const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700168 "Ljava/lang/Class;",
169 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700170 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700171 "[Ljava/lang/Object;",
172 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700173 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700174 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700175 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700176 "Ljava/lang/reflect/Field;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700177 "Ljava/lang/reflect/AbstractMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700178 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700179 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700180 "[Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700181 "[Ljava/lang/reflect/AbstractMethod;",
Ian Rogers4445a7e2012-10-05 17:19:13 -0700182 "[Ljava/lang/reflect/Field;",
183 "[Ljava/lang/reflect/Method;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700184 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800185 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800186 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700187 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700188 "Z",
189 "B",
190 "C",
191 "D",
192 "F",
193 "I",
194 "J",
195 "S",
196 "V",
197 "[Z",
198 "[B",
199 "[C",
200 "[D",
201 "[F",
202 "[I",
203 "[J",
204 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700205 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700206};
207
Brian Carlstroma004aa92012-02-08 18:05:09 -0800208ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
209 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700210 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800211 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800212 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700213 return class_linker.release();
214}
215
Brian Carlstroma004aa92012-02-08 18:05:09 -0800216ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800217 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700218 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700219 return class_linker.release();
220}
221
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800222ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700223 // dex_lock_ is recursive as it may be used in stack dumping.
224 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel, true),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700225 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700226 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700227 init_done_(false),
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700228 is_dirty_(false),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700229 intern_table_(intern_table) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700230 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700231}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700232
Brian Carlstroma004aa92012-02-08 18:05:09 -0800233void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
234 VLOG(startup) << "ClassLinker::Init";
235 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700236
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700237 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700238
Elliott Hughes30646832011-10-13 16:59:46 -0700239 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700240 Thread* self = Thread::Current();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800241 Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers50b35e22012-10-04 10:09:15 -0700242 SirtRef<Class>
243 java_lang_Class(self, down_cast<Class*>(heap->AllocObject(self, NULL, sizeof(ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700244 CHECK(java_lang_Class.get() != NULL);
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700245 Class::SetClassClass(java_lang_Class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700246 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700247 java_lang_Class->SetClassSize(sizeof(ClassClass));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700248 // AllocClass(Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700249
Elliott Hughes418d20f2011-09-22 14:00:39 -0700250 // Class[] is used for reflection support.
Ian Rogers50b35e22012-10-04 10:09:15 -0700251 SirtRef<Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700252 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700253
Ian Rogers23435d02012-09-24 11:23:12 -0700254 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers50b35e22012-10-04 10:09:15 -0700255 SirtRef<Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700256 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700257 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700258 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700259 java_lang_Object->SetStatus(Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700260
Ian Rogers23435d02012-09-24 11:23:12 -0700261 // Object[] next to hold class roots.
Ian Rogers50b35e22012-10-04 10:09:15 -0700262 SirtRef<Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700263 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700264
Ian Rogers23435d02012-09-24 11:23:12 -0700265 // Setup the char class to be used for char[].
Ian Rogers50b35e22012-10-04 10:09:15 -0700266 SirtRef<Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700267
Ian Rogers23435d02012-09-24 11:23:12 -0700268 // Setup the char[] class to be used for String.
Ian Rogers50b35e22012-10-04 10:09:15 -0700269 SirtRef<Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700270 char_array_class->SetComponentType(char_class.get());
271 CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700272
Ian Rogers23435d02012-09-24 11:23:12 -0700273 // Setup String.
Ian Rogers50b35e22012-10-04 10:09:15 -0700274 SirtRef<Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(StringClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700275 String::SetClass(java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700276 java_lang_String->SetObjectSize(sizeof(String));
277 java_lang_String->SetStatus(Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400278
Ian Rogers23435d02012-09-24 11:23:12 -0700279 // Create storage for root classes, save away our work so far (requires descriptors).
Ian Rogers50b35e22012-10-04 10:09:15 -0700280 class_roots_ = ObjectArray<Class>::Alloc(self, 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.
Ian Rogers50b35e22012-10-04 10:09:15 -0700290 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
291 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
292 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
293 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
294 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
295 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
296 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
297 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700298
Ian Rogers23435d02012-09-24 11:23:12 -0700299 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700300 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700301
Ian Rogers23435d02012-09-24 11:23:12 -0700302 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers50b35e22012-10-04 10:09:15 -0700303 SirtRef<Class> int_array_class(self, AllocClass(self, 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
Ian Rogers52813c92012-10-11 11:50:38 -0700310 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers50b35e22012-10-04 10:09:15 -0700311 SirtRef<Class>
312 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700313 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
314 java_lang_DexCache->SetObjectSize(sizeof(DexCacheClass));
315 java_lang_DexCache->SetStatus(Class::kStatusResolved);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700316
Mathieu Chartier66f19252012-09-18 08:57:04 -0700317 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Ian Rogers50b35e22012-10-04 10:09:15 -0700318 SirtRef<Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
319 sizeof(FieldClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700320 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700321 java_lang_reflect_Field->SetObjectSize(sizeof(Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700322 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700323 java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700324 Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700325
Ian Rogers50b35e22012-10-04 10:09:15 -0700326 SirtRef<Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
327 sizeof(MethodClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700328 CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
329 java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(AbstractMethod));
330 SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
331 java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700332
333 SirtRef<Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
334 sizeof(MethodClass)));
335 CHECK(java_lang_reflect_Constructor.get() != NULL);
336 java_lang_reflect_Constructor->SetObjectSize(sizeof(Constructor));
337 java_lang_reflect_Constructor->SetSuperClass(java_lang_reflect_AbstractMethod.get());
338 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
339 java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
340
341 SirtRef<Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
342 sizeof(MethodClass)));
343 CHECK(java_lang_reflect_Method.get() != NULL);
344 java_lang_reflect_Method->SetObjectSize(sizeof(Method));
345 java_lang_reflect_Method->SetSuperClass(java_lang_reflect_AbstractMethod.get());
346 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
347 java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
348
Mathieu Chartier66f19252012-09-18 08:57:04 -0700349 AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
350
351 // Set up array classes for string, field, method
Ian Rogers50b35e22012-10-04 10:09:15 -0700352 SirtRef<Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700353 object_array_string->SetComponentType(java_lang_String.get());
354 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
355
Ian Rogers4445a7e2012-10-05 17:19:13 -0700356 SirtRef<Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
357 object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
358 SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
359
Ian Rogers50b35e22012-10-04 10:09:15 -0700360 SirtRef<Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700361 object_array_field->SetComponentType(java_lang_reflect_Field.get());
362 SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
363
Ian Rogers4445a7e2012-10-05 17:19:13 -0700364 SirtRef<Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
365 object_array_method->SetComponentType(java_lang_reflect_Method.get());
366 SetClassRoot(kJavaLangReflectMethodArrayClass, object_array_method.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700367
Ian Rogers23435d02012-09-24 11:23:12 -0700368 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
369 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
370 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700371 CHECK_NE(0U, boot_class_path.size());
372 for (size_t i = 0; i != boot_class_path.size(); ++i) {
373 const DexFile* dex_file = boot_class_path[i];
374 CHECK(dex_file != NULL);
375 AppendToBootClassPath(*dex_file);
376 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700377
378 // now we can use FindSystemClass
379
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700380 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700381 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700382 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700383
Mathieu Chartier66f19252012-09-18 08:57:04 -0700384 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700385 java_lang_Object->SetStatus(Class::kStatusNotReady);
386 Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700387 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700388 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(Object));
389 java_lang_String->SetStatus(Class::kStatusNotReady);
390 Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700391 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700392 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700393 java_lang_DexCache->SetStatus(Class::kStatusNotReady);
394 Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
395 CHECK_EQ(java_lang_String.get(), String_class);
396 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
397 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700398
Ian Rogers23435d02012-09-24 11:23:12 -0700399 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700400 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
401 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
402
403 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
404 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
405
406 Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700407 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700408
409 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
410 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
411
412 Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700413 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700414
415 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
416 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
417
418 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
419 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
420
421 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
422 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
423
Elliott Hughes418d20f2011-09-22 14:00:39 -0700424 Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700425 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700426
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700427 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700428 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700429
Ian Rogers23435d02012-09-24 11:23:12 -0700430 // Setup the single, global copy of "iftable".
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700431 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
432 CHECK(java_lang_Cloneable != NULL);
433 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
434 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700435 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
436 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700437 array_iftable_->SetInterface(0, java_lang_Cloneable);
438 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700439
Ian Rogers23435d02012-09-24 11:23:12 -0700440 // Sanity check Class[] and Object[]'s interfaces.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800441 ClassHelper kh(class_array_class.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -0700442 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
443 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800444 kh.ChangeClass(object_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700445 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
446 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers23435d02012-09-24 11:23:12 -0700447 // Run Class, Constructor, Field, and Method through FindSystemClass. This initializes their
448 // dex_cache_ fields and register them in classes_.
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700449 Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700450 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700451
Mathieu Chartier66f19252012-09-18 08:57:04 -0700452 java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusNotReady);
453 Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
454 CHECK_EQ(java_lang_reflect_AbstractMethod.get(), Abstract_method_class);
455
456 // Method extends AbstractMethod so must reset after.
457 java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
458 Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
459 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
460
461 // Constructor extends AbstractMethod so must reset after.
Elliott Hughes80609252011-09-23 17:24:51 -0700462 java_lang_reflect_Constructor->SetStatus(Class::kStatusNotReady);
463 Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700464 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700465
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700466 java_lang_reflect_Field->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700467 Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700468 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700469
Mathieu Chartier66f19252012-09-18 08:57:04 -0700470 Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
471 CHECK_EQ(object_array_string.get(), String_array_class);
472
Mathieu Chartier66f19252012-09-18 08:57:04 -0700473 Class* Abstract_method_array_class =
474 FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
475 CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700476
Ian Rogers4445a7e2012-10-05 17:19:13 -0700477 Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
478 CHECK_EQ(object_array_field.get(), Field_array_class);
479
480 Class* Method_array_class =
481 FindSystemClass(class_roots_descriptors_[kJavaLangReflectMethodArrayClass]);
482 CHECK_EQ(object_array_method.get(), Method_array_class);
483
Ian Rogers23435d02012-09-24 11:23:12 -0700484 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700485
Ian Rogers23435d02012-09-24 11:23:12 -0700486 // Create java.lang.reflect.Proxy root.
Ian Rogers466bb252011-10-14 03:29:56 -0700487 Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
488 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
489
Brian Carlstrom1f870082011-08-23 16:02:11 -0700490 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700491 Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
492 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700493 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700494 java_lang_ref_FinalizerReference->SetAccessFlags(
495 java_lang_ref_FinalizerReference->GetAccessFlags() |
496 kAccClassIsReference | kAccClassIsFinalizerReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700497 Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700498 java_lang_ref_PhantomReference->SetAccessFlags(
499 java_lang_ref_PhantomReference->GetAccessFlags() |
500 kAccClassIsReference | kAccClassIsPhantomReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700501 Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700502 java_lang_ref_SoftReference->SetAccessFlags(
503 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700504 Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700505 java_lang_ref_WeakReference->SetAccessFlags(
506 java_lang_ref_WeakReference->GetAccessFlags() |
507 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700508
Ian Rogers23435d02012-09-24 11:23:12 -0700509 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700510 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
Brian Carlstromaded5f72011-10-07 17:15:04 -0700511 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700512 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
513
jeffhao8cd6dda2012-02-22 10:15:34 -0800514 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700515 // java.lang.StackTraceElement as a convenience.
Ian Rogers5167c972012-02-03 10:41:20 -0800516 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
517 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800518 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700519 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
520 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700521 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700522
Brian Carlstroma663ea52011-08-19 23:33:41 -0700523 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700524
Brian Carlstroma004aa92012-02-08 18:05:09 -0800525 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700526}
527
528void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800529 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700530
531 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700532 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700533 // as the types of the field can't be resolved prior to the runtime being
534 // fully initialized
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700535 Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700536 Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700537 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
538
Ian Rogers4445a7e2012-10-05 17:19:13 -0700539 const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800540
Brian Carlstrom16192862011-09-12 17:50:06 -0700541 Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800542 FieldHelper fh(pendingNext, this);
543 CHECK_STREQ(fh.GetName(), "pendingNext");
544 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
545 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700546
547 Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800548 fh.ChangeField(queue);
549 CHECK_STREQ(fh.GetName(), "queue");
550 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
551 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700552
553 Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800554 fh.ChangeField(queueNext);
555 CHECK_STREQ(fh.GetName(), "queueNext");
556 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
557 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700558
559 Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800560 fh.ChangeField(referent);
561 CHECK_STREQ(fh.GetName(), "referent");
562 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
563 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700564
565 Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800566 fh.ChangeField(zombie);
567 CHECK_STREQ(fh.GetName(), "zombie");
568 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
569 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700570
Elliott Hughesa4f94742012-05-29 16:28:38 -0700571 Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800572 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700573 queue->GetOffset(),
574 queueNext->GetOffset(),
575 pendingNext->GetOffset(),
576 zombie->GetOffset());
577
Brian Carlstroma663ea52011-08-19 23:33:41 -0700578 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700579 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700580 ClassRoot class_root = static_cast<ClassRoot>(i);
581 Class* klass = GetClassRoot(class_root);
582 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700583 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700584 // note SetClassRoot does additional validation.
585 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700586 }
587
Elliott Hughes92f14b22011-10-06 12:29:54 -0700588 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700589
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700590 // disable the slow paths in FindClass and CreatePrimitiveClass now
591 // that Object, Class, and Object[] are setup
592 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700593
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800594 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700595}
596
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700597void ClassLinker::RunRootClinits() {
598 Thread* self = Thread::Current();
599 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
600 Class* c = GetClassRoot(ClassRoot(i));
601 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700602 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700603 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700604 }
605 }
606}
607
Brian Carlstromd601af82012-01-06 10:15:19 -0800608bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
609 int oat_fd,
610 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800611 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700612 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800613 const char* dex2oat = dex2oat_string.c_str();
614
Brian Carlstroma004aa92012-02-08 18:05:09 -0800615 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800616
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800617 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800618 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700619 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800620 const char* boot_image_option = boot_image_option_string.c_str();
621
622 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800623 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800624 const char* dex_file_option = dex_file_option_string.c_str();
625
Brian Carlstromd601af82012-01-06 10:15:19 -0800626 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800627 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800628 const char* oat_fd_option = oat_fd_option_string.c_str();
629
Brian Carlstroma004aa92012-02-08 18:05:09 -0800630 std::string oat_location_option_string("--oat-location=");
631 oat_location_option_string += oat_cache_filename;
632 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800633
jeffhao262bf462011-10-20 18:36:32 -0700634 // fork and exec dex2oat
635 pid_t pid = fork();
636 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800637 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800638
639 // change process groups, so we don't get reaped by ProcessManager
640 setpgid(0, 0);
641
jeffhao10037c82012-01-23 15:06:23 -0800642 VLOG(class_linker) << dex2oat
643 << " --runtime-arg -Xms64m"
644 << " --runtime-arg -Xmx64m"
645 << " --runtime-arg -classpath"
646 << " --runtime-arg " << class_path
647 << " " << boot_image_option
648 << " " << dex_file_option
649 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800650 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800651
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800652 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700653 "--runtime-arg", "-Xms64m",
654 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500655 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800656 "--runtime-arg", class_path,
657 boot_image_option,
658 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800659 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800660 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700661 NULL);
662
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800663 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800664 return false;
jeffhao262bf462011-10-20 18:36:32 -0700665 } else {
666 // wait for dex2oat to finish
667 int status;
668 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
669 if (got_pid != pid) {
670 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800671 return false;
jeffhao262bf462011-10-20 18:36:32 -0700672 }
673 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800674 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
675 return false;
jeffhao262bf462011-10-20 18:36:32 -0700676 }
677 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800678 return true;
jeffhao262bf462011-10-20 18:36:32 -0700679}
680
Brian Carlstrom866c8622012-01-06 16:35:13 -0800681void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700682 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800683 RegisterOatFileLocked(oat_file);
684}
685
686void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700687 dex_lock_.AssertHeld(Thread::Current());
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800688#ifndef NDEBUG
689 for (size_t i = 0; i < oat_files_.size(); ++i) {
690 CHECK_NE(&oat_file, oat_files_[i]) << oat_file.GetLocation();
691 }
692#endif
Brian Carlstrom866c8622012-01-06 16:35:13 -0800693 oat_files_.push_back(&oat_file);
694}
695
Ian Rogers30fab402012-01-23 15:43:46 -0800696OatFile* ClassLinker::OpenOat(const ImageSpace* space) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700697 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700698 const Runtime* runtime = Runtime::Current();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700699 const ImageHeader& image_header = space->GetImageHeader();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800700 // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
701 // check the down cast
702 String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700703 std::string oat_filename;
704 oat_filename += runtime->GetHostPrefix();
705 oat_filename += oat_location->ToModifiedUtf8();
Mathieu Chartierd8195f12012-10-05 12:21:28 -0700706 runtime->GetHeap()->UnReserveOatFileAddressRange();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800707 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin());
Ian Rogers30fab402012-01-23 15:43:46 -0800708 VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700709 if (oat_file == NULL) {
Brian Carlstroma9f19782011-10-13 00:14:47 -0700710 LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700711 return NULL;
712 }
713 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
714 uint32_t image_oat_checksum = image_header.GetOatChecksum();
715 if (oat_checksum != image_oat_checksum) {
Brian Carlstrom866c8622012-01-06 16:35:13 -0800716 LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
Brian Carlstroma85b8372012-10-18 17:00:32 -0700717 << " to expected oat checksum " << std::hex << image_oat_checksum
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700718 << " in image";
719 return NULL;
720 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800721 RegisterOatFileLocked(*oat_file);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800722 VLOG(startup) << "ClassLinker::OpenOat exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700723 return oat_file;
724}
725
Brian Carlstromae826982011-11-09 01:33:42 -0800726const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700727 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800728 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800729}
730
Brian Carlstroma004aa92012-02-08 18:05:09 -0800731const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800732 for (size_t i = 0; i < oat_files_.size(); i++) {
733 const OatFile* oat_file = oat_files_[i];
734 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800735 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800736 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800737 return oat_file;
738 }
739 }
740 return NULL;
741}
742
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800743static const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
744 uint32_t dex_location_checksum,
745 const std::string& oat_location) {
Brian Carlstrom1cac3432012-12-12 10:56:22 -0800746 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800747 if (oat_file.get() == NULL) {
748 return NULL;
749 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700750 Runtime* runtime = Runtime::Current();
751 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700752 if (oat_file->GetOatHeader().GetImageFileLocationOatChecksum() != image_header.GetOatChecksum()) {
753 return NULL;
754 }
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800755 if (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
756 != reinterpret_cast<uint32_t>(image_header.GetOatDataBegin())) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700757 return NULL;
758 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800759 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
760 if (oat_dex_file == NULL) {
761 return NULL;
762 }
763 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
764 return NULL;
765 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700766 runtime->GetClassLinker()->RegisterOatFile(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800767 return oat_dex_file->OpenDexFile();
768}
769
770const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
771 const std::string& oat_location) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700772 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700773 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_location);
774}
775
776const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
777 const std::string& oat_location) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800778 uint32_t dex_location_checksum;
779 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
780 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
781 return NULL;
782 }
783
784 // Check if we already have an up-to-date output file
785 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
786 dex_location_checksum,
787 oat_location);
788 if (dex_file != NULL) {
789 return dex_file;
790 }
791
792 // Generate the output oat file for the dex file
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800793 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
794 if (file.get() == NULL) {
795 LOG(ERROR) << "Failed to create oat file: " << oat_location;
796 return NULL;
797 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700798 if (!GenerateOatFile(dex_location, file->Fd(), oat_location)) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800799 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
800 return NULL;
801 }
802 // Open the oat from file descriptor we passed to GenerateOatFile
803 if (lseek(file->Fd(), 0, SEEK_SET) != 0) {
804 LOG(ERROR) << "Failed to seek to start of generated oat file: " << oat_location;
805 return NULL;
806 }
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800807 const OatFile* oat_file = OatFile::Open(file.get(), oat_location, NULL, false);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800808 if (oat_file == NULL) {
809 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
810 return NULL;
811 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700812 RegisterOatFileLocked(*oat_file);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800813 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
814 if (oat_dex_file == NULL) {
815 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
816 return NULL;
817 }
818 return oat_dex_file->OpenDexFile();
819}
820
Brian Carlstromafe25512012-06-27 17:02:58 -0700821bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
822 const std::string& dex_location,
823 uint32_t dex_location_checksum) {
824 Runtime* runtime = Runtime::Current();
825 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700826 uint32_t image_oat_checksum = image_header.GetOatChecksum();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800827 uint32_t image_oat_data_begin = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
Brian Carlstrom28db0122012-10-18 16:20:41 -0700828 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800829 && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700830
Brian Carlstromafe25512012-06-27 17:02:58 -0700831 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
832 if (oat_dex_file == NULL) {
833 LOG(ERROR) << ".oat file " << oat_file->GetLocation()
834 << " does not contain contents for " << dex_location;
835 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
836 for (size_t i = 0; i < oat_dex_files.size(); i++) {
837 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
838 LOG(ERROR) << ".oat file " << oat_file->GetLocation()
839 << " contains contents for " << oat_dex_file->GetDexFileLocation();
840 }
841 return false;
842 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700843 bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700844
Brian Carlstromafe25512012-06-27 17:02:58 -0700845 if (image_check && dex_check) {
846 return true;
847 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700848
Brian Carlstromafe25512012-06-27 17:02:58 -0700849 if (!image_check) {
850 std::string image_file(image_header.GetImageRoot(
851 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
852 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700853 << " mismatch ( " << std::hex << oat_file->GetOatHeader().GetImageFileLocationOatChecksum()
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800854 << ", " << oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700855 << ") with " << image_file
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800856 << " (" << image_oat_checksum << ", " << std::hex << image_oat_data_begin << ")";
Brian Carlstromafe25512012-06-27 17:02:58 -0700857 }
858 if (!dex_check) {
859 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700860 << " mismatch ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
861 << ") with " << dex_location
Brian Carlstromafe25512012-06-27 17:02:58 -0700862 << " (" << std::hex << dex_location_checksum << ")";
863 }
864 return false;
865}
866
867const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
868 const std::string& dex_location,
869 uint32_t dex_location_checksum) {
870 bool verified = VerifyOatFileChecksums(oat_file, dex_location, dex_location_checksum);
871 if (!verified) {
872 return NULL;
873 }
874 RegisterOatFileLocked(*oat_file);
875 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700876}
877
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800878const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700879 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800880
Brian Carlstroma004aa92012-02-08 18:05:09 -0800881 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800882 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800883 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800884 }
885
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700886 // Look for an existing file next to dex. for example, for
887 // /foo/bar/baz.jar, look for /foo/bar/baz.jar.oat.
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800888 std::string oat_filename(OatFile::DexFilenameToOatFilename(dex_location));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700889 const OatFile* oat_file = FindOatFileFromOatLocationLocked(oat_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800890 if (oat_file != NULL) {
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700891 uint32_t dex_location_checksum;
892 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
893 // If no classes.dex found in dex_location, it has been stripped, assume oat is up-to-date.
894 // This is the common case in user builds for jar's and apk's in the /system directory.
895 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
896 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
897 RegisterOatFileLocked(*oat_file);
898 return oat_dex_file->OpenDexFile();
899 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700900 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
901 dex_location,
902 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700903 if (dex_file != NULL) {
904 return dex_file;
905 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800906 }
907 // Look for an existing file in the art-cache, validating the result if found
908 // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
909 std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700910 oat_file = FindOatFileFromOatLocationLocked(cache_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800911 if (oat_file != NULL) {
912 uint32_t dex_location_checksum;
913 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
914 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
915 return NULL;
916 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700917 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
918 dex_location,
919 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700920 if (dex_file != NULL) {
921 return dex_file;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700922 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800923 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700924 PLOG(FATAL) << "Failed to remove obsolete .oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800925 }
jeffhao262bf462011-10-20 18:36:32 -0700926 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800927 LOG(INFO) << "Failed to open oat file from " << oat_filename << " or " << cache_location << ".";
928
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800929 // Try to generate oat file if it wasn't found or was obsolete.
930 std::string oat_cache_filename(GetArtCacheFilenameOrDie(oat_filename));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700931 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700932}
933
Brian Carlstromae826982011-11-09 01:33:42 -0800934const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700935 for (size_t i = 0; i < oat_files_.size(); i++) {
936 const OatFile* oat_file = oat_files_[i];
937 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800938 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700939 return oat_file;
940 }
941 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700942 return NULL;
943}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700944
Brian Carlstromae826982011-11-09 01:33:42 -0800945const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700946 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700947 return FindOatFileFromOatLocationLocked(oat_location);
948}
949
950const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800951 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
952 if (oat_file != NULL) {
953 return oat_file;
954 }
955
Brian Carlstrom1cac3432012-12-12 10:56:22 -0800956 oat_file = OatFile::Open(oat_location, oat_location, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700957 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800958 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700959 }
960 return oat_file;
961}
962
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700963void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800964 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700965 CHECK(!init_done_);
966
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800967 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700968 ImageSpace* space = heap->GetImageSpace();
969 OatFile* oat_file = OpenOat(space);
970 CHECK(oat_file != NULL) << "Failed to open oat file for image";
Brian Carlstrom28db0122012-10-18 16:20:41 -0700971 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800972 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
Elliott Hughes74847412012-06-20 18:10:21 -0700973 CHECK(oat_file->GetOatHeader().GetImageFileLocation().empty());
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700974 Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
975 ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700976
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700977 ObjectArray<Class>* class_roots =
978 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<Class>();
979
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700980 // Special case of setting up the String class early so that we can test arbitrary objects
981 // as being Strings or not
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700982 String::SetClass(class_roots->Get(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800983
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700984 CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
985 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers1f539342012-10-03 21:09:42 -0700986 Thread* self = Thread::Current();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700987 for (int i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers1f539342012-10-03 21:09:42 -0700988 SirtRef<DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700989 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
990 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800991 CHECK(oat_dex_file != NULL) << oat_file->GetLocation() << " " << dex_file_location;
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700992 const DexFile* dex_file = oat_dex_file->OpenDexFile();
993 if (dex_file == NULL) {
994 LOG(FATAL) << "Failed to open dex file " << dex_file_location
995 << " from within oat file " << oat_file->GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700996 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700997
998 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
999
1000 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001001 }
1002
Brian Carlstroma663ea52011-08-19 23:33:41 -07001003 // reinit clases_ table
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001004 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001005 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001006 heap->FlushAllocStack();
Mathieu Chartiere0f0cb32012-08-28 11:26:00 -07001007 heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001008 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001009
1010 // reinit class_roots_
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001011 Class::SetClassClass(class_roots->Get(kJavaLangClass));
1012 class_roots_ = class_roots;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001013
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001014 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001015 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1016 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001017 // String class root was set above
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001018 Field::SetClass(GetClassRoot(kJavaLangReflectField));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001019 AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
1020 GetClassRoot(kJavaLangReflectMethod));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001021 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1022 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1023 CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1024 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1025 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1026 IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1027 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1028 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers5167c972012-02-03 10:41:20 -08001029 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001030 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001031
1032 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001033
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001034 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001035}
1036
Brian Carlstrom78128a62011-09-15 17:21:19 -07001037void ClassLinker::InitFromImageCallback(Object* obj, void* arg) {
Brian Carlstroma663ea52011-08-19 23:33:41 -07001038 DCHECK(obj != NULL);
1039 DCHECK(arg != NULL);
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001040 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001041
Elliott Hughesdbb40792011-11-18 17:05:22 -08001042 if (obj->GetClass()->IsStringClass()) {
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001043 class_linker->intern_table_->RegisterStrong(obj->AsString());
Brian Carlstromc74255f2011-09-11 22:47:39 -07001044 return;
1045 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001046 if (obj->IsClass()) {
1047 // restore class to ClassLinker::classes_ table
1048 Class* klass = obj->AsClass();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001049 ClassHelper kh(klass, class_linker);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001050 Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
1051 DCHECK(existing == NULL) << kh.GetDescriptor();
Brian Carlstroma663ea52011-08-19 23:33:41 -07001052 return;
1053 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001054}
1055
1056// Keep in sync with InitCallback. Anything we visit, we need to
1057// reinit references to when reinitializing a ClassLinker from a
1058// mapped image.
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001059void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001060 visitor(class_roots_, arg);
Ian Rogers50b35e22012-10-04 10:09:15 -07001061 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001062 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001063 MutexLock mu(self, dex_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001064 for (size_t i = 0; i < dex_caches_.size(); i++) {
1065 visitor(dex_caches_[i], arg);
1066 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001067 }
1068
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001069 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001070 MutexLock mu(self, *Locks::classlinker_classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001071 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001072 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001073 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001074 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001075
1076 // We deliberately ignore the class roots in the image since we
1077 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001078 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001079
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001080 visitor(array_iftable_, arg);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001081 is_dirty_ = false;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001082}
1083
Elliott Hughesa2155262011-11-16 16:26:58 -08001084void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001085 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -08001086 typedef Table::const_iterator It; // TODO: C++0x auto
1087 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
1088 if (!visitor(it->second, arg)) {
1089 return;
1090 }
1091 }
1092 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
1093 if (!visitor(it->second, arg)) {
1094 return;
1095 }
1096 }
1097}
1098
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001099static bool GetClassesVisitor(Class* c, void* arg) {
1100 std::set<Class*>* classes = reinterpret_cast<std::set<Class*>*>(arg);
1101 classes->insert(c);
1102 return true;
1103}
1104
1105void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
1106 std::set<Class*> classes;
1107 VisitClasses(GetClassesVisitor, &classes);
1108 typedef std::set<Class*>::const_iterator It; // TODO: C++0x auto
1109 for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
1110 if (!visitor(*it, arg)) {
1111 return;
1112 }
1113 }
1114}
1115
1116
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001117ClassLinker::~ClassLinker() {
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001118 Class::ResetClass();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001119 String::ResetClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001120 Field::ResetClass();
Mathieu Chartier66f19252012-09-18 08:57:04 -07001121 AbstractMethod::ResetClasses();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001122 BooleanArray::ResetArrayClass();
1123 ByteArray::ResetArrayClass();
1124 CharArray::ResetArrayClass();
1125 DoubleArray::ResetArrayClass();
1126 FloatArray::ResetArrayClass();
1127 IntArray::ResetArrayClass();
1128 LongArray::ResetArrayClass();
1129 ShortArray::ResetArrayClass();
Ian Rogers5167c972012-02-03 10:41:20 -08001130 Throwable::ResetClass();
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001131 StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001132 STLDeleteElements(&boot_class_path_);
1133 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001134}
1135
Ian Rogers50b35e22012-10-04 10:09:15 -07001136DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001137 Heap* heap = Runtime::Current()->GetHeap();
1138 Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
Ian Rogers50b35e22012-10-04 10:09:15 -07001139 SirtRef<DexCache> dex_cache(self,
1140 down_cast<DexCache*>(heap->AllocObject(self, dex_cache_class,
1141 dex_cache_class->GetObjectSize())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001142 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001143 return NULL;
1144 }
Ian Rogers1f539342012-10-03 21:09:42 -07001145 SirtRef<String> location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001146 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001147 return NULL;
1148 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001149 SirtRef<ObjectArray<String> > strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001150 if (strings.get() == NULL) {
1151 return NULL;
1152 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001153 SirtRef<ObjectArray<Class> > types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001154 if (types.get() == NULL) {
1155 return NULL;
1156 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001157 SirtRef<ObjectArray<AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07001158 methods(self, AllocAbstractMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001159 if (methods.get() == NULL) {
1160 return NULL;
1161 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001162 SirtRef<ObjectArray<Field> > fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001163 if (fields.get() == NULL) {
1164 return NULL;
1165 }
Ian Rogers1f539342012-10-03 21:09:42 -07001166 SirtRef<ObjectArray<StaticStorageBase> >
Ian Rogers50b35e22012-10-04 10:09:15 -07001167 initialized_static_storage(self,
1168 AllocObjectArray<StaticStorageBase>(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001169 if (initialized_static_storage.get() == NULL) {
1170 return NULL;
1171 }
1172
Mathieu Chartier66f19252012-09-18 08:57:04 -07001173 dex_cache->Init(&dex_file,
1174 location.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001175 strings.get(),
1176 types.get(),
1177 methods.get(),
1178 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001179 initialized_static_storage.get());
1180 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001181}
1182
Ian Rogers50b35e22012-10-04 10:09:15 -07001183Class* ClassLinker::AllocClass(Thread* self, Class* java_lang_Class, size_t class_size) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07001184 DCHECK_GE(class_size, sizeof(Class));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001185 Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers50b35e22012-10-04 10:09:15 -07001186 SirtRef<Class> klass(self,
1187 heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001188 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001189 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001190 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001191}
1192
Ian Rogers50b35e22012-10-04 10:09:15 -07001193Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
1194 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001195}
1196
Ian Rogers50b35e22012-10-04 10:09:15 -07001197Field* ClassLinker::AllocField(Thread* self) {
1198 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001199}
1200
Ian Rogers50b35e22012-10-04 10:09:15 -07001201Method* ClassLinker::AllocMethod(Thread* self) {
1202 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001203}
1204
Ian Rogers50b35e22012-10-04 10:09:15 -07001205Constructor* ClassLinker::AllocConstructor(Thread* self) {
1206 return down_cast<Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001207}
1208
Ian Rogers50b35e22012-10-04 10:09:15 -07001209ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
1210 size_t length) {
1211 return ObjectArray<StackTraceElement>::Alloc(self,
1212 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1213 length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001214}
1215
Ian Rogers50b35e22012-10-04 10:09:15 -07001216static Class* EnsureResolved(Thread* self, Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001217 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001218 DCHECK(klass != NULL);
1219 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001220 if (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers1f539342012-10-03 21:09:42 -07001221 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001222 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001223 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001224 self->ThrowNewException("Ljava/lang/ClassCircularityError;",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001225 PrettyDescriptor(klass).c_str());
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001226 klass->SetStatus(Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001227 return NULL;
1228 }
1229 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001230 while (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001231 lock.Wait();
1232 }
1233 }
1234 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001235 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001236 return NULL;
1237 }
1238 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001239 CHECK(klass->IsResolved()) << PrettyClass(klass);
1240 CHECK(!self->IsExceptionPending())
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001241 << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException()) << "\n"
1242 << self->GetException()->Dump();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001243 return klass;
1244}
1245
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001246Class* ClassLinker::FindSystemClass(const char* descriptor) {
1247 return FindClass(descriptor, NULL);
1248}
1249
Ian Rogers365c1022012-06-22 15:05:28 -07001250Class* ClassLinker::FindClass(const char* descriptor, ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001251 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001252 Thread* self = Thread::Current();
1253 DCHECK(self != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001254 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001255 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001256 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1257 // for primitive classes that aren't backed by dex files.
1258 return FindPrimitiveClass(descriptor[0]);
1259 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001260 // Find the class in the loaded classes table.
1261 Class* klass = LookupClass(descriptor, class_loader);
1262 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001263 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001264 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001265 // Class is not yet loaded.
1266 if (descriptor[0] == '[') {
1267 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001268
Jesse Wilson47daf872011-11-23 11:42:45 -05001269 } else if (class_loader == NULL) {
1270 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1271 if (pair.second != NULL) {
1272 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1273 }
1274
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001275 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001276 // first try the boot class path
1277 Class* system_class = FindSystemClass(descriptor);
1278 if (system_class != NULL) {
1279 return system_class;
1280 }
1281 CHECK(self->IsExceptionPending());
1282 self->ClearException();
1283
1284 // next try the compile time class path
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001285 const std::vector<const DexFile*>* class_path;
1286 {
1287 ScopedObjectAccessUnchecked soa(Thread::Current());
1288 ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
1289 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1290 }
1291
1292 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001293 if (pair.second != NULL) {
1294 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001295 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001296
1297 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001298 ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1299 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
1300 soa.AddLocalReference<jobject>(class_loader));
Elliott Hughes95572412011-12-13 18:14:20 -08001301 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001302 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001303 {
1304 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001305 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1306 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001307 if (class_name_object.get() == NULL) {
1308 return NULL;
1309 }
1310 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001311 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1312 WellKnownClasses::java_lang_ClassLoader_loadClass,
1313 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001314 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001315 if (soa.Env()->ExceptionCheck()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001316 // If the ClassLoader threw, pass that exception up.
1317 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001318 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001319 // broken loader - throw NPE to be compatible with Dalvik
1320 ThrowNullPointerException("ClassLoader.loadClass returned null for %s",
1321 class_name_string.c_str());
1322 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001323 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08001324 // success, return Class*
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001325 return soa.Decode<Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001326 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001327 }
1328
Elliott Hughes82914b62012-04-09 15:56:29 -07001329 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001330 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001331}
1332
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001333Class* ClassLinker::DefineClass(const StringPiece& descriptor,
Ian Rogers365c1022012-06-22 15:05:28 -07001334 ClassLoader* class_loader,
Brian Carlstromaded5f72011-10-07 17:15:04 -07001335 const DexFile& dex_file,
1336 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001337 Thread* self = Thread::Current();
1338 SirtRef<Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001339 // Load the class from the dex file.
1340 if (!init_done_) {
1341 // finish up init of hand crafted class_roots_
1342 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001343 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001344 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001345 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001346 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001347 klass.reset(GetClassRoot(kJavaLangString));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001348 } else if (descriptor == "Ljava/lang/DexCache;") {
1349 klass.reset(GetClassRoot(kJavaLangDexCache));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001350 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001351 klass.reset(GetClassRoot(kJavaLangReflectField));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001352 } else if (descriptor == "Ljava/lang/reflect/AbstractMethod;") {
1353 klass.reset(GetClassRoot(kJavaLangReflectAbstractMethod));
1354 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
1355 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001356 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001357 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001358 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001359 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001360 }
1361 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001362 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001363 }
1364 klass->SetDexCache(FindDexCache(dex_file));
1365 LoadClass(dex_file, dex_class_def, klass, class_loader);
1366 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001367 if (self->IsExceptionPending()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001368 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001369 return NULL;
1370 }
Ian Rogers1f539342012-10-03 21:09:42 -07001371 ObjectLock lock(self, klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001372 klass->SetClinitThreadId(self->GetTid());
1373 // Add the newly loaded class to the loaded classes table.
Ian Rogers1f539342012-10-03 21:09:42 -07001374 SirtRef<Class> existing(self, InsertClass(descriptor, klass.get(), false));
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001375 if (existing.get() != NULL) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001376 // We failed to insert because we raced with another thread.
Ian Rogers50b35e22012-10-04 10:09:15 -07001377 return EnsureResolved(self, existing.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001378 }
1379 // Finish loading (if necessary) by finding parents
1380 CHECK(!klass->IsLoaded());
1381 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1382 // Loading failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001383 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001384 lock.NotifyAll();
1385 return NULL;
1386 }
1387 CHECK(klass->IsLoaded());
1388 // Link the class (if necessary)
1389 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001390 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001391 // Linking failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001392 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001393 lock.NotifyAll();
1394 return NULL;
1395 }
1396 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001397
1398 /*
1399 * We send CLASS_PREPARE events to the debugger from here. The
1400 * definition of "preparation" is creating the static fields for a
1401 * class and initializing them to the standard default values, but not
1402 * executing any code (that comes later, during "initialization").
1403 *
1404 * We did the static preparation in LinkClass.
1405 *
1406 * The class has been prepared and resolved but possibly not yet verified
1407 * at this point.
1408 */
1409 Dbg::PostClassPrepare(klass.get());
1410
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001411 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001412}
1413
Brian Carlstrom4873d462011-08-21 15:23:39 -07001414// Precomputes size that will be needed for Class, matching LinkStaticFields
1415size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1416 const DexFile::ClassDef& dex_class_def) {
1417 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001418 size_t num_ref = 0;
1419 size_t num_32 = 0;
1420 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001421 if (class_data != NULL) {
1422 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1423 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001424 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001425 char c = descriptor[0];
1426 if (c == 'L' || c == '[') {
1427 num_ref++;
1428 } else if (c == 'J' || c == 'D') {
1429 num_64++;
1430 } else {
1431 num_32++;
1432 }
1433 }
1434 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001435 // start with generic class data
1436 size_t size = sizeof(Class);
1437 // follow with reference fields which must be contiguous at start
1438 size += (num_ref * sizeof(uint32_t));
1439 // if there are 64-bit fields to add, make sure they are aligned
1440 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
1441 if (num_32 != 0) {
1442 // use an available 32-bit field for padding
1443 num_32--;
1444 }
1445 size += sizeof(uint32_t); // either way, we are adding a word
1446 DCHECK_EQ(size, RoundUp(size, 8));
1447 }
1448 // tack on any 64-bit fields now that alignment is assured
1449 size += (num_64 * sizeof(uint64_t));
1450 // tack on any remaining 32-bit fields
1451 size += (num_32 * sizeof(uint32_t));
1452 return size;
1453}
1454
Ian Rogers19846512012-02-24 11:42:47 -08001455const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1456 DCHECK(descriptor != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001457 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1458 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1459 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1460 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1461 uint32_t class_def_index;
1462 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1463 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1464 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1465 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1466 return oat_class;
1467}
1468
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001469static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint32_t method_idx) {
1470 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1471 const DexFile::TypeId& type_id = dex_file.GetTypeId(method_id.class_idx_);
1472 const DexFile::ClassDef* class_def = dex_file.FindClassDef(dex_file.GetTypeDescriptor(type_id));
1473 CHECK(class_def != NULL);
1474 const byte* class_data = dex_file.GetClassData(*class_def);
1475 CHECK(class_data != NULL);
1476 ClassDataItemIterator it(dex_file, class_data);
1477 // Skip fields
1478 while (it.HasNextStaticField()) {
1479 it.Next();
1480 }
1481 while (it.HasNextInstanceField()) {
1482 it.Next();
1483 }
1484 // Process methods
1485 size_t class_def_method_index = 0;
1486 while (it.HasNextDirectMethod()) {
1487 if (it.GetMemberIndex() == method_idx) {
1488 return class_def_method_index;
1489 }
1490 class_def_method_index++;
1491 it.Next();
1492 }
1493 while (it.HasNextVirtualMethod()) {
1494 if (it.GetMemberIndex() == method_idx) {
1495 return class_def_method_index;
1496 }
1497 class_def_method_index++;
1498 it.Next();
1499 }
1500 DCHECK(!it.HasNext());
1501 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1502 return 0;
1503}
1504
Mathieu Chartier66f19252012-09-18 08:57:04 -07001505const OatFile::OatMethod ClassLinker::GetOatMethodFor(const AbstractMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001506 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001507 // method for direct methods (or virtual methods made direct).
1508 Class* declaring_class = method->GetDeclaringClass();
1509 size_t oat_method_index;
1510 if (method->IsStatic() || method->IsDirect()) {
1511 // Simple case where the oat method index was stashed at load time.
1512 oat_method_index = method->GetMethodIndex();
1513 } else {
1514 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1515 // by search for its position in the declared virtual methods.
1516 oat_method_index = declaring_class->NumDirectMethods();
1517 size_t end = declaring_class->NumVirtualMethods();
1518 bool found = false;
1519 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001520 if (declaring_class->GetVirtualMethod(i) == method) {
1521 found = true;
1522 break;
1523 }
Ian Rogersf320b632012-03-13 18:47:47 -07001524 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001525 }
1526 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1527 }
1528 ClassHelper kh(declaring_class);
Ian Rogers19846512012-02-24 11:42:47 -08001529 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001530 CHECK(oat_class.get() != NULL);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001531 DCHECK_EQ(oat_method_index,
1532 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
1533 method->GetDexMethodIndex()));
1534
TDYa12785321912012-04-01 15:24:56 -07001535 return oat_class->GetOatMethod(oat_method_index);
1536}
1537
1538// Special case to get oat code without overwriting a trampoline.
Mathieu Chartier66f19252012-09-18 08:57:04 -07001539const void* ClassLinker::GetOatCodeFor(const AbstractMethod* method) {
TDYa127ccffd9e2012-04-08 14:37:03 -07001540 CHECK(Runtime::Current()->IsCompiler() || method->GetDeclaringClass()->IsInitializing());
TDYa12785321912012-04-01 15:24:56 -07001541 return GetOatMethodFor(method).GetCode();
1542}
1543
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001544const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx) {
1545 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1546 const char* descriptor = dex_file.GetTypeDescriptor(dex_file.GetTypeId(method_id.class_idx_));
1547 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, method_idx);
1548 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, descriptor));
1549 CHECK(oat_class.get() != NULL);
1550 return oat_class->GetOatMethod(oat_method_idx).GetCode();
1551}
1552
Ian Rogers19846512012-02-24 11:42:47 -08001553void ClassLinker::FixupStaticTrampolines(Class* klass) {
1554 ClassHelper kh(klass);
1555 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1556 CHECK(dex_class_def != NULL);
1557 const DexFile& dex_file = kh.GetDexFile();
1558 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1559 if (class_data == NULL) {
1560 return; // no fields or methods - for example a marker interface
1561 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001562 if (!Runtime::Current()->IsStarted() || Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001563 // OAT file unavailable
1564 return;
1565 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001566 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1567 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001568 ClassDataItemIterator it(dex_file, class_data);
1569 // Skip fields
1570 while (it.HasNextStaticField()) {
1571 it.Next();
1572 }
1573 while (it.HasNextInstanceField()) {
1574 it.Next();
1575 }
1576 size_t method_index = 0;
1577 // Link the code of methods skipped by LinkCode
1578 const void* trampoline = Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData();
1579 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001580 AbstractMethod* method = klass->GetDirectMethod(i);
jeffhaob5e81852012-03-12 11:15:45 -07001581 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhao725a9572012-11-13 18:20:12 -08001582 Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
1583 if (instrumentation->GetSavedCodeFromMap(method) == trampoline) {
jeffhaob5e81852012-03-12 11:15:45 -07001584 const void* code = oat_class->GetOatMethod(method_index).GetCode();
jeffhao725a9572012-11-13 18:20:12 -08001585 instrumentation->ResetSavedCode(method);
jeffhaob5e81852012-03-12 11:15:45 -07001586 method->SetCode(code);
jeffhao725a9572012-11-13 18:20:12 -08001587 instrumentation->SaveAndUpdateCode(method);
jeffhaob5e81852012-03-12 11:15:45 -07001588 }
1589 } else if (method->GetCode() == trampoline) {
Ian Rogers19846512012-02-24 11:42:47 -08001590 const void* code = oat_class->GetOatMethod(method_index).GetCode();
Ian Rogers08f753d2012-08-24 14:35:25 -07001591 CHECK(code != NULL)
1592 << "Resolving a static trampoline but found no code for: " << PrettyMethod(method);
Ian Rogers19846512012-02-24 11:42:47 -08001593 method->SetCode(code);
1594 }
1595 method_index++;
1596 }
1597}
1598
Mathieu Chartier66f19252012-09-18 08:57:04 -07001599static void LinkCode(SirtRef<AbstractMethod>& method, const OatFile::OatClass* oat_class,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001600 uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001601 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001602 // Every kind of method should at least get an invoke stub from the oat_method.
1603 // non-abstract methods also get their code pointers.
1604 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstromae826982011-11-09 01:33:42 -08001605 oat_method.LinkMethodPointers(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001606
Ian Rogers19846512012-02-24 11:42:47 -08001607 Runtime* runtime = Runtime::Current();
Brian Carlstrom92827a52011-10-10 15:50:01 -07001608 if (method->IsAbstract()) {
Ian Rogers19846512012-02-24 11:42:47 -08001609 method->SetCode(runtime->GetAbstractMethodErrorStubArray()->GetData());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001610 return;
1611 }
Ian Rogers19846512012-02-24 11:42:47 -08001612
1613 if (method->IsStatic() && !method->IsConstructor()) {
1614 // For static methods excluding the class initializer, install the trampoline
1615 method->SetCode(runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData());
Ian Rogers0d6de042012-02-29 08:50:26 -08001616 }
1617 if (method->IsNative()) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001618 // unregistering restores the dlsym lookup stub
Ian Rogers19846512012-02-24 11:42:47 -08001619 method->UnregisterNative(Thread::Current());
jeffhao26c0a1a2012-01-17 16:28:33 -08001620 }
1621
1622 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhao725a9572012-11-13 18:20:12 -08001623 Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
1624 instrumentation->SaveAndUpdateCode(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001625 }
1626}
1627
Brian Carlstromf615a612011-07-23 12:50:34 -07001628void ClassLinker::LoadClass(const DexFile& dex_file,
1629 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001630 SirtRef<Class>& klass,
Ian Rogers365c1022012-06-22 15:05:28 -07001631 ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001632 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001633 CHECK(klass->GetDexCache() != NULL);
1634 CHECK_EQ(Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001635 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001636 CHECK(descriptor != NULL);
1637
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001638 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001639 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001640 // Make sure that none of our runtime-only flags are set.
mikaelpeltier6ffd0962012-10-25 15:37:45 +02001641 // TODO: JACK CLASS ACCESS (HACK TO BE REMOVED)
1642 CHECK_EQ(access_flags & ~(kAccJavaFlagsMask | kAccClassJack), 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001643 klass->SetAccessFlags(access_flags);
1644 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001645 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001646 klass->SetStatus(Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001647
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001648 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001649
Ian Rogers0571d352011-11-03 19:51:38 -07001650 // Load fields fields.
1651 const byte* class_data = dex_file.GetClassData(dex_class_def);
1652 if (class_data == NULL) {
1653 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001654 }
Ian Rogers0571d352011-11-03 19:51:38 -07001655 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001656 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001657 if (it.NumStaticFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001658 klass->SetSFields(AllocFieldArray(self, it.NumStaticFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001659 }
1660 if (it.NumInstanceFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001661 klass->SetIFields(AllocFieldArray(self, it.NumInstanceFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001662 }
1663 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001664 SirtRef<Field> sfield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001665 klass->SetStaticField(i, sfield.get());
1666 LoadField(dex_file, it, klass, sfield);
1667 }
1668 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001669 SirtRef<Field> ifield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001670 klass->SetInstanceField(i, ifield.get());
1671 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001672 }
1673
Brian Carlstromf5822582012-03-19 22:34:31 -07001674 UniquePtr<const OatFile::OatClass> oat_class;
1675 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1676 oat_class.reset(GetOatClass(dex_file, descriptor));
1677 }
Ian Rogers19846512012-02-24 11:42:47 -08001678
Ian Rogers0571d352011-11-03 19:51:38 -07001679 // Load methods.
1680 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001681 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001682 klass->SetDirectMethods(AllocAbstractMethodArray(self, it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001683 }
Ian Rogers0571d352011-11-03 19:51:38 -07001684 if (it.NumVirtualMethods() != 0) {
1685 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001686 klass->SetVirtualMethods(AllocMethodArray(self, it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001687 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001688 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001689 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001690 SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001691 klass->SetDirectMethod(i, method.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001692 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001693 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001694 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001695 method->SetMethodIndex(class_def_method_index);
1696 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001697 }
1698 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001699 SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001700 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001701 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001702 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001703 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001704 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001705 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001706 }
1707 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001708}
1709
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001710void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Ian Rogers0571d352011-11-03 19:51:38 -07001711 SirtRef<Class>& klass, SirtRef<Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001712 uint32_t field_idx = it.GetMemberIndex();
1713 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001714 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001715 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001716}
1717
Ian Rogers50b35e22012-10-04 10:09:15 -07001718AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
1719 const ClassDataItemIterator& it,
1720 SirtRef<Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001721 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001722 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001723 StringPiece method_name(dex_file.GetMethodName(method_id));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001724
1725 AbstractMethod* dst = NULL;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001726 if (method_name == "<init>") {
Ian Rogers50b35e22012-10-04 10:09:15 -07001727 dst = AllocConstructor(self);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001728 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001729 dst = AllocMethod(self);
Elliott Hughes80609252011-09-23 17:24:51 -07001730 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07001731 DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
1732
Ian Rogers50b35e22012-10-04 10:09:15 -07001733 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07001734 dst->SetDexMethodIndex(dex_method_idx);
1735 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001736
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001737 if (method_name == "finalize") {
1738 // Create the prototype for a signature of "()V"
1739 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1740 if (void_string_id != NULL) {
1741 const DexFile::TypeId* void_type_id =
1742 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1743 if (void_type_id != NULL) {
1744 std::vector<uint16_t> no_args;
1745 const DexFile::ProtoId* finalizer_proto =
1746 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1747 if (finalizer_proto != NULL) {
1748 // We have the prototype in the dex file
1749 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1750 klass->SetFinalizable();
1751 } else {
1752 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1753 // The Enum class declares a "final" finalize() method to prevent subclasses from
1754 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1755 // subclasses, so we exclude it here.
1756 // We also want to avoid setting the flag on Object, where we know that finalize() is
1757 // empty.
1758 if (klass_descriptor != "Ljava/lang/Object;" &&
1759 klass_descriptor != "Ljava/lang/Enum;") {
1760 klass->SetFinalizable();
1761 }
1762 }
1763 }
1764 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001765 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001766 }
Ian Rogers0571d352011-11-03 19:51:38 -07001767 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001768 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001769
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001770 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001771 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001772 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001773 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001774
1775 CHECK(dst->IsMethod());
1776
Ian Rogers50b35e22012-10-04 10:09:15 -07001777 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001778 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07001779}
1780
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001781void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001782 Thread* self = Thread::Current();
1783 SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001784 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001785}
1786
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001787void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
1788 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001789 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001790 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001791}
1792
Brian Carlstromaded5f72011-10-07 17:15:04 -07001793bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001794 dex_lock_.AssertHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001795 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1796 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001797 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001798 }
1799 }
1800 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001801}
1802
Brian Carlstromaded5f72011-10-07 17:15:04 -07001803bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001804 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001805 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001806}
1807
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001808void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001809 dex_lock_.AssertHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001810 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001811 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001812 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001813 dex_cache->SetDexFile(&dex_file);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001814 Dirty();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001815}
1816
Brian Carlstromaded5f72011-10-07 17:15:04 -07001817void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07001818 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001819 {
Ian Rogers1f539342012-10-03 21:09:42 -07001820 MutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001821 if (IsDexFileRegisteredLocked(dex_file)) {
1822 return;
1823 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001824 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001825 // Don't alloc while holding the lock, since allocation may need to
1826 // suspend all threads and another thread may need the dex_lock_ to
1827 // get to a suspend point.
Ian Rogers50b35e22012-10-04 10:09:15 -07001828 SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001829 {
Ian Rogers1f539342012-10-03 21:09:42 -07001830 MutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001831 if (IsDexFileRegisteredLocked(dex_file)) {
1832 return;
1833 }
1834 RegisterDexFileLocked(dex_file, dex_cache);
1835 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001836}
1837
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001838void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001839 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001840 RegisterDexFileLocked(dex_file, dex_cache);
1841}
1842
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001843DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001844 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001845 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07001846 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1847 DexCache* dex_cache = dex_caches_[i];
1848 if (dex_cache->GetDexFile() == &dex_file) {
1849 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001850 }
1851 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001852 // Search matching by location name.
1853 std::string location(dex_file.GetLocation());
1854 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1855 DexCache* dex_cache = dex_caches_[i];
1856 if (dex_cache->GetDexFile()->GetLocation() == location) {
1857 return dex_cache;
1858 }
1859 }
1860 // Failure, dump diagnostic and abort.
1861 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1862 DexCache* dex_cache = dex_caches_[i];
1863 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
1864 }
1865 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001866 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001867}
1868
Mathieu Chartier66f19252012-09-18 08:57:04 -07001869void ClassLinker::FixupDexCaches(AbstractMethod* resolution_method) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001870 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08001871 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1872 dex_caches_[i]->Fixup(resolution_method);
1873 }
1874}
1875
Ian Rogersc8982582012-09-07 16:53:25 -07001876Class* ClassLinker::InitializePrimitiveClass(Class* primitive_class, Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001877 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07001878 // Must hold lock on object when initializing.
1879 ObjectLock lock(Thread::Current(), primitive_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001880 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001881 primitive_class->SetPrimitiveType(type);
1882 primitive_class->SetStatus(Class::kStatusInitialized);
Ian Rogersc8982582012-09-07 16:53:25 -07001883 Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
1884 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001885 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001886}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001887
Brian Carlstrombe977852011-07-19 14:54:54 -07001888// Create an array class (i.e. the class object for the array, not the
1889// array itself). "descriptor" looks like "[C" or "[[[[B" or
1890// "[Ljava/lang/String;".
1891//
1892// If "descriptor" refers to an array of primitives, look up the
1893// primitive type's internally-generated class object.
1894//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001895// "class_loader" is the class loader of the class that's referring to
1896// us. It's used to ensure that we're looking for the element type in
1897// the right context. It does NOT become the class loader for the
1898// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001899//
1900// Returns NULL with an exception raised on failure.
Ian Rogers365c1022012-06-22 15:05:28 -07001901Class* ClassLinker::CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001902 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001903
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001904 // Identify the underlying component type
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001905 Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001906 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001907 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001908 return NULL;
1909 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001910
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001911 // See if the component type is already loaded. Array classes are
1912 // always associated with the class loader of their underlying
1913 // element type -- an array of Strings goes with the loader for
1914 // java/lang/String -- so we need to look for it there. (The
1915 // caller should have checked for the existence of the class
1916 // before calling here, but they did so with *their* class loader,
1917 // not the component type's loader.)
1918 //
1919 // If we find it, the caller adds "loader" to the class' initiating
1920 // loader list, which should prevent us from going through this again.
1921 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001922 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001923 // are the same, because our caller (FindClass) just did the
1924 // lookup. (Even if we get this wrong we still have correct behavior,
1925 // because we effectively do this lookup again when we add the new
1926 // class to the hash table --- necessary because of possible races with
1927 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001928 if (class_loader != component_type->GetClassLoader()) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001929 Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001930 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001931 return new_class;
1932 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001933 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001934
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001935 // Fill out the fields in the Class.
1936 //
1937 // It is possible to execute some methods against arrays, because
1938 // all arrays are subclasses of java_lang_Object_, so we need to set
1939 // up a vtable. We can just point at the one in java_lang_Object_.
1940 //
1941 // Array classes are simple enough that we don't need to do a full
1942 // link step.
Ian Rogers1f539342012-10-03 21:09:42 -07001943 Thread* self = Thread::Current();
1944 SirtRef<Class> new_class(self, NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001945 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001946 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07001947 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001948 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07001949 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001950 new_class.reset(GetClassRoot(kObjectArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001951 } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
1952 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001953 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]) {
1954 new_class.reset(GetClassRoot(kJavaLangReflectAbstractMethodArrayClass));
Ian Rogers4445a7e2012-10-05 17:19:13 -07001955 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectFieldArrayClass]) {
1956 new_class.reset(GetClassRoot(kJavaLangReflectFieldArrayClass));
1957 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectMethodArrayClass]) {
1958 new_class.reset(GetClassRoot(kJavaLangReflectMethodArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001959 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001960 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001961 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001962 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001963 }
1964 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001965 if (new_class.get() == NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001966 new_class.reset(AllocClass(self, sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001967 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001968 return NULL;
1969 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001970 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001971 }
Ian Rogers1f539342012-10-03 21:09:42 -07001972 ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001973 DCHECK(new_class->GetComponentType() != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001974 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001975 new_class->SetSuperClass(java_lang_Object);
1976 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001977 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001978 new_class->SetClassLoader(component_type->GetClassLoader());
1979 new_class->SetStatus(Class::kStatusInitialized);
1980 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001981 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001982
1983
1984 // All arrays have java/lang/Cloneable and java/io/Serializable as
1985 // interfaces. We need to set that up here, so that stuff like
1986 // "instanceof" works right.
1987 //
1988 // Note: The GC could run during the call to FindSystemClass,
1989 // so we need to make sure the class object is GC-valid while we're in
1990 // there. Do this by clearing the interface list so the GC will just
1991 // think that the entries are null.
1992
1993
1994 // Use the single, global copies of "interfaces" and "iftable"
1995 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07001996 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001997 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001998
1999 // Inherit access flags from the component type. Arrays can't be
2000 // used as a superclass or interface, so we want to add "final"
2001 // and remove "interface".
2002 //
2003 // Don't inherit any non-standard flags (e.g., kAccFinal)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002004 // from component_type. We assume that the array class does not
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002005 // override finalize().
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002006 new_class->SetAccessFlags(((new_class->GetComponentType()->GetAccessFlags() &
2007 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002008
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002009 Class* existing = InsertClass(descriptor, new_class.get(), false);
2010 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002011 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002012 }
2013 // Another thread must have loaded the class after we
2014 // started but before we finished. Abandon what we've
2015 // done.
2016 //
2017 // (Yes, this happens.)
2018
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002019 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002020}
2021
2022Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002023 switch (Primitive::GetType(type)) {
2024 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002025 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002026 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002027 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002028 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002029 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002030 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002031 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002032 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002033 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002034 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002035 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002036 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002037 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002038 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002039 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002040 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002041 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002042 case Primitive::kPrimNot:
2043 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002044 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002045 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002046 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002047 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002048}
2049
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002050Class* ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass, bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002051 if (VLOG_IS_ON(class_linker)) {
Brian Carlstromae826982011-11-09 01:33:42 -08002052 DexCache* dex_cache = klass->GetDexCache();
2053 std::string source;
2054 if (dex_cache != NULL) {
2055 source += " from ";
2056 source += dex_cache->GetLocation()->ToModifiedUtf8();
2057 }
2058 LOG(INFO) << "Loaded class " << descriptor << source;
2059 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002060 size_t hash = StringPieceHash()(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002061 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002062 Table& classes = image_class ? image_classes_ : classes_;
Elliott Hughesf8349362012-06-18 15:00:06 -07002063 Class* existing = LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002064#ifndef NDEBUG
2065 // Check we don't have the class in the other table in error
2066 Table& other_classes = image_class ? classes_ : image_classes_;
Elliott Hughesf8349362012-06-18 15:00:06 -07002067 CHECK(LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002068#endif
2069 if (existing != NULL) {
2070 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002071 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002072 classes.insert(std::make_pair(hash, klass));
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07002073 Dirty();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002074 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002075}
2076
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002077bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
2078 size_t hash = Hash(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002079 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08002080 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08002081 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002082 ClassHelper kh;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002083 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08002084 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002085 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002086 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002087 classes_.erase(it);
2088 return true;
2089 }
2090 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002091 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08002092 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002093 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002094 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002095 image_classes_.erase(it);
2096 return true;
2097 }
2098 }
2099 return false;
2100}
2101
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002102Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
2103 size_t hash = Hash(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002104 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07002105 // TODO: determine if its better to search classes_ or image_classes_ first
Elliott Hughesf8349362012-06-18 15:00:06 -07002106 Class* klass = LookupClassLocked(descriptor, class_loader, hash, classes_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002107 if (klass != NULL) {
2108 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002109 }
Elliott Hughesf8349362012-06-18 15:00:06 -07002110 return LookupClassLocked(descriptor, class_loader, hash, image_classes_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002111}
2112
Elliott Hughesf8349362012-06-18 15:00:06 -07002113Class* ClassLinker::LookupClassLocked(const char* descriptor, const ClassLoader* class_loader,
2114 size_t hash, const Table& classes) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002115 ClassHelper kh(NULL, this);
2116 typedef Table::const_iterator It; // TODO: C++0x auto
2117 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers5d76c432011-10-31 21:42:49 -07002118 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002119 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002120 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002121#ifndef NDEBUG
2122 for (++it; it != end && it->first == hash; ++it) {
Ian Rogersd85016c2012-02-03 18:27:34 -08002123 Class* klass2 = it->second;
2124 kh.ChangeClass(klass2);
2125 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002126 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08002127 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002128 }
2129#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07002130 return klass;
2131 }
2132 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002133 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002134}
2135
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002136void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002137 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002138 size_t hash = Hash(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002139 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002140 typedef Table::const_iterator It; // TODO: C++0x auto
2141 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002142 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002143 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002144 Class* klass = it->second;
2145 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002146 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002147 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002148 }
2149 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002150 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002151 Class* klass = it->second;
2152 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002153 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002154 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002155 }
2156 }
2157}
2158
jeffhao98eacac2011-09-14 16:11:53 -07002159void ClassLinker::VerifyClass(Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002160 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002161 Thread* self = Thread::Current();
2162 ObjectLock lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002163
Ian Rogers9ffb0392012-09-10 11:56:50 -07002164 // Don't attempt to re-verify if already sufficiently verified.
2165 if (klass->IsVerified() ||
2166 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002167 return;
2168 }
2169
Ian Rogers9ffb0392012-09-10 11:56:50 -07002170 // The class might already be erroneous, for example at compile time if we attempted to verify
2171 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002172 if (klass->IsErroneous()) {
2173 ThrowEarlierClassFailure(klass);
2174 return;
2175 }
2176
Ian Rogers9ffb0392012-09-10 11:56:50 -07002177 if (klass->GetStatus() == Class::kStatusResolved) {
2178 klass->SetStatus(Class::kStatusVerifying);
2179 } else {
2180 CHECK_EQ(klass->GetStatus(), Class::kStatusRetryVerificationAtRuntime) << PrettyClass(klass);
2181 CHECK(!Runtime::Current()->IsCompiler());
2182 klass->SetStatus(Class::kStatusVerifyingAtRuntime);
2183 }
jeffhao98eacac2011-09-14 16:11:53 -07002184
Ian Rogers9ffb0392012-09-10 11:56:50 -07002185 // Verify super class.
Ian Rogers1c5eb702012-02-01 09:18:34 -08002186 Class* super = klass->GetSuperClass();
2187 std::string error_msg;
2188 if (super != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002189 // Acquire lock to prevent races on verifying the super class.
Ian Rogers1f539342012-10-03 21:09:42 -07002190 ObjectLock lock(self, super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002191
2192 if (!super->IsVerified() && !super->IsErroneous()) {
2193 Runtime::Current()->GetClassLinker()->VerifyClass(super);
2194 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002195 if (!super->IsCompileTimeVerified()) {
Ian Rogers1c5eb702012-02-01 09:18:34 -08002196 error_msg = "Rejecting class ";
2197 error_msg += PrettyDescriptor(klass);
2198 error_msg += " that attempts to sub-class erroneous class ";
2199 error_msg += PrettyDescriptor(super);
2200 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers1f539342012-10-03 21:09:42 -07002201 SirtRef<Throwable> cause(self, self->GetException());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002202 if (cause.get() != NULL) {
2203 self->ClearException();
2204 }
2205 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2206 if (cause.get() != NULL) {
2207 self->GetException()->SetCause(cause.get());
2208 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08002209 klass->SetStatus(Class::kStatusError);
2210 return;
2211 }
2212 }
2213
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002214 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002215 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002216 Class::Status oat_file_class_status(Class::kStatusNotReady);
2217 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
jeffhaof1e6b7c2012-06-05 18:33:30 -07002218 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
jeffhaoec014232012-09-05 10:42:25 -07002219 if (oat_file_class_status == Class::kStatusError) {
2220 LOG(WARNING) << "Skipping runtime verification of erroneous class " << PrettyDescriptor(klass)
2221 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
2222 error_msg = "Rejecting class ";
2223 error_msg += PrettyDescriptor(klass);
2224 error_msg += " because it failed compile-time verification";
2225 Thread::Current()->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2226 klass->SetStatus(Class::kStatusError);
2227 return;
2228 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002229 if (!preverified) {
2230 verifier_failure = verifier::MethodVerifier::VerifyClass(klass, error_msg);
2231 }
2232 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002233 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
2234 LOG(WARNING) << "Soft verification failure in class " << PrettyDescriptor(klass)
2235 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2236 << " because: " << error_msg;
2237 }
Ian Rogers1f539342012-10-03 21:09:42 -07002238 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002239 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002240 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002241 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
2242 klass->SetStatus(Class::kStatusVerified);
2243 } else {
2244 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2245 // Soft failures at compile time should be retried at runtime. Soft
2246 // failures at runtime will be handled by slow paths in the generated
2247 // code. Set status accordingly.
2248 if (Runtime::Current()->IsCompiler()) {
2249 klass->SetStatus(Class::kStatusRetryVerificationAtRuntime);
2250 } else {
2251 klass->SetStatus(Class::kStatusVerified);
2252 }
2253 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002254 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002255 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002256 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2257 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002258 self->AssertNoPendingException();
Ian Rogers1c5eb702012-02-01 09:18:34 -08002259 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002260 klass->SetStatus(Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002261 }
jeffhao98eacac2011-09-14 16:11:53 -07002262}
2263
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002264bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
2265 Class::Status& oat_file_class_status) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002266 if (!Runtime::Current()->IsStarted()) {
2267 return false;
2268 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002269 if (Runtime::Current()->UseCompileTimeClassPath()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002270 return false;
2271 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002272 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2273 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002274 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002275 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002276 const char* descriptor = ClassHelper(klass).GetDescriptor();
2277 uint32_t class_def_index;
2278 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002279 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002280 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002281 CHECK(oat_class.get() != NULL)
2282 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002283 oat_file_class_status = oat_class->GetStatus();
Ian Rogers9ffb0392012-09-10 11:56:50 -07002284 if (oat_file_class_status == Class::kStatusVerified ||
2285 oat_file_class_status == Class::kStatusInitialized) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002286 return true;
2287 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002288 if (oat_file_class_status == Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002289 // Compile time verification failed with a soft error. Compile time verification can fail
2290 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002291 // class ... {
2292 // Foo x;
2293 // .... () {
2294 // if (...) {
2295 // v1 gets assigned a type of resolved class Foo
2296 // } else {
2297 // v1 gets assigned a type of unresolved class Bar
2298 // }
2299 // iput x = v1
2300 // } }
2301 // when we merge v1 following the if-the-else it results in Conflict
2302 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2303 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2304 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2305 // at compile time).
2306 return false;
2307 }
jeffhao1ac29442012-03-26 11:37:32 -07002308 if (oat_file_class_status == Class::kStatusError) {
2309 // Compile time verification failed with a hard error. This is caused by invalid instructions
2310 // in the class. These errors are unrecoverable.
2311 return false;
2312 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002313 if (oat_file_class_status == Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002314 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2315 // not loading the class.
2316 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2317 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002318 return false;
2319 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002320 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002321 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2322
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002323 return false;
2324}
2325
2326void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
2327 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2328 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2329 }
2330 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2331 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2332 }
2333}
2334
Mathieu Chartier66f19252012-09-18 08:57:04 -07002335void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, AbstractMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002336 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2337 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2338 if (code_item == NULL) {
2339 return; // native or abstract method
2340 }
2341 if (code_item->tries_size_ == 0) {
2342 return; // nothing to process
2343 }
2344 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2345 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2346 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2347 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2348 CatchHandlerIterator iterator(handlers_ptr);
2349 for (; iterator.HasNext(); iterator.Next()) {
2350 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2351 // unresolved exception types will be ignored by exception delivery
2352 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
2353 Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
2354 if (exception_type == NULL) {
2355 DCHECK(Thread::Current()->IsExceptionPending());
2356 Thread::Current()->ClearException();
2357 }
2358 }
2359 }
2360 handlers_ptr = iterator.EndDataPointer();
2361 }
2362}
2363
Mathieu Chartier66f19252012-09-18 08:57:04 -07002364static void CheckProxyConstructor(AbstractMethod* constructor);
2365static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002366
Jesse Wilson95caa792011-10-12 18:14:17 -04002367Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
Mathieu Chartier66f19252012-09-18 08:57:04 -07002368 ClassLoader* loader, ObjectArray<AbstractMethod>* methods,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002369 ObjectArray<ObjectArray<Class> >* throws) {
Ian Rogers1f539342012-10-03 21:09:42 -07002370 Thread* self = Thread::Current();
Ian Rogers50b35e22012-10-04 10:09:15 -07002371 SirtRef<Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2372 sizeof(SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002373 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002374 DCHECK(klass->GetClass() != NULL);
Jesse Wilson95caa792011-10-12 18:14:17 -04002375 klass->SetObjectSize(sizeof(Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002376 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002377 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002378 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002379 klass->SetName(name);
Ian Rogers466bb252011-10-14 03:29:56 -07002380 Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002381 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002382
2383 klass->SetStatus(Class::kStatusIdx);
2384
2385 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2386
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002387 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogers4445a7e2012-10-05 17:19:13 -07002388 klass->SetSFields(AllocFieldArray(self, 2));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002389 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2390 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Ian Rogers50b35e22012-10-04 10:09:15 -07002391 SirtRef<Field> interfaces_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002392 klass->SetStaticField(0, interfaces_sfield.get());
2393 interfaces_sfield->SetDexFieldIndex(0);
2394 interfaces_sfield->SetDeclaringClass(klass.get());
2395 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2396 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Ian Rogers50b35e22012-10-04 10:09:15 -07002397 SirtRef<Field> throws_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002398 klass->SetStaticField(1, throws_sfield.get());
2399 throws_sfield->SetDexFieldIndex(1);
2400 throws_sfield->SetDeclaringClass(klass.get());
2401 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002402
Ian Rogers466bb252011-10-14 03:29:56 -07002403 // Proxies have 1 direct method, the constructor
Ian Rogers4445a7e2012-10-05 17:19:13 -07002404 klass->SetDirectMethods(AllocAbstractMethodArray(self, 1));
Ian Rogers50b35e22012-10-04 10:09:15 -07002405 klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002406
Ian Rogers466bb252011-10-14 03:29:56 -07002407 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002408 size_t num_virtual_methods = methods->GetLength();
Ian Rogers4445a7e2012-10-05 17:19:13 -07002409 klass->SetVirtualMethods(AllocMethodArray(self, num_virtual_methods));
Jesse Wilson95caa792011-10-12 18:14:17 -04002410 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers1f539342012-10-03 21:09:42 -07002411 SirtRef<AbstractMethod> prototype(self, methods->Get(i));
Ian Rogers50b35e22012-10-04 10:09:15 -07002412 klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002413 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002414
2415 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
2416 klass->SetStatus(Class::kStatusLoaded); // Class is now effectively in the loaded state
2417 DCHECK(!Thread::Current()->IsExceptionPending());
2418
2419 // Link the fields and virtual methods, creating vtable and iftables
2420 if (!LinkClass(klass, interfaces)) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002421 klass->SetStatus(Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002422 return NULL;
2423 }
Ian Rogersc8982582012-09-07 16:53:25 -07002424 {
Ian Rogers1f539342012-10-03 21:09:42 -07002425 ObjectLock lock(self, klass.get()); // Must hold lock on object when initializing.
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002426 interfaces_sfield->SetObject(klass.get(), interfaces);
2427 throws_sfield->SetObject(klass.get(), throws);
Ian Rogersc8982582012-09-07 16:53:25 -07002428 klass->SetStatus(Class::kStatusInitialized);
2429 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002430
2431 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002432 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002433 CHECK(klass->GetIFields() == NULL);
2434 CheckProxyConstructor(klass->GetDirectMethod(0));
2435 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers1f539342012-10-03 21:09:42 -07002436 SirtRef<AbstractMethod> prototype(self, methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002437 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2438 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002439
2440 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2441 name->ToModifiedUtf8().c_str()));
2442 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2443
2444 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2445 name->ToModifiedUtf8().c_str()));
2446 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002447
2448 SynthesizedProxyClass* synth_proxy_class = down_cast<SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002449 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002450 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2451 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002452 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002453}
2454
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002455std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
2456 DCHECK(proxy_class->IsProxyClass());
2457 String* name = proxy_class->GetName();
2458 DCHECK(name != NULL);
2459 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2460}
2461
Mathieu Chartier66f19252012-09-18 08:57:04 -07002462AbstractMethod* ClassLinker::FindMethodForProxy(const Class* proxy_class, const AbstractMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002463 DCHECK(proxy_class->IsProxyClass());
2464 DCHECK(proxy_method->IsProxyMethod());
2465 // Locate the dex cache of the original interface/Object
2466 DexCache* dex_cache = NULL;
2467 {
2468 ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers50b35e22012-10-04 10:09:15 -07002469 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002470 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2471 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2472 dex_cache = dex_caches_[i];
2473 break;
2474 }
2475 }
2476 }
2477 CHECK(dex_cache != NULL);
2478 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Mathieu Chartier66f19252012-09-18 08:57:04 -07002479 AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002480 CHECK(resolved_method != NULL);
2481 return resolved_method;
2482}
2483
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002484
Ian Rogers50b35e22012-10-04 10:09:15 -07002485AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self, SirtRef<Class>& klass, Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002486 // Create constructor for Proxy that must initialize h
Mathieu Chartier66f19252012-09-18 08:57:04 -07002487 ObjectArray<AbstractMethod>* proxy_direct_methods = proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002488 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002489 AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002490 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2491 // code_ too)
Ian Rogers50b35e22012-10-04 10:09:15 -07002492 AbstractMethod* constructor = down_cast<AbstractMethod*>(proxy_constructor->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002493 // Make this constructor public and fix the class to be our Proxy version
2494 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002495 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002496 return constructor;
2497}
2498
Mathieu Chartier66f19252012-09-18 08:57:04 -07002499static void CheckProxyConstructor(AbstractMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002500 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002501 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002502 MethodHelper mh(constructor);
2503 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002504 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002505 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002506}
2507
Ian Rogers50b35e22012-10-04 10:09:15 -07002508AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<Class>& klass,
2509 SirtRef<AbstractMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002510 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2511 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002512 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2513 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002514 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002515 // as necessary
Ian Rogers50b35e22012-10-04 10:09:15 -07002516 AbstractMethod* method = down_cast<AbstractMethod*>(prototype->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002517
2518 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2519 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002520 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002521 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002522
Ian Rogers466bb252011-10-14 03:29:56 -07002523 // At runtime the method looks like a reference and argument saving method, clone the code
2524 // related parameters from this method.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002525 AbstractMethod* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07002526 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2527 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2528 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
TDYa1275bb86012012-04-11 05:57:28 -07002529#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers466bb252011-10-14 03:29:56 -07002530 method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
TDYa1275bb86012012-04-11 05:57:28 -07002531#else
Logan Chien7a2a23a2012-06-06 11:01:00 +08002532 OatFile::OatMethod oat_method = GetOatMethodFor(prototype.get());
2533 method->SetCode(oat_method.GetProxyStub());
TDYa1275bb86012012-04-11 05:57:28 -07002534#endif
Ian Rogers16f93672012-02-14 12:29:06 -08002535
Ian Rogersc2b44472011-12-14 21:17:17 -08002536 return method;
2537}
Jesse Wilson95caa792011-10-12 18:14:17 -04002538
Mathieu Chartier66f19252012-09-18 08:57:04 -07002539static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002540 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002541 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002542 CHECK(!prototype->IsFinal());
2543 CHECK(method->IsFinal());
2544 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002545
2546 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2547 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2548 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2549 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2550 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2551 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2552 method->GetDexCacheInitializedStaticStorage());
2553 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2554
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002555 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002556 MethodHelper mh2(prototype.get());
2557 CHECK_STREQ(mh.GetName(), mh2.GetName());
2558 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002559 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002560 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002561}
2562
Ian Rogers0045a292012-03-31 21:08:41 -07002563bool ClassLinker::InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002564 CHECK(klass->IsResolved() || klass->IsErroneous())
Ian Rogers9ffb0392012-09-10 11:56:50 -07002565 << PrettyClass(klass) << ": state=" << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002566
Carl Shapirob5573532011-07-12 18:22:59 -07002567 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002568
Mathieu Chartier66f19252012-09-18 08:57:04 -07002569 AbstractMethod* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002570 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002571 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Ian Rogers1f539342012-10-03 21:09:42 -07002572 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002573
Brian Carlstromd1422f82011-09-28 11:37:09 -07002574 if (klass->GetStatus() == Class::kStatusInitialized) {
2575 return true;
2576 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002577
Brian Carlstromd1422f82011-09-28 11:37:09 -07002578 if (klass->IsErroneous()) {
2579 ThrowEarlierClassFailure(klass);
2580 return false;
2581 }
2582
jeffhaoebe2e0f2012-06-06 15:19:40 -07002583 if (klass->GetStatus() == Class::kStatusResolved ||
2584 klass->GetStatus() == Class::kStatusRetryVerificationAtRuntime) {
jeffhao98eacac2011-09-14 16:11:53 -07002585 VerifyClass(klass);
2586 if (klass->GetStatus() != Class::kStatusVerified) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07002587 if (klass->GetStatus() == Class::kStatusError) {
2588 CHECK(self->IsExceptionPending());
2589 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002590 return false;
2591 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002592 }
2593
Brian Carlstrom25c33252011-09-18 15:58:35 -07002594 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2595 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002596 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002597 // don't bother going to kStatusInitializing. We return false so that
2598 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002599 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2600 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002601 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002602 }
2603
Brian Carlstromd1422f82011-09-28 11:37:09 -07002604 // If the class is kStatusInitializing, either this thread is
2605 // initializing higher up the stack or another thread has beat us
2606 // to initializing and we need to wait. Either way, this
2607 // invocation of InitializeClass will not be responsible for
2608 // running <clinit> and will return.
2609 if (klass->GetStatus() == Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002610 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002611 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002612 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002613 return true;
2614 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002615 // No. That's fine. Wait for another thread to finish initializing.
2616 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002617 }
2618
2619 if (!ValidateSuperClassDescriptors(klass)) {
2620 klass->SetStatus(Class::kStatusError);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002621 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002622 return false;
2623 }
2624
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002625 DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002626
Elliott Hughesdcc24742011-09-07 14:02:44 -07002627 klass->SetClinitThreadId(self->GetTid());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002628 klass->SetStatus(Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002629 }
2630
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002631 uint64_t t0 = NanoTime();
2632
Ian Rogers0045a292012-03-31 21:08:41 -07002633 if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002634 // Super class initialization failed, this can be because we can't run
2635 // super-class class initializers in which case we'll be verified.
2636 // Otherwise this class is erroneous.
2637 if (!can_run_clinit) {
2638 CHECK(klass->IsVerified());
2639 } else {
2640 CHECK(klass->IsErroneous());
2641 }
Ian Rogers3d1548d2012-09-24 14:08:03 -07002642 // Signal to any waiting threads that saw this class as initializing.
Ian Rogers1f539342012-10-03 21:09:42 -07002643 ObjectLock lock(self, klass);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002644 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002645 return false;
2646 }
2647
Ian Rogers0045a292012-03-31 21:08:41 -07002648 bool has_static_field_initializers = InitializeStaticFields(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002649
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002650 if (clinit != NULL) {
Ian Rogers64b6d142012-10-29 16:34:15 -07002651 if (Runtime::Current()->IsStarted()) {
2652 clinit->Invoke(self, NULL, NULL, NULL);
2653 } else {
2654 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
2655 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002656 }
2657
Ian Rogers19846512012-02-24 11:42:47 -08002658 FixupStaticTrampolines(klass);
2659
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002660 uint64_t t1 = NanoTime();
2661
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002662 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002663 {
Ian Rogers1f539342012-10-03 21:09:42 -07002664 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002665
2666 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002667 WrapExceptionInInitializer();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002668 klass->SetStatus(Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002669 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002670 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002671 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2672 RuntimeStats* thread_stats = self->GetStats();
2673 ++global_stats->class_init_count;
2674 ++thread_stats->class_init_count;
2675 global_stats->class_init_time_ns += (t1 - t0);
2676 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogers0045a292012-03-31 21:08:41 -07002677 // Set the class as initialized except if we can't initialize static fields and static field
2678 // initialization is necessary.
2679 if (!can_init_statics && has_static_field_initializers) {
2680 klass->SetStatus(Class::kStatusVerified); // Don't leave class in initializing state.
2681 success = false;
2682 } else {
2683 klass->SetStatus(Class::kStatusInitialized);
2684 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002685 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002686 ClassHelper kh(klass);
2687 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002688 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002689 }
2690 lock.NotifyAll();
2691 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002692 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002693}
2694
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002695bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002696 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002697 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002698 self->AssertNoPendingException();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002699 lock.Wait();
2700
2701 // When we wake up, repeat the test for init-in-progress. If
2702 // there's an exception pending (only possible if
2703 // "interruptShouldThrow" was set), bail out.
2704 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002705 WrapExceptionInInitializer();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002706 klass->SetStatus(Class::kStatusError);
2707 return false;
2708 }
2709 // Spurious wakeup? Go back to waiting.
2710 if (klass->GetStatus() == Class::kStatusInitializing) {
2711 continue;
2712 }
Ian Rogers3d1548d2012-09-24 14:08:03 -07002713 if (klass->GetStatus() == Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
2714 // Compile time initialization failed.
2715 return false;
2716 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002717 if (klass->IsErroneous()) {
2718 // The caller wants an exception, but it was thrown in a
2719 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002720 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002721 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002722 return false;
2723 }
2724 if (klass->IsInitialized()) {
2725 return true;
2726 }
2727 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2728 }
2729 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2730}
2731
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002732bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
2733 if (klass->IsInterface()) {
2734 return true;
2735 }
2736 // begin with the methods local to the superclass
2737 if (klass->HasSuperClass() &&
2738 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
2739 const Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002740 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002741 const AbstractMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08002742 if (method != super->GetVTable()->Get(i) &&
2743 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002744 ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
2745 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2746 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002747 return false;
2748 }
2749 }
2750 }
Ian Rogers9bc81912012-10-11 21:43:36 -07002751 IfTable* iftable = klass->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002752 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07002753 Class* interface = iftable->GetInterface(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002754 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2755 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Ian Rogers9bc81912012-10-11 21:43:36 -07002756 const AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002757 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2758 method->GetDeclaringClass())) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002759 ThrowLinkageError("Class %s method %s resolves differently in interface %s",
2760 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2761 PrettyMethod(method).c_str(),
2762 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002763 return false;
2764 }
2765 }
2766 }
2767 }
2768 return true;
2769}
2770
Ian Rogers595799e2012-01-11 17:32:51 -08002771// Returns true if classes referenced by the signature of the method are the
2772// same classes in klass1 as they are in klass2.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002773bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const AbstractMethod* method,
Ian Rogers595799e2012-01-11 17:32:51 -08002774 const Class* klass1,
2775 const Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002776 if (klass1 == klass2) {
2777 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002778 }
Ian Rogers4445a7e2012-10-05 17:19:13 -07002779 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002780 const DexFile::ProtoId& proto_id =
2781 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002782 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2783 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002784 if (descriptor == NULL) {
2785 break;
2786 }
2787 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2788 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002789 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002790 return false;
2791 }
2792 }
2793 }
2794 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002795 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002796 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002797 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002798 return false;
2799 }
2800 }
2801 return true;
2802}
2803
Ian Rogers595799e2012-01-11 17:32:51 -08002804// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2805bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
2806 const Class* klass1,
2807 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002808 CHECK(descriptor != NULL);
2809 CHECK(klass1 != NULL);
2810 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002811 if (klass1 == klass2) {
2812 return true;
2813 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002814 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002815 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002816 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002817 }
Ian Rogers595799e2012-01-11 17:32:51 -08002818 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
2819 if (found2 == NULL) {
2820 Thread::Current()->ClearException();
2821 }
2822 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002823}
2824
Ian Rogers0045a292012-03-31 21:08:41 -07002825bool ClassLinker::InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002826 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002827 if (!klass->IsInterface() && klass->HasSuperClass()) {
2828 Class* super_class = klass->GetSuperClass();
Ian Rogers9ffb0392012-09-10 11:56:50 -07002829 if (!super_class->IsInitialized()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002830 CHECK(!super_class->IsInterface());
Ian Rogers1f539342012-10-03 21:09:42 -07002831 // Must hold lock on object when initializing and setting status.
2832 ObjectLock lock(Thread::Current(), klass);
Ian Rogers0045a292012-03-31 21:08:41 -07002833 bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002834 // TODO: check for a pending exception
2835 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002836 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002837 // Don't set status to error when we can't run <clinit>.
2838 CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
2839 klass->SetStatus(Class::kStatusVerified);
2840 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002841 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002842 klass->SetStatus(Class::kStatusError);
2843 klass->NotifyAll();
2844 return false;
2845 }
2846 }
2847 }
2848 return true;
2849}
2850
Ian Rogers0045a292012-03-31 21:08:41 -07002851bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields) {
Mathieu Chartier155dfe92012-10-09 14:24:49 -07002852 DCHECK(c != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002853 if (c->IsInitialized()) {
2854 return true;
2855 }
2856
Elliott Hughes5f791332011-09-15 17:45:30 -07002857 Thread* self = Thread::Current();
Elliott Hughes34e06962012-04-09 13:55:55 -07002858 ScopedThreadStateChange tsc(self, kRunnable);
Ian Rogers0045a292012-03-31 21:08:41 -07002859 bool success = InitializeClass(c, can_run_clinit, can_init_fields);
Ian Rogers595799e2012-01-11 17:32:51 -08002860 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002861 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002862 }
2863 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002864}
2865
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002866void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Elliott Hughesa0e18062012-04-13 15:59:59 -07002867 Class* c, SafeMap<uint32_t, Field*>& field_map) {
Ian Rogers365c1022012-06-22 15:05:28 -07002868 ClassLoader* cl = c->GetClassLoader();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002869 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002870 ClassDataItemIterator it(dex_file, class_data);
2871 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002872 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002873 }
2874}
2875
Ian Rogers0045a292012-03-31 21:08:41 -07002876bool ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002877 size_t num_static_fields = klass->NumStaticFields();
2878 if (num_static_fields == 0) {
Ian Rogers0045a292012-03-31 21:08:41 -07002879 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002880 }
Brian Carlstromf615a612011-07-23 12:50:34 -07002881 DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002882 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002883 if (dex_cache == NULL) {
Ian Rogers0045a292012-03-31 21:08:41 -07002884 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002885 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002886 ClassHelper kh(klass);
2887 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002888 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002889 const DexFile& dex_file = kh.GetDexFile();
Brian Carlstrom88f36542012-10-16 23:24:21 -07002890 EncodedStaticFieldValueIterator it(dex_file, dex_cache, klass->GetClassLoader(),
2891 this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002892
Ian Rogers0571d352011-11-03 19:51:38 -07002893 if (it.HasNext()) {
2894 // 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 -07002895 SafeMap<uint32_t, Field*> field_map;
Ian Rogers0571d352011-11-03 19:51:38 -07002896 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
2897 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002898 it.ReadValueToField(field_map.Get(i));
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002899 }
Ian Rogers0045a292012-03-31 21:08:41 -07002900 return true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002901 }
Ian Rogers0045a292012-03-31 21:08:41 -07002902 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002903}
2904
Ian Rogersc2b44472011-12-14 21:17:17 -08002905bool ClassLinker::LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002906 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002907 if (!LinkSuperClass(klass)) {
2908 return false;
2909 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002910 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002911 return false;
2912 }
2913 if (!LinkInstanceFields(klass)) {
2914 return false;
2915 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07002916 if (!LinkStaticFields(klass)) {
2917 return false;
2918 }
2919 CreateReferenceInstanceOffsets(klass);
2920 CreateReferenceStaticOffsets(klass);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002921 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
2922 klass->SetStatus(Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002923 return true;
2924}
2925
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002926bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002927 CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002928 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
2929 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08002930 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002931 uint16_t super_class_idx = class_def->superclass_idx_;
2932 if (super_class_idx != DexFile::kDexNoIndex16) {
2933 Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002934 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07002935 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002936 return false;
2937 }
Ian Rogersbe125a92012-01-11 15:19:49 -08002938 // Verify
2939 if (!klass->CanAccess(super_class)) {
2940 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2941 "Class %s extended by class %s is inaccessible",
2942 PrettyDescriptor(super_class).c_str(),
2943 PrettyDescriptor(klass.get()).c_str());
2944 return false;
2945 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002946 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002947 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002948 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
2949 if (interfaces != NULL) {
2950 for (size_t i = 0; i < interfaces->Size(); i++) {
2951 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
2952 Class* interface = ResolveType(dex_file, idx, klass.get());
2953 if (interface == NULL) {
2954 DCHECK(Thread::Current()->IsExceptionPending());
2955 return false;
2956 }
2957 // Verify
2958 if (!klass->CanAccess(interface)) {
2959 // TODO: the RI seemed to ignore this in my testing.
2960 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2961 "Interface %s implemented by class %s is inaccessible",
2962 PrettyDescriptor(interface).c_str(),
2963 PrettyDescriptor(klass.get()).c_str());
2964 return false;
2965 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002966 }
2967 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002968 // Mark the class as loaded.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002969 klass->SetStatus(Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002970 return true;
2971}
2972
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002973bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002974 CHECK(!klass->IsPrimitive());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002975 Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002976 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002977 if (super != NULL) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002978 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002979 "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002980 return false;
2981 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002982 return true;
2983 }
2984 if (super == NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002985 ThrowLinkageError("No superclass defined for class %s", PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002986 return false;
2987 }
2988 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002989 if (super->IsFinal() || super->IsInterface()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002990 Thread* self = Thread::Current();
2991 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002992 "Superclass %s of %s is %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002993 PrettyDescriptor(super).c_str(),
2994 PrettyDescriptor(klass.get()).c_str(),
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002995 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002996 return false;
2997 }
2998 if (!klass->CanAccess(super)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002999 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07003000 "Superclass %s is inaccessible by %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003001 PrettyDescriptor(super).c_str(),
3002 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003003 return false;
3004 }
Elliott Hughes20cde902011-10-04 17:37:27 -07003005
3006 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3007 if (super->IsFinalizable()) {
3008 klass->SetFinalizable();
3009 }
3010
Elliott Hughes2da50362011-10-10 16:57:08 -07003011 // Inherit reference flags (if any) from the superclass.
3012 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3013 if (reference_flags != 0) {
3014 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3015 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003016 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07003017 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003018 ThrowLinkageError("Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003019 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003020 return false;
3021 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003022
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003023#ifndef NDEBUG
3024 // Ensure super classes are fully resolved prior to resolving fields..
3025 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003026 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003027 super = super->GetSuperClass();
3028 }
3029#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003030 return true;
3031}
3032
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003033// Populate the class vtable and itable. Compute return type indices.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003034bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003035 if (klass->IsInterface()) {
3036 // No vtable.
3037 size_t count = klass->NumVirtualMethods();
3038 if (!IsUint(16, count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08003039 ThrowClassFormatError("Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003040 return false;
3041 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003042 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003043 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003044 }
jeffhaobdb76512011-09-07 11:43:16 -07003045 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003046 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003047 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003048 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003049 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003050 }
3051 return true;
3052}
3053
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003054bool ClassLinker::LinkVirtualMethods(SirtRef<Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003055 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003056 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003057 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3058 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003059 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003060 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers1f539342012-10-03 21:09:42 -07003061 SirtRef<ObjectArray<AbstractMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003062 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003063 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003064 MethodHelper local_mh(NULL, this);
3065 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003066 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003067 AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003068 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003069 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003070 for (; j < actual_count; ++j) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003071 AbstractMethod* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003072 super_mh.ChangeMethod(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003073 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3074 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3075 if (super_method->IsFinal()) {
3076 ThrowLinkageError("Method %s overrides final method in class %s",
3077 PrettyMethod(local_method).c_str(),
3078 super_mh.GetDeclaringClassDescriptor());
3079 return false;
3080 }
3081 vtable->Set(j, local_method);
3082 local_method->SetMethodIndex(j);
3083 break;
3084 } else {
3085 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3086 << " would have incorrectly overridden the package-private method in "
3087 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003088 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003089 }
3090 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003091 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003092 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003093 vtable->Set(actual_count, local_method);
3094 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003095 actual_count += 1;
3096 }
3097 }
3098 if (!IsUint(16, actual_count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08003099 ThrowClassFormatError("Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003100 return false;
3101 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003102 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003103 CHECK_LE(actual_count, max_count);
3104 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003105 vtable.reset(vtable->CopyOf(self, actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003106 }
Ian Rogers30fab402012-01-23 15:43:46 -08003107 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003108 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003109 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003110 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003111 if (!IsUint(16, num_virtual_methods)) {
Elliott Hughese555dc02011-09-25 10:46:35 -07003112 ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003113 return false;
3114 }
Ian Rogers1f539342012-10-03 21:09:42 -07003115 SirtRef<ObjectArray<AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07003116 vtable(self, AllocMethodArray(self, num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003117 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003118 AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003119 vtable->Set(i, virtual_method);
3120 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003121 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003122 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003123 }
3124 return true;
3125}
3126
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003127bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003128 size_t super_ifcount;
3129 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003130 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003131 } else {
3132 super_ifcount = 0;
3133 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003134 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003135 ClassHelper kh(klass.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -07003136 uint32_t num_interfaces = interfaces == NULL ? kh.NumDirectInterfaces() : interfaces->GetLength();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003137 ifcount += num_interfaces;
3138 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogersd24e2642012-06-06 21:21:43 -07003139 Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003140 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003141 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003142 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003143 // Class implements no interfaces.
3144 DCHECK_EQ(klass->GetIfTableCount(), 0);
3145 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003146 return true;
3147 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003148 if (ifcount == super_ifcount) {
3149 // Class implements same interfaces as parent, are any of these not marker interfaces?
3150 bool has_non_marker_interface = false;
3151 IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
3152 for (size_t i = 0; i < ifcount; ++i) {
3153 if (super_iftable->GetMethodArrayCount(i) > 0) {
3154 has_non_marker_interface = true;
3155 break;
3156 }
3157 }
3158 if (!has_non_marker_interface) {
3159 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3160 klass->SetIfTable(super_iftable);
3161 return true;
3162 }
3163 }
Ian Rogers1f539342012-10-03 21:09:42 -07003164 Thread* self = Thread::Current();
Ian Rogers9bc81912012-10-11 21:43:36 -07003165 SirtRef<IfTable> iftable(self, AllocIfTable(self, ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003166 if (super_ifcount != 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003167 IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003168 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003169 Class* super_interface = super_iftable->GetInterface(i);
3170 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003171 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003172 }
3173 // Flatten the interface inheritance hierarchy.
3174 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003175 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogersd24e2642012-06-06 21:21:43 -07003176 Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003177 DCHECK(interface != NULL);
3178 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003179 ClassHelper ih(interface);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08003180 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003181 "Class %s implements non-interface class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003182 PrettyDescriptor(klass.get()).c_str(),
3183 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003184 return false;
3185 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003186 // Check if interface is already in iftable
3187 bool duplicate = false;
3188 for (size_t j = 0; j < idx; j++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003189 Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003190 if (existing_interface == interface) {
3191 duplicate = true;
3192 break;
3193 }
3194 }
3195 if (!duplicate) {
3196 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003197 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003198 // Add this interface's non-duplicate super-interfaces.
3199 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003200 Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003201 bool super_duplicate = false;
3202 for (size_t k = 0; k < idx; k++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003203 Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003204 if (existing_interface == super_interface) {
3205 super_duplicate = true;
3206 break;
3207 }
3208 }
3209 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003210 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003211 }
3212 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003213 }
3214 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003215 // Shrink iftable in case duplicates were found
3216 if (idx < ifcount) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003217 iftable.reset(down_cast<IfTable*>(iftable->CopyOf(self, idx * IfTable::kMax)));
Ian Rogersb52b01a2012-01-12 17:01:38 -08003218 ifcount = idx;
3219 } else {
3220 CHECK_EQ(idx, ifcount);
3221 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003222 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003223
3224 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003225 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003226 return true;
3227 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07003228 std::vector<AbstractMethod*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003229 MethodHelper vtable_mh(NULL, this);
3230 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003231 for (size_t i = 0; i < ifcount; ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003232 Class* interface = iftable->GetInterface(i);
3233 size_t num_methods = interface->NumVirtualMethods();
3234 if (num_methods > 0) {
3235 ObjectArray<AbstractMethod>* method_array = AllocMethodArray(self, num_methods);
3236 iftable->SetMethodArray(i, method_array);
3237 ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
3238 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
3239 AbstractMethod* interface_method = interface->GetVirtualMethod(j);
3240 interface_mh.ChangeMethod(interface_method);
3241 int32_t k;
3242 // For each method listed in the interface's method list, find the
3243 // matching method in our class's method list. We want to favor the
3244 // subclass over the superclass, which just requires walking
3245 // back from the end of the vtable. (This only matters if the
3246 // superclass defines a private method and this class redefines
3247 // it -- otherwise it would use the same vtable slot. In .dex files
3248 // those don't end up in the virtual method table, so it shouldn't
3249 // matter which direction we go. We walk it backward anyway.)
3250 for (k = vtable->GetLength() - 1; k >= 0; --k) {
3251 AbstractMethod* vtable_method = vtable->Get(k);
3252 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003253 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003254 if (!vtable_method->IsPublic()) {
3255 self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
3256 "Implementation not public: %s",
3257 PrettyMethod(vtable_method).c_str());
3258 return false;
3259 }
3260 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003261 break;
3262 }
3263 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003264 if (k < 0) {
3265 SirtRef<AbstractMethod> miranda_method(self, NULL);
3266 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
3267 AbstractMethod* mir_method = miranda_list[mir];
3268 vtable_mh.ChangeMethod(mir_method);
3269 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3270 miranda_method.reset(miranda_list[mir]);
3271 break;
3272 }
3273 }
3274 if (miranda_method.get() == NULL) {
3275 // point the interface table at a phantom slot
3276 miranda_method.reset(down_cast<AbstractMethod*>(interface_method->Clone(self)));
3277 miranda_list.push_back(miranda_method.get());
3278 }
3279 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003280 }
3281 }
3282 }
3283 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003284 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003285 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003286 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07003287 klass->SetVirtualMethods((old_method_count == 0)
Ian Rogers4445a7e2012-10-05 17:19:13 -07003288 ? AllocMethodArray(self, new_method_count)
Ian Rogers50b35e22012-10-04 10:09:15 -07003289 : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003290
Ian Rogers1f539342012-10-03 21:09:42 -07003291 SirtRef<ObjectArray<AbstractMethod> > vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003292 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003293 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003294 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003295 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07003296 for (size_t i = 0; i < miranda_list.size(); ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003297 AbstractMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003298 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003299 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3300 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3301 klass->SetVirtualMethod(old_method_count + i, method);
3302 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003303 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003304 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003305 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003306 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003307
Mathieu Chartier66f19252012-09-18 08:57:04 -07003308 ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003309 for (int i = 0; i < vtable->GetLength(); ++i) {
3310 CHECK(vtable->Get(i) != NULL);
3311 }
3312
3313// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3314
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003315 return true;
3316}
3317
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003318bool ClassLinker::LinkInstanceFields(SirtRef<Class>& klass) {
3319 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003320 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003321}
3322
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003323bool ClassLinker::LinkStaticFields(SirtRef<Class>& klass) {
3324 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003325 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003326 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003327 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003328 return success;
3329}
3330
Brian Carlstromdbc05252011-09-09 01:59:59 -07003331struct LinkFieldsComparator {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003332 explicit LinkFieldsComparator(FieldHelper* fh)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003333 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003334 : fh_(fh) {}
3335 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
3336 bool operator()(const Field* field1, const Field* field2) NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003337 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003338 fh_->ChangeField(field1);
3339 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3340 fh_->ChangeField(field2);
3341 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003342 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3343 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3344 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3345 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003346 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3347 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3348 if (order1 != order2) {
3349 return order1 < order2;
3350 }
3351
3352 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003353 fh_->ChangeField(field1);
3354 StringPiece name1(fh_->GetName());
3355 fh_->ChangeField(field2);
3356 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003357 return name1 < name2;
3358 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003359
3360 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003361};
3362
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003363bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003364 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003365 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003366
3367 ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003368 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003369
3370 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003371 size_t size;
3372 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003373 if (is_static) {
3374 size = klass->GetClassSize();
3375 field_offset = Class::FieldsOffset();
3376 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003377 Class* super_class = klass->GetSuperClass();
3378 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003379 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003380 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003381 }
3382 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003383 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003384
Brian Carlstromdbc05252011-09-09 01:59:59 -07003385 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003386
Brian Carlstromdbc05252011-09-09 01:59:59 -07003387 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003388 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromdbc05252011-09-09 01:59:59 -07003389 std::deque<Field*> grouped_and_sorted_fields;
3390 for (size_t i = 0; i < num_fields; i++) {
3391 grouped_and_sorted_fields.push_back(fields->Get(i));
3392 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003393 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003394 std::sort(grouped_and_sorted_fields.begin(),
3395 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003396 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003397
3398 // References should be at the front.
3399 size_t current_field = 0;
3400 size_t num_reference_fields = 0;
3401 for (; current_field < num_fields; current_field++) {
3402 Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003403 fh.ChangeField(field);
3404 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003405 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003406 if (isPrimitive) {
3407 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003408 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003409 grouped_and_sorted_fields.pop_front();
3410 num_reference_fields++;
3411 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003412 field->SetOffset(field_offset);
3413 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003414 }
3415
3416 // Now we want to pack all of the double-wide fields together. If
3417 // we're not aligned, though, we want to shuffle one 32-bit field
3418 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003419 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003420 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
3421 Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003422 fh.ChangeField(field);
3423 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003424 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3425 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003426 continue;
3427 }
3428 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003429 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003430 // drop the consumed field
3431 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3432 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003433 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003434 // whether we found a 32-bit field for padding or not, we advance
3435 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003436 }
3437
3438 // Alignment is good, shuffle any double-wide fields forward, and
3439 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003440 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003441 while (!grouped_and_sorted_fields.empty()) {
3442 Field* field = grouped_and_sorted_fields.front();
3443 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003444 fh.ChangeField(field);
3445 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003446 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003447 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003448 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003449 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003450 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003451 ? sizeof(uint64_t)
3452 : sizeof(uint32_t)));
3453 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003454 }
3455
Elliott Hughesadb460d2011-10-05 17:02:34 -07003456 // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
Ian Rogers64b6d142012-10-29 16:34:15 -07003457 if (!is_static &&
3458 StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003459 // We know there are no non-reference fields in the Reference classes, and we know
3460 // that 'referent' is alphabetically last, so this is easy...
3461 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003462 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003463 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003464 --num_reference_fields;
3465 }
3466
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003467#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003468 // Make sure that all reference fields appear before
3469 // non-reference fields, and all double-wide fields are aligned.
3470 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003471 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003472 Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003473 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003474 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003475 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003476 << " field=" << PrettyField(field)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003477 << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
3478 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003479 fh.ChangeField(field);
3480 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003481 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers64b6d142012-10-29 16:34:15 -07003482 if (StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;" &&
3483 StringPiece(fh.GetName()) == "referent") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003484 is_primitive = true; // We lied above, so we have to expect a lie here.
3485 }
3486 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003487 if (!seen_non_ref) {
3488 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003489 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003490 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003491 } else {
3492 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003493 }
3494 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003495 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003496 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003497 }
3498#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003499 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003500 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003501 if (is_static) {
3502 klass->SetNumReferenceStaticFields(num_reference_fields);
3503 klass->SetClassSize(size);
3504 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003505 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003506 if (!klass->IsVariableSize()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003507 klass->SetObjectSize(size);
3508 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003509 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003510 return true;
3511}
3512
3513// Set the bitmap of reference offsets, refOffsets, from the ifields
3514// list.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003515void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003516 uint32_t reference_offsets = 0;
3517 Class* super_class = klass->GetSuperClass();
3518 if (super_class != NULL) {
3519 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003520 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003521 if (reference_offsets == CLASS_WALK_SUPER) {
3522 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003523 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003524 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003525 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003526 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003527}
3528
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003529void ClassLinker::CreateReferenceStaticOffsets(SirtRef<Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003530 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003531}
3532
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003533void ClassLinker::CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003534 uint32_t reference_offsets) {
3535 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003536 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3537 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003538 const ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003539 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003540 // All of the fields that contain object references are guaranteed
3541 // to be at the beginning of the fields list.
3542 for (size_t i = 0; i < num_reference_fields; ++i) {
3543 // Note that byte_offset is the offset from the beginning of
3544 // object, not the offset into instance data
3545 const Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003546 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003547 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3548 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3549 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003550 CHECK_NE(new_bit, 0U);
3551 reference_offsets |= new_bit;
3552 } else {
3553 reference_offsets = CLASS_WALK_SUPER;
3554 break;
3555 }
3556 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003557 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003558 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003559 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003560 } else {
3561 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003562 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003563}
3564
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003565String* ClassLinker::ResolveString(const DexFile& dex_file,
Elliott Hughescf4c6c42011-09-01 15:16:42 -07003566 uint32_t string_idx, DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003567 DCHECK(dex_cache != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003568 String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003569 if (resolved != NULL) {
3570 return resolved;
3571 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003572 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3573 int32_t utf16_length = dex_file.GetStringLength(string_id);
3574 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom928bf022011-10-11 02:48:14 -07003575 String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003576 dex_cache->SetResolvedString(string_idx, string);
3577 return string;
3578}
3579
3580Class* ClassLinker::ResolveType(const DexFile& dex_file,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003581 uint16_t type_idx,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003582 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003583 ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003584 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003585 Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003586 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003587 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003588 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003589 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003590 // TODO: we used to throw here if resolved's class loader was not the
3591 // boot class loader. This was to permit different classes with the
3592 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003593 dex_cache->SetResolvedType(type_idx, resolved);
3594 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08003595 CHECK(Thread::Current()->IsExceptionPending())
3596 << "Expected pending exception for failed resolution of: " << descriptor;
jeffhao8cd6dda2012-02-22 10:15:34 -08003597 // Convert a ClassNotFoundException to a NoClassDefFoundError
3598 if (Thread::Current()->GetException()->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
3599 Thread::Current()->ClearException();
3600 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
3601 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003602 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003603 }
3604 return resolved;
3605}
3606
Mathieu Chartier66f19252012-09-18 08:57:04 -07003607AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
Ian Rogers4c5b2652012-12-15 21:36:16 -08003608 uint32_t method_idx,
3609 DexCache* dex_cache,
3610 ClassLoader* class_loader,
3611 const AbstractMethod* referrer,
3612 InvokeType type) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003613 DCHECK(dex_cache != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07003614 // Check for hit in the dex cache.
Mathieu Chartier66f19252012-09-18 08:57:04 -07003615 AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003616 if (resolved != NULL) {
3617 return resolved;
3618 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003619 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003620 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
3621 Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
3622 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003623 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003624 return NULL;
3625 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003626 // Scan using method_idx, this saves string compares but will only hit for matching dex
3627 // caches/files.
3628 switch (type) {
3629 case kDirect: // Fall-through.
3630 case kStatic:
3631 resolved = klass->FindDirectMethod(dex_cache, method_idx);
3632 break;
3633 case kInterface:
3634 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Ian Rogers4c5b2652012-12-15 21:36:16 -08003635 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07003636 break;
3637 case kSuper: // Fall-through.
3638 case kVirtual:
3639 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
3640 break;
3641 default:
3642 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003643 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003644 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07003645 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003646 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3647 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
Ian Rogers08f753d2012-08-24 14:35:25 -07003648 switch (type) {
3649 case kDirect: // Fall-through.
3650 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08003651 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003652 break;
3653 case kInterface:
3654 resolved = klass->FindInterfaceMethod(name, signature);
Ian Rogers4c5b2652012-12-15 21:36:16 -08003655 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07003656 break;
3657 case kSuper: // Fall-through.
3658 case kVirtual:
3659 resolved = klass->FindVirtualMethod(name, signature);
3660 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003661 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003662 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003663 if (resolved != NULL) {
3664 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07003665 if (resolved->CheckIncompatibleClassChange(type)) {
3666 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07003667 }
3668 }
3669 if (resolved != NULL) {
3670 // Be a good citizen and update the dex cache to speed subsequent calls.
3671 dex_cache->SetResolvedMethod(method_idx, resolved);
3672 return resolved;
3673 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07003674 // We failed to find the method which means either an access error, an incompatible class
3675 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07003676 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3677 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3678 switch (type) {
3679 case kDirect:
3680 case kStatic:
3681 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07003682 break;
3683 case kInterface:
3684 case kVirtual:
3685 case kSuper:
3686 resolved = klass->FindDirectMethod(name, signature);
3687 break;
3688 }
3689
3690 // If we found something, check that it can be accessed by the referrer.
3691 if (resolved != NULL && referrer != NULL) {
3692 Class* methods_class = resolved->GetDeclaringClass();
3693 Class* referring_class = referrer->GetDeclaringClass();
3694 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003695 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
3696 referrer, resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07003697 return NULL;
3698 } else if (!referring_class->CanAccessMember(methods_class,
3699 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003700 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07003701 return NULL;
3702 }
3703 }
3704
3705 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
3706 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
3707 switch (type) {
3708 case kDirect:
3709 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07003710 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003711 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003712 } else {
3713 resolved = klass->FindInterfaceMethod(name, signature);
3714 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003715 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003716 } else {
Ian Rogers2fc14272012-08-30 10:56:57 -07003717 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003718 }
3719 }
3720 break;
3721 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07003722 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003723 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003724 } else {
3725 resolved = klass->FindVirtualMethod(name, signature);
3726 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003727 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003728 } else {
Ian Rogers2fc14272012-08-30 10:56:57 -07003729 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003730 }
3731 }
3732 break;
3733 case kSuper:
Ian Rogers2fc14272012-08-30 10:56:57 -07003734 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003735 break;
3736 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07003737 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003738 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003739 } else {
3740 resolved = klass->FindInterfaceMethod(name, signature);
3741 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003742 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003743 } else {
Ian Rogers2fc14272012-08-30 10:56:57 -07003744 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003745 }
3746 }
3747 break;
3748 }
3749 DCHECK(Thread::Current()->IsExceptionPending());
3750 return NULL;
3751 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003752}
3753
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003754Field* ClassLinker::ResolveField(const DexFile& dex_file,
3755 uint32_t field_idx,
3756 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003757 ClassLoader* class_loader,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003758 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003759 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003760 Field* resolved = dex_cache->GetResolvedField(field_idx);
3761 if (resolved != NULL) {
3762 return resolved;
3763 }
3764 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3765 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3766 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003767 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003768 return NULL;
3769 }
3770
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003771 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003772 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003773 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003774 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003775 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003776
3777 if (resolved == NULL) {
3778 const char* name = dex_file.GetFieldName(field_id);
3779 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3780 if (is_static) {
3781 resolved = klass->FindStaticField(name, type);
3782 } else {
3783 resolved = klass->FindInstanceField(name, type);
3784 }
3785 if (resolved == NULL) {
3786 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3787 return NULL;
3788 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003789 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003790 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003791 return resolved;
3792}
3793
3794Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3795 uint32_t field_idx,
3796 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003797 ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003798 DCHECK(dex_cache != NULL);
Ian Rogersb067ac22011-12-13 18:05:09 -08003799 Field* resolved = dex_cache->GetResolvedField(field_idx);
3800 if (resolved != NULL) {
3801 return resolved;
3802 }
3803 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3804 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3805 if (klass == NULL) {
3806 DCHECK(Thread::Current()->IsExceptionPending());
3807 return NULL;
3808 }
3809
3810 const char* name = dex_file.GetFieldName(field_id);
3811 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3812 resolved = klass->FindField(name, type);
3813 if (resolved != NULL) {
3814 dex_cache->SetResolvedField(field_idx, resolved);
3815 } else {
3816 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003817 }
3818 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003819}
3820
Mathieu Chartier66f19252012-09-18 08:57:04 -07003821const char* ClassLinker::MethodShorty(uint32_t method_idx, AbstractMethod* referrer, uint32_t* length) {
Ian Rogersad25ac52011-10-04 19:13:33 -07003822 Class* declaring_class = referrer->GetDeclaringClass();
3823 DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07003824 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07003825 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003826 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003827}
3828
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003829void ClassLinker::DumpAllClasses(int flags) const {
3830 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3831 // lock held, because it might need to resolve a field's type, which would try to take the lock.
3832 std::vector<Class*> all_classes;
3833 {
Ian Rogers50b35e22012-10-04 10:09:15 -07003834 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003835 typedef Table::const_iterator It; // TODO: C++0x auto
3836 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3837 all_classes.push_back(it->second);
3838 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003839 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3840 all_classes.push_back(it->second);
3841 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003842 }
3843
3844 for (size_t i = 0; i < all_classes.size(); ++i) {
3845 all_classes[i]->DumpClass(std::cerr, flags);
3846 }
3847}
3848
Elliott Hughescac6cc72011-11-03 20:31:21 -07003849void ClassLinker::DumpForSigQuit(std::ostream& os) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07003850 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -07003851 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3852 << classes_.size() << " allocated classes\n";
3853}
3854
Elliott Hughese27955c2011-08-26 15:21:24 -07003855size_t ClassLinker::NumLoadedClasses() const {
Ian Rogers50b35e22012-10-04 10:09:15 -07003856 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003857 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003858}
3859
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003860pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07003861 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003862}
3863
3864pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003865 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003866}
3867
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003868void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
3869 DCHECK(!init_done_);
3870
3871 DCHECK(klass != NULL);
3872 DCHECK(klass->GetClassLoader() == NULL);
3873
3874 DCHECK(class_roots_ != NULL);
3875 DCHECK(class_roots_->Get(class_root) == NULL);
3876 class_roots_->Set(class_root, klass);
3877}
3878
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003879} // namespace art