blob: dc86aed4a1a597ae9285f8caca6bc44a24a021e8 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "class_linker.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070018
Brian Carlstromd601af82012-01-06 10:15:19 -080019#include <fcntl.h>
20#include <sys/file.h>
21#include <sys/stat.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080022#include <sys/types.h>
23#include <sys/wait.h>
24
Brian Carlstromdbc05252011-09-09 01:59:59 -070025#include <deque>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070026#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070027#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070028#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070029
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070030#include "casts.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070031#include "class_loader.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080032#include "debugger.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070033#include "dex_cache.h"
Elliott Hughes90a33692011-08-30 13:27:07 -070034#include "dex_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070035#include "heap.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070036#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070037#include "interpreter/interpreter.h"
Ian Rogers0571d352011-11-03 19:51:38 -070038#include "leb128.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070039#include "logging.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070040#include "oat_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070041#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080042#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080043#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070044#include "runtime.h"
Ian Rogers466bb252011-10-14 03:29:56 -070045#include "runtime_support.h"
TDYa1275bb86012012-04-11 05:57:28 -070046#if defined(ART_USE_LLVM_COMPILER)
47#include "compiler_llvm/runtime_support_llvm.h"
48#endif
Elliott Hughes4d0207c2011-10-03 19:14:34 -070049#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070050#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070051#include "sirt_ref.h"
Mathieu Chartier7469ebf2012-09-24 16:28:36 -070052#include "gc/space.h"
53#include "gc/space_bitmap.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070054#include "stack_indirect_reference_table.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070055#include "stl_util.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070056#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070057#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070058#include "utils.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070059#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070060
61namespace art {
62
Ian Rogers00f7d0e2012-07-19 15:28:27 -070063static void ThrowNoClassDefFoundError(const char* fmt, ...)
64 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070065 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070066static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070067 va_list args;
68 va_start(args, fmt);
69 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
70 va_end(args);
71}
72
Ian Rogers00f7d0e2012-07-19 15:28:27 -070073static void ThrowClassFormatError(const char* fmt, ...)
74 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070075 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070076static void ThrowClassFormatError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070077 va_list args;
78 va_start(args, fmt);
Elliott Hughese555dc02011-09-25 10:46:35 -070079 Thread::Current()->ThrowNewExceptionV("Ljava/lang/ClassFormatError;", fmt, args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -070080 va_end(args);
81}
82
Ian Rogers00f7d0e2012-07-19 15:28:27 -070083static void ThrowLinkageError(const char* fmt, ...)
84 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070085 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070086static void ThrowLinkageError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070087 va_list args;
88 va_start(args, fmt);
89 Thread::Current()->ThrowNewExceptionV("Ljava/lang/LinkageError;", fmt, args);
90 va_end(args);
91}
92
Elliott Hughes0512f022012-03-15 22:10:52 -070093static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
Ian Rogers00f7d0e2012-07-19 15:28:27 -070094 const StringPiece& name)
Ian Rogersb726dcb2012-09-05 08:57:23 -070095 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers9f1ab122011-12-12 08:52:43 -080096 ClassHelper kh(c);
97 std::ostringstream msg;
Ian Rogers08f753d2012-08-24 14:35:25 -070098 msg << "No " << scope << "field " << name << " of type " << type
Ian Rogers9f1ab122011-12-12 08:52:43 -080099 << " in class " << kh.GetDescriptor() << " or its superclasses";
100 std::string location(kh.GetLocation());
101 if (!location.empty()) {
102 msg << " (defined in " << location << ")";
103 }
104 Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
105}
106
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700107static void ThrowNullPointerException(const char* fmt, ...)
108 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -0700109 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -0700110static void ThrowNullPointerException(const char* fmt, ...) {
Ian Rogerscab01012012-01-10 17:35:46 -0800111 va_list args;
112 va_start(args, fmt);
113 Thread::Current()->ThrowNewExceptionV("Ljava/lang/NullPointerException;", fmt, args);
114 va_end(args);
115}
116
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700117static void ThrowEarlierClassFailure(Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700118 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -0700119 // The class failed to initialize on a previous attempt, so we want to throw
120 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
121 // failed in verification, in which case v2 5.4.1 says we need to re-throw
122 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -0700123 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
124 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
125 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700126
Elliott Hughes5c599942012-06-13 16:45:05 -0700127 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700128 if (c->GetVerifyErrorClass() != NULL) {
129 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800130 ClassHelper ve_ch(c->GetVerifyErrorClass());
131 std::string error_descriptor(ve_ch.GetDescriptor());
132 Thread::Current()->ThrowNewException(error_descriptor.c_str(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700133 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800134 ThrowNoClassDefFoundError("%s", PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700135 }
136}
137
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700138static void WrapExceptionInInitializer()
Ian Rogersb726dcb2012-09-05 08:57:23 -0700139 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700140 Thread* self = Thread::Current();
141 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700142
143 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
144 CHECK(cause.get() != NULL);
145
146 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700147 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
148 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700149
Elliott Hughesa4f94742012-05-29 16:28:38 -0700150 // We only wrap non-Error exceptions; an Error can just be used as-is.
151 if (!is_error) {
152 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700153 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700154}
155
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800156static size_t Hash(const char* s) {
157 // This is the java.lang.String hashcode for convenience, not interoperability.
158 size_t hash = 0;
159 for (; *s != '\0'; ++s) {
160 hash = hash * 31 + *s;
161 }
162 return hash;
163}
164
Elliott Hughes418d20f2011-09-22 14:00:39 -0700165const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700166 "Ljava/lang/Class;",
167 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700168 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700169 "[Ljava/lang/Object;",
170 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700171 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700172 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700173 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700174 "Ljava/lang/reflect/Field;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700175 "Ljava/lang/reflect/AbstractMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700176 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700177 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700178 "[Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700179 "[Ljava/lang/reflect/AbstractMethod;",
Ian Rogers4445a7e2012-10-05 17:19:13 -0700180 "[Ljava/lang/reflect/Field;",
181 "[Ljava/lang/reflect/Method;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700182 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800183 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800184 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700185 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700186 "Z",
187 "B",
188 "C",
189 "D",
190 "F",
191 "I",
192 "J",
193 "S",
194 "V",
195 "[Z",
196 "[B",
197 "[C",
198 "[D",
199 "[F",
200 "[I",
201 "[J",
202 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700203 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700204};
205
Brian Carlstroma004aa92012-02-08 18:05:09 -0800206ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
207 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700208 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800209 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800210 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700211 return class_linker.release();
212}
213
Brian Carlstroma004aa92012-02-08 18:05:09 -0800214ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800215 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700216 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700217 return class_linker.release();
218}
219
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800220ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700221 // dex_lock_ is recursive as it may be used in stack dumping.
222 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel, true),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700223 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700224 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700225 init_done_(false),
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700226 is_dirty_(false),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700227 intern_table_(intern_table) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700228 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700229}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700230
Brian Carlstroma004aa92012-02-08 18:05:09 -0800231void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
232 VLOG(startup) << "ClassLinker::Init";
233 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700234
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700235 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700236
Elliott Hughes30646832011-10-13 16:59:46 -0700237 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700238 Thread* self = Thread::Current();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800239 Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers50b35e22012-10-04 10:09:15 -0700240 SirtRef<Class>
241 java_lang_Class(self, down_cast<Class*>(heap->AllocObject(self, NULL, sizeof(ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700242 CHECK(java_lang_Class.get() != NULL);
243 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700244 java_lang_Class->SetClassSize(sizeof(ClassClass));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700245 // AllocClass(Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700246
Elliott Hughes418d20f2011-09-22 14:00:39 -0700247 // Class[] is used for reflection support.
Ian Rogers50b35e22012-10-04 10:09:15 -0700248 SirtRef<Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700249 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700250
Ian Rogers23435d02012-09-24 11:23:12 -0700251 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers50b35e22012-10-04 10:09:15 -0700252 SirtRef<Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700253 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700254 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700255 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700256 java_lang_Object->SetStatus(Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700257
Ian Rogers23435d02012-09-24 11:23:12 -0700258 // Object[] next to hold class roots.
Ian Rogers50b35e22012-10-04 10:09:15 -0700259 SirtRef<Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700260 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700261
Ian Rogers23435d02012-09-24 11:23:12 -0700262 // Setup the char class to be used for char[].
Ian Rogers50b35e22012-10-04 10:09:15 -0700263 SirtRef<Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700264
Ian Rogers23435d02012-09-24 11:23:12 -0700265 // Setup the char[] class to be used for String.
Ian Rogers50b35e22012-10-04 10:09:15 -0700266 SirtRef<Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700267 char_array_class->SetComponentType(char_class.get());
268 CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700269
Ian Rogers23435d02012-09-24 11:23:12 -0700270 // Setup String.
Ian Rogers50b35e22012-10-04 10:09:15 -0700271 SirtRef<Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(StringClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700272 String::SetClass(java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700273 java_lang_String->SetObjectSize(sizeof(String));
274 java_lang_String->SetStatus(Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400275
Ian Rogers23435d02012-09-24 11:23:12 -0700276 // Create storage for root classes, save away our work so far (requires descriptors).
Ian Rogers50b35e22012-10-04 10:09:15 -0700277 class_roots_ = ObjectArray<Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700278 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700279 SetClassRoot(kJavaLangClass, java_lang_Class.get());
280 SetClassRoot(kJavaLangObject, java_lang_Object.get());
281 SetClassRoot(kClassArrayClass, class_array_class.get());
282 SetClassRoot(kObjectArrayClass, object_array_class.get());
283 SetClassRoot(kCharArrayClass, char_array_class.get());
284 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700285
286 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700287 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
288 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
289 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
290 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
291 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
292 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
293 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
294 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700295
Ian Rogers23435d02012-09-24 11:23:12 -0700296 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700297 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700298
Ian Rogers23435d02012-09-24 11:23:12 -0700299 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers50b35e22012-10-04 10:09:15 -0700300 SirtRef<Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700301 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700302 IntArray::SetArrayClass(int_array_class.get());
303 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700304
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700305 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700306
Ian Rogers52813c92012-10-11 11:50:38 -0700307 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers50b35e22012-10-04 10:09:15 -0700308 SirtRef<Class>
309 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700310 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
311 java_lang_DexCache->SetObjectSize(sizeof(DexCacheClass));
312 java_lang_DexCache->SetStatus(Class::kStatusResolved);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700313
Mathieu Chartier66f19252012-09-18 08:57:04 -0700314 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Ian Rogers50b35e22012-10-04 10:09:15 -0700315 SirtRef<Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
316 sizeof(FieldClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700317 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700318 java_lang_reflect_Field->SetObjectSize(sizeof(Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700319 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700320 java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700321 Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700322
Ian Rogers50b35e22012-10-04 10:09:15 -0700323 SirtRef<Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
324 sizeof(MethodClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700325 CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
326 java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(AbstractMethod));
327 SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
328 java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700329
330 SirtRef<Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
331 sizeof(MethodClass)));
332 CHECK(java_lang_reflect_Constructor.get() != NULL);
333 java_lang_reflect_Constructor->SetObjectSize(sizeof(Constructor));
334 java_lang_reflect_Constructor->SetSuperClass(java_lang_reflect_AbstractMethod.get());
335 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
336 java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
337
338 SirtRef<Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
339 sizeof(MethodClass)));
340 CHECK(java_lang_reflect_Method.get() != NULL);
341 java_lang_reflect_Method->SetObjectSize(sizeof(Method));
342 java_lang_reflect_Method->SetSuperClass(java_lang_reflect_AbstractMethod.get());
343 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
344 java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
345
Mathieu Chartier66f19252012-09-18 08:57:04 -0700346 AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
347
348 // Set up array classes for string, field, method
Ian Rogers50b35e22012-10-04 10:09:15 -0700349 SirtRef<Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700350 object_array_string->SetComponentType(java_lang_String.get());
351 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
352
Ian Rogers4445a7e2012-10-05 17:19:13 -0700353 SirtRef<Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
354 object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
355 SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
356
Ian Rogers50b35e22012-10-04 10:09:15 -0700357 SirtRef<Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700358 object_array_field->SetComponentType(java_lang_reflect_Field.get());
359 SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
360
Ian Rogers4445a7e2012-10-05 17:19:13 -0700361 SirtRef<Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
362 object_array_method->SetComponentType(java_lang_reflect_Method.get());
363 SetClassRoot(kJavaLangReflectMethodArrayClass, object_array_method.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700364
Ian Rogers23435d02012-09-24 11:23:12 -0700365 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
366 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
367 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700368 CHECK_NE(0U, boot_class_path.size());
369 for (size_t i = 0; i != boot_class_path.size(); ++i) {
370 const DexFile* dex_file = boot_class_path[i];
371 CHECK(dex_file != NULL);
372 AppendToBootClassPath(*dex_file);
373 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700374
375 // now we can use FindSystemClass
376
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700377 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700378 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700379 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700380
Mathieu Chartier66f19252012-09-18 08:57:04 -0700381 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700382 java_lang_Object->SetStatus(Class::kStatusNotReady);
383 Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700384 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700385 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(Object));
386 java_lang_String->SetStatus(Class::kStatusNotReady);
387 Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700388 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700389 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700390 java_lang_DexCache->SetStatus(Class::kStatusNotReady);
391 Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
392 CHECK_EQ(java_lang_String.get(), String_class);
393 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
394 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700395
Ian Rogers23435d02012-09-24 11:23:12 -0700396 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700397 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
398 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
399
400 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
401 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
402
403 Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700404 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700405
406 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
407 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
408
409 Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700410 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700411
412 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
413 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
414
415 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
416 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
417
418 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
419 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
420
Elliott Hughes418d20f2011-09-22 14:00:39 -0700421 Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700422 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700423
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700424 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700425 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700426
Ian Rogers23435d02012-09-24 11:23:12 -0700427 // Setup the single, global copy of "iftable".
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700428 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
429 CHECK(java_lang_Cloneable != NULL);
430 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
431 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700432 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
433 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700434 array_iftable_->SetInterface(0, java_lang_Cloneable);
435 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700436
Ian Rogers23435d02012-09-24 11:23:12 -0700437 // Sanity check Class[] and Object[]'s interfaces.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800438 ClassHelper kh(class_array_class.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -0700439 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
440 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800441 kh.ChangeClass(object_array_class.get());
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 Rogers23435d02012-09-24 11:23:12 -0700444 // Run Class, Constructor, Field, and Method through FindSystemClass. This initializes their
445 // dex_cache_ fields and register them in classes_.
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700446 Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700447 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700448
Mathieu Chartier66f19252012-09-18 08:57:04 -0700449 java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusNotReady);
450 Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
451 CHECK_EQ(java_lang_reflect_AbstractMethod.get(), Abstract_method_class);
452
453 // Method extends AbstractMethod so must reset after.
454 java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
455 Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
456 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
457
458 // Constructor extends AbstractMethod so must reset after.
Elliott Hughes80609252011-09-23 17:24:51 -0700459 java_lang_reflect_Constructor->SetStatus(Class::kStatusNotReady);
460 Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700461 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700462
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700463 java_lang_reflect_Field->SetStatus(Class::kStatusNotReady);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700464 Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700465 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700466
Mathieu Chartier66f19252012-09-18 08:57:04 -0700467 Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
468 CHECK_EQ(object_array_string.get(), String_array_class);
469
Mathieu Chartier66f19252012-09-18 08:57:04 -0700470 Class* Abstract_method_array_class =
471 FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
472 CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700473
Ian Rogers4445a7e2012-10-05 17:19:13 -0700474 Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
475 CHECK_EQ(object_array_field.get(), Field_array_class);
476
477 Class* Method_array_class =
478 FindSystemClass(class_roots_descriptors_[kJavaLangReflectMethodArrayClass]);
479 CHECK_EQ(object_array_method.get(), Method_array_class);
480
Ian Rogers23435d02012-09-24 11:23:12 -0700481 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700482
Ian Rogers23435d02012-09-24 11:23:12 -0700483 // Create java.lang.reflect.Proxy root.
Ian Rogers466bb252011-10-14 03:29:56 -0700484 Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
485 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
486
Brian Carlstrom1f870082011-08-23 16:02:11 -0700487 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700488 Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
489 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700490 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700491 java_lang_ref_FinalizerReference->SetAccessFlags(
492 java_lang_ref_FinalizerReference->GetAccessFlags() |
493 kAccClassIsReference | kAccClassIsFinalizerReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700494 Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700495 java_lang_ref_PhantomReference->SetAccessFlags(
496 java_lang_ref_PhantomReference->GetAccessFlags() |
497 kAccClassIsReference | kAccClassIsPhantomReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700498 Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700499 java_lang_ref_SoftReference->SetAccessFlags(
500 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700501 Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700502 java_lang_ref_WeakReference->SetAccessFlags(
503 java_lang_ref_WeakReference->GetAccessFlags() |
504 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700505
Ian Rogers23435d02012-09-24 11:23:12 -0700506 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700507 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
Brian Carlstromaded5f72011-10-07 17:15:04 -0700508 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700509 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
510
jeffhao8cd6dda2012-02-22 10:15:34 -0800511 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700512 // java.lang.StackTraceElement as a convenience.
Ian Rogers5167c972012-02-03 10:41:20 -0800513 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
514 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800515 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700516 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
517 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700518 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700519
Brian Carlstroma663ea52011-08-19 23:33:41 -0700520 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700521
Brian Carlstroma004aa92012-02-08 18:05:09 -0800522 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700523}
524
525void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800526 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700527
528 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700529 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700530 // as the types of the field can't be resolved prior to the runtime being
531 // fully initialized
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700532 Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700533 Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700534 Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
535
Ian Rogers4445a7e2012-10-05 17:19:13 -0700536 const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800537
Brian Carlstrom16192862011-09-12 17:50:06 -0700538 Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800539 FieldHelper fh(pendingNext, this);
540 CHECK_STREQ(fh.GetName(), "pendingNext");
541 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
542 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700543
544 Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800545 fh.ChangeField(queue);
546 CHECK_STREQ(fh.GetName(), "queue");
547 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
548 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700549
550 Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800551 fh.ChangeField(queueNext);
552 CHECK_STREQ(fh.GetName(), "queueNext");
553 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
554 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700555
556 Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800557 fh.ChangeField(referent);
558 CHECK_STREQ(fh.GetName(), "referent");
559 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
560 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700561
562 Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800563 fh.ChangeField(zombie);
564 CHECK_STREQ(fh.GetName(), "zombie");
565 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
566 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700567
Elliott Hughesa4f94742012-05-29 16:28:38 -0700568 Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800569 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700570 queue->GetOffset(),
571 queueNext->GetOffset(),
572 pendingNext->GetOffset(),
573 zombie->GetOffset());
574
Brian Carlstroma663ea52011-08-19 23:33:41 -0700575 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700576 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700577 ClassRoot class_root = static_cast<ClassRoot>(i);
578 Class* klass = GetClassRoot(class_root);
579 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700580 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700581 // note SetClassRoot does additional validation.
582 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700583 }
584
Elliott Hughes92f14b22011-10-06 12:29:54 -0700585 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700586
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700587 // disable the slow paths in FindClass and CreatePrimitiveClass now
588 // that Object, Class, and Object[] are setup
589 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700590
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800591 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700592}
593
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700594void ClassLinker::RunRootClinits() {
595 Thread* self = Thread::Current();
596 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
597 Class* c = GetClassRoot(ClassRoot(i));
598 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700599 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700600 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700601 }
602 }
603}
604
Brian Carlstromd601af82012-01-06 10:15:19 -0800605bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
606 int oat_fd,
607 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800608 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700609 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800610 const char* dex2oat = dex2oat_string.c_str();
611
Brian Carlstroma004aa92012-02-08 18:05:09 -0800612 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800613
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800614 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800615 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700616 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800617 const char* boot_image_option = boot_image_option_string.c_str();
618
619 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800620 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800621 const char* dex_file_option = dex_file_option_string.c_str();
622
Brian Carlstromd601af82012-01-06 10:15:19 -0800623 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800624 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800625 const char* oat_fd_option = oat_fd_option_string.c_str();
626
Brian Carlstroma004aa92012-02-08 18:05:09 -0800627 std::string oat_location_option_string("--oat-location=");
628 oat_location_option_string += oat_cache_filename;
629 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800630
jeffhao262bf462011-10-20 18:36:32 -0700631 // fork and exec dex2oat
632 pid_t pid = fork();
633 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800634 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800635
636 // change process groups, so we don't get reaped by ProcessManager
637 setpgid(0, 0);
638
jeffhao10037c82012-01-23 15:06:23 -0800639 VLOG(class_linker) << dex2oat
640 << " --runtime-arg -Xms64m"
641 << " --runtime-arg -Xmx64m"
642 << " --runtime-arg -classpath"
643 << " --runtime-arg " << class_path
644 << " " << boot_image_option
645 << " " << dex_file_option
646 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800647 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800648
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800649 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700650 "--runtime-arg", "-Xms64m",
651 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500652 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800653 "--runtime-arg", class_path,
654 boot_image_option,
655 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800656 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800657 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700658 NULL);
659
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800660 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800661 return false;
jeffhao262bf462011-10-20 18:36:32 -0700662 } else {
663 // wait for dex2oat to finish
664 int status;
665 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
666 if (got_pid != pid) {
667 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800668 return false;
jeffhao262bf462011-10-20 18:36:32 -0700669 }
670 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800671 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
672 return false;
jeffhao262bf462011-10-20 18:36:32 -0700673 }
674 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800675 return true;
jeffhao262bf462011-10-20 18:36:32 -0700676}
677
Brian Carlstrom866c8622012-01-06 16:35:13 -0800678void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700679 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800680 RegisterOatFileLocked(oat_file);
681}
682
683void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700684 dex_lock_.AssertHeld(Thread::Current());
Brian Carlstrom866c8622012-01-06 16:35:13 -0800685 oat_files_.push_back(&oat_file);
686}
687
Ian Rogers30fab402012-01-23 15:43:46 -0800688OatFile* ClassLinker::OpenOat(const ImageSpace* space) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700689 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700690 const Runtime* runtime = Runtime::Current();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700691 const ImageHeader& image_header = space->GetImageHeader();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800692 // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
693 // check the down cast
694 String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700695 std::string oat_filename;
696 oat_filename += runtime->GetHostPrefix();
697 oat_filename += oat_location->ToModifiedUtf8();
Mathieu Chartierd8195f12012-10-05 12:21:28 -0700698 runtime->GetHeap()->UnReserveOatFileAddressRange();
Logan Chien0c717dd2012-03-28 18:31:07 +0800699 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename,
700 image_header.GetOatBegin(),
701 OatFile::kRelocNone);
Ian Rogers30fab402012-01-23 15:43:46 -0800702 VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700703 if (oat_file == NULL) {
Brian Carlstroma9f19782011-10-13 00:14:47 -0700704 LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700705 return NULL;
706 }
707 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
708 uint32_t image_oat_checksum = image_header.GetOatChecksum();
709 if (oat_checksum != image_oat_checksum) {
Brian Carlstrom866c8622012-01-06 16:35:13 -0800710 LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
Brian Carlstroma85b8372012-10-18 17:00:32 -0700711 << " to expected oat checksum " << std::hex << image_oat_checksum
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700712 << " in image";
713 return NULL;
714 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800715 RegisterOatFileLocked(*oat_file);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800716 VLOG(startup) << "ClassLinker::OpenOat exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700717 return oat_file;
718}
719
Brian Carlstromae826982011-11-09 01:33:42 -0800720const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700721 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800722 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800723}
724
Brian Carlstroma004aa92012-02-08 18:05:09 -0800725const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800726 for (size_t i = 0; i < oat_files_.size(); i++) {
727 const OatFile* oat_file = oat_files_[i];
728 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800729 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800730 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800731 return oat_file;
732 }
733 }
734 return NULL;
735}
736
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800737static const DexFile* FindDexFileInOatLocation(const std::string& dex_location,
738 uint32_t dex_location_checksum,
739 const std::string& oat_location) {
Logan Chien0c717dd2012-03-28 18:31:07 +0800740 UniquePtr<OatFile> oat_file(
741 OatFile::Open(oat_location, oat_location, NULL, OatFile::kRelocAll));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800742 if (oat_file.get() == NULL) {
743 return NULL;
744 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700745 Runtime* runtime = Runtime::Current();
746 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700747 if (oat_file->GetOatHeader().GetImageFileLocationOatChecksum() != image_header.GetOatChecksum()) {
748 return NULL;
749 }
750 if (oat_file->GetOatHeader().GetImageFileLocationOatBegin()
751 != reinterpret_cast<uint32_t>(image_header.GetOatBegin())) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700752 return NULL;
753 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800754 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
755 if (oat_dex_file == NULL) {
756 return NULL;
757 }
758 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
759 return NULL;
760 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700761 runtime->GetClassLinker()->RegisterOatFile(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800762 return oat_dex_file->OpenDexFile();
763}
764
765const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
766 const std::string& oat_location) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700767 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700768 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_location);
769}
770
771const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
772 const std::string& oat_location) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800773 uint32_t dex_location_checksum;
774 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
775 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
776 return NULL;
777 }
778
779 // Check if we already have an up-to-date output file
780 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
781 dex_location_checksum,
782 oat_location);
783 if (dex_file != NULL) {
784 return dex_file;
785 }
786
787 // Generate the output oat file for the dex file
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800788 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
789 if (file.get() == NULL) {
790 LOG(ERROR) << "Failed to create oat file: " << oat_location;
791 return NULL;
792 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700793 if (!GenerateOatFile(dex_location, file->Fd(), oat_location)) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800794 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
795 return NULL;
796 }
797 // Open the oat from file descriptor we passed to GenerateOatFile
798 if (lseek(file->Fd(), 0, SEEK_SET) != 0) {
799 LOG(ERROR) << "Failed to seek to start of generated oat file: " << oat_location;
800 return NULL;
801 }
Logan Chien0c717dd2012-03-28 18:31:07 +0800802 const OatFile* oat_file =
803 OatFile::Open(*file.get(), oat_location, NULL, OatFile::kRelocAll);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800804 if (oat_file == NULL) {
805 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
806 return NULL;
807 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700808 RegisterOatFileLocked(*oat_file);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800809 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
810 if (oat_dex_file == NULL) {
811 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
812 return NULL;
813 }
814 return oat_dex_file->OpenDexFile();
815}
816
Brian Carlstromafe25512012-06-27 17:02:58 -0700817bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
818 const std::string& dex_location,
819 uint32_t dex_location_checksum) {
820 Runtime* runtime = Runtime::Current();
821 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700822 uint32_t image_oat_checksum = image_header.GetOatChecksum();
823 uint32_t image_oat_begin = reinterpret_cast<uint32_t>(image_header.GetOatBegin());
824 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
825 && (oat_file->GetOatHeader().GetImageFileLocationOatBegin() == image_oat_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700826
Brian Carlstromafe25512012-06-27 17:02:58 -0700827 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
828 if (oat_dex_file == NULL) {
829 LOG(ERROR) << ".oat file " << oat_file->GetLocation()
830 << " does not contain contents for " << dex_location;
831 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
832 for (size_t i = 0; i < oat_dex_files.size(); i++) {
833 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
834 LOG(ERROR) << ".oat file " << oat_file->GetLocation()
835 << " contains contents for " << oat_dex_file->GetDexFileLocation();
836 }
837 return false;
838 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700839 bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700840
Brian Carlstromafe25512012-06-27 17:02:58 -0700841 if (image_check && dex_check) {
842 return true;
843 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700844
Brian Carlstromafe25512012-06-27 17:02:58 -0700845 if (!image_check) {
846 std::string image_file(image_header.GetImageRoot(
847 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
848 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700849 << " mismatch ( " << std::hex << oat_file->GetOatHeader().GetImageFileLocationOatChecksum()
850 << ", " << oat_file->GetOatHeader().GetImageFileLocationOatBegin()
851 << ") with " << image_file
852 << " (" << image_oat_checksum << ", " << std::hex << image_oat_begin << ")";
Brian Carlstromafe25512012-06-27 17:02:58 -0700853 }
854 if (!dex_check) {
855 LOG(WARNING) << ".oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700856 << " mismatch ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
857 << ") with " << dex_location
Brian Carlstromafe25512012-06-27 17:02:58 -0700858 << " (" << std::hex << dex_location_checksum << ")";
859 }
860 return false;
861}
862
863const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
864 const std::string& dex_location,
865 uint32_t dex_location_checksum) {
866 bool verified = VerifyOatFileChecksums(oat_file, dex_location, dex_location_checksum);
867 if (!verified) {
868 return NULL;
869 }
870 RegisterOatFileLocked(*oat_file);
871 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700872}
873
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800874const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700875 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800876
Brian Carlstroma004aa92012-02-08 18:05:09 -0800877 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800878 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800879 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800880 }
881
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700882 // Look for an existing file next to dex. for example, for
883 // /foo/bar/baz.jar, look for /foo/bar/baz.jar.oat.
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800884 std::string oat_filename(OatFile::DexFilenameToOatFilename(dex_location));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700885 const OatFile* oat_file = FindOatFileFromOatLocationLocked(oat_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800886 if (oat_file != NULL) {
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700887 uint32_t dex_location_checksum;
888 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
889 // If no classes.dex found in dex_location, it has been stripped, assume oat is up-to-date.
890 // This is the common case in user builds for jar's and apk's in the /system directory.
891 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
892 CHECK(oat_dex_file != NULL) << oat_filename << " " << dex_location;
893 RegisterOatFileLocked(*oat_file);
894 return oat_dex_file->OpenDexFile();
895 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700896 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
897 dex_location,
898 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700899 if (dex_file != NULL) {
900 return dex_file;
901 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800902 }
903 // Look for an existing file in the art-cache, validating the result if found
904 // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
905 std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700906 oat_file = FindOatFileFromOatLocationLocked(cache_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800907 if (oat_file != NULL) {
908 uint32_t dex_location_checksum;
909 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
910 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
911 return NULL;
912 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700913 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
914 dex_location,
915 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700916 if (dex_file != NULL) {
917 return dex_file;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700918 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800919 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
Brian Carlstrom5ef74932012-03-23 17:56:02 -0700920 PLOG(FATAL) << "Failed to remove obsolete .oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800921 }
jeffhao262bf462011-10-20 18:36:32 -0700922 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800923 LOG(INFO) << "Failed to open oat file from " << oat_filename << " or " << cache_location << ".";
924
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800925 // Try to generate oat file if it wasn't found or was obsolete.
926 std::string oat_cache_filename(GetArtCacheFilenameOrDie(oat_filename));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700927 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700928}
929
Brian Carlstromae826982011-11-09 01:33:42 -0800930const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700931 for (size_t i = 0; i < oat_files_.size(); i++) {
932 const OatFile* oat_file = oat_files_[i];
933 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800934 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700935 return oat_file;
936 }
937 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700938 return NULL;
939}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700940
Brian Carlstromae826982011-11-09 01:33:42 -0800941const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700942 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700943 return FindOatFileFromOatLocationLocked(oat_location);
944}
945
946const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800947 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
948 if (oat_file != NULL) {
949 return oat_file;
950 }
951
Logan Chien0c717dd2012-03-28 18:31:07 +0800952 oat_file = OatFile::Open(oat_location, oat_location, NULL,
953 OatFile::kRelocAll);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700954 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800955 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700956 }
Brian Carlstromae826982011-11-09 01:33:42 -0800957 CHECK(oat_file != NULL) << oat_location;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700958 return oat_file;
959}
960
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700961void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800962 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700963 CHECK(!init_done_);
964
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800965 Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700966 ImageSpace* space = heap->GetImageSpace();
967 OatFile* oat_file = OpenOat(space);
968 CHECK(oat_file != NULL) << "Failed to open oat file for image";
Brian Carlstrom28db0122012-10-18 16:20:41 -0700969 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
970 CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatBegin(), 0U);
Elliott Hughes74847412012-06-20 18:10:21 -0700971 CHECK(oat_file->GetOatHeader().GetImageFileLocation().empty());
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700972 Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
973 ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700974
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700975 // Special case of setting up the String class early so that we can test arbitrary objects
976 // as being Strings or not
977 Class* java_lang_String = space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)
978 ->AsObjectArray<Class>()->Get(kJavaLangString);
979 String::SetClass(java_lang_String);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800980
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700981 CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
982 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers1f539342012-10-03 21:09:42 -0700983 Thread* self = Thread::Current();
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700984 for (int i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers1f539342012-10-03 21:09:42 -0700985 SirtRef<DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700986 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
987 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
988 const DexFile* dex_file = oat_dex_file->OpenDexFile();
989 if (dex_file == NULL) {
990 LOG(FATAL) << "Failed to open dex file " << dex_file_location
991 << " from within oat file " << oat_file->GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700992 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700993
994 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
995
996 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700997 }
998
Brian Carlstroma663ea52011-08-19 23:33:41 -0700999 // reinit clases_ table
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001000 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001001 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001002 heap->FlushAllocStack();
Mathieu Chartiere0f0cb32012-08-28 11:26:00 -07001003 heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001004 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001005
1006 // reinit class_roots_
Ian Rogers30fab402012-01-23 15:43:46 -08001007 Object* class_roots_object =
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001008 heap->GetImageSpace()->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots);
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001009 class_roots_ = class_roots_object->AsObjectArray<Class>();
Brian Carlstroma663ea52011-08-19 23:33:41 -07001010
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001011 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001012 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1013 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001014 // String class root was set above
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001015 Field::SetClass(GetClassRoot(kJavaLangReflectField));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001016 AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
1017 GetClassRoot(kJavaLangReflectMethod));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001018 BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1019 ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1020 CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1021 DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1022 FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1023 IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1024 LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1025 ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers5167c972012-02-03 10:41:20 -08001026 Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001027 StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001028
1029 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001030
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001031 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001032}
1033
Brian Carlstrom78128a62011-09-15 17:21:19 -07001034void ClassLinker::InitFromImageCallback(Object* obj, void* arg) {
Brian Carlstroma663ea52011-08-19 23:33:41 -07001035 DCHECK(obj != NULL);
1036 DCHECK(arg != NULL);
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001037 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001038
Elliott Hughesdbb40792011-11-18 17:05:22 -08001039 if (obj->GetClass()->IsStringClass()) {
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001040 class_linker->intern_table_->RegisterStrong(obj->AsString());
Brian Carlstromc74255f2011-09-11 22:47:39 -07001041 return;
1042 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001043 if (obj->IsClass()) {
1044 // restore class to ClassLinker::classes_ table
1045 Class* klass = obj->AsClass();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001046 ClassHelper kh(klass, class_linker);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001047 Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
1048 DCHECK(existing == NULL) << kh.GetDescriptor();
Brian Carlstroma663ea52011-08-19 23:33:41 -07001049 return;
1050 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001051}
1052
1053// Keep in sync with InitCallback. Anything we visit, we need to
1054// reinit references to when reinitializing a ClassLinker from a
1055// mapped image.
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001056void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001057 visitor(class_roots_, arg);
Ian Rogers50b35e22012-10-04 10:09:15 -07001058 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001059 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001060 MutexLock mu(self, dex_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001061 for (size_t i = 0; i < dex_caches_.size(); i++) {
1062 visitor(dex_caches_[i], arg);
1063 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001064 }
1065
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001066 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001067 MutexLock mu(self, *Locks::classlinker_classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001068 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001069 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001070 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001071 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001072
1073 // We deliberately ignore the class roots in the image since we
1074 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001075 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001076
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001077 visitor(array_iftable_, arg);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001078 is_dirty_ = false;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001079}
1080
Elliott Hughesa2155262011-11-16 16:26:58 -08001081void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001082 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -08001083 typedef Table::const_iterator It; // TODO: C++0x auto
1084 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
1085 if (!visitor(it->second, arg)) {
1086 return;
1087 }
1088 }
1089 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
1090 if (!visitor(it->second, arg)) {
1091 return;
1092 }
1093 }
1094}
1095
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001096static bool GetClassesVisitor(Class* c, void* arg) {
1097 std::set<Class*>* classes = reinterpret_cast<std::set<Class*>*>(arg);
1098 classes->insert(c);
1099 return true;
1100}
1101
1102void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
1103 std::set<Class*> classes;
1104 VisitClasses(GetClassesVisitor, &classes);
1105 typedef std::set<Class*>::const_iterator It; // TODO: C++0x auto
1106 for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
1107 if (!visitor(*it, arg)) {
1108 return;
1109 }
1110 }
1111}
1112
1113
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001114ClassLinker::~ClassLinker() {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001115 String::ResetClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001116 Field::ResetClass();
Mathieu Chartier66f19252012-09-18 08:57:04 -07001117 AbstractMethod::ResetClasses();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001118 BooleanArray::ResetArrayClass();
1119 ByteArray::ResetArrayClass();
1120 CharArray::ResetArrayClass();
1121 DoubleArray::ResetArrayClass();
1122 FloatArray::ResetArrayClass();
1123 IntArray::ResetArrayClass();
1124 LongArray::ResetArrayClass();
1125 ShortArray::ResetArrayClass();
Ian Rogers5167c972012-02-03 10:41:20 -08001126 Throwable::ResetClass();
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001127 StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001128 STLDeleteElements(&boot_class_path_);
1129 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001130}
1131
Ian Rogers50b35e22012-10-04 10:09:15 -07001132DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001133 Heap* heap = Runtime::Current()->GetHeap();
1134 Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
Ian Rogers50b35e22012-10-04 10:09:15 -07001135 SirtRef<DexCache> dex_cache(self,
1136 down_cast<DexCache*>(heap->AllocObject(self, dex_cache_class,
1137 dex_cache_class->GetObjectSize())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001138 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001139 return NULL;
1140 }
Ian Rogers1f539342012-10-03 21:09:42 -07001141 SirtRef<String> location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001142 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001143 return NULL;
1144 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001145 SirtRef<ObjectArray<String> > strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001146 if (strings.get() == NULL) {
1147 return NULL;
1148 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001149 SirtRef<ObjectArray<Class> > types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001150 if (types.get() == NULL) {
1151 return NULL;
1152 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001153 SirtRef<ObjectArray<AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07001154 methods(self, AllocAbstractMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001155 if (methods.get() == NULL) {
1156 return NULL;
1157 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001158 SirtRef<ObjectArray<Field> > fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001159 if (fields.get() == NULL) {
1160 return NULL;
1161 }
Ian Rogers1f539342012-10-03 21:09:42 -07001162 SirtRef<ObjectArray<StaticStorageBase> >
Ian Rogers50b35e22012-10-04 10:09:15 -07001163 initialized_static_storage(self,
1164 AllocObjectArray<StaticStorageBase>(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001165 if (initialized_static_storage.get() == NULL) {
1166 return NULL;
1167 }
1168
Mathieu Chartier66f19252012-09-18 08:57:04 -07001169 dex_cache->Init(&dex_file,
1170 location.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001171 strings.get(),
1172 types.get(),
1173 methods.get(),
1174 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001175 initialized_static_storage.get());
1176 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001177}
1178
Ian Rogers50b35e22012-10-04 10:09:15 -07001179Class* ClassLinker::AllocClass(Thread* self, Class* java_lang_Class, size_t class_size) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07001180 DCHECK_GE(class_size, sizeof(Class));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001181 Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers50b35e22012-10-04 10:09:15 -07001182 SirtRef<Class> klass(self,
1183 heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001184 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001185 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001186 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001187}
1188
Ian Rogers50b35e22012-10-04 10:09:15 -07001189Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
1190 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001191}
1192
Ian Rogers50b35e22012-10-04 10:09:15 -07001193Field* ClassLinker::AllocField(Thread* self) {
1194 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001195}
1196
Ian Rogers50b35e22012-10-04 10:09:15 -07001197Method* ClassLinker::AllocMethod(Thread* self) {
1198 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001199}
1200
Ian Rogers50b35e22012-10-04 10:09:15 -07001201Constructor* ClassLinker::AllocConstructor(Thread* self) {
1202 return down_cast<Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001203}
1204
Ian Rogers50b35e22012-10-04 10:09:15 -07001205ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
1206 size_t length) {
1207 return ObjectArray<StackTraceElement>::Alloc(self,
1208 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1209 length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001210}
1211
Ian Rogers50b35e22012-10-04 10:09:15 -07001212static Class* EnsureResolved(Thread* self, Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001213 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001214 DCHECK(klass != NULL);
1215 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001216 if (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers1f539342012-10-03 21:09:42 -07001217 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001218 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001219 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001220 self->ThrowNewException("Ljava/lang/ClassCircularityError;",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001221 PrettyDescriptor(klass).c_str());
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001222 klass->SetStatus(Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001223 return NULL;
1224 }
1225 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001226 while (!klass->IsResolved() && !klass->IsErroneous()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001227 lock.Wait();
1228 }
1229 }
1230 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001231 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001232 return NULL;
1233 }
1234 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001235 CHECK(klass->IsResolved()) << PrettyClass(klass);
1236 CHECK(!self->IsExceptionPending())
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001237 << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException()) << "\n"
1238 << self->GetException()->Dump();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001239 return klass;
1240}
1241
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001242Class* ClassLinker::FindSystemClass(const char* descriptor) {
1243 return FindClass(descriptor, NULL);
1244}
1245
Ian Rogers365c1022012-06-22 15:05:28 -07001246Class* ClassLinker::FindClass(const char* descriptor, ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001247 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001248 Thread* self = Thread::Current();
1249 DCHECK(self != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001250 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001251 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001252 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1253 // for primitive classes that aren't backed by dex files.
1254 return FindPrimitiveClass(descriptor[0]);
1255 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001256 // Find the class in the loaded classes table.
1257 Class* klass = LookupClass(descriptor, class_loader);
1258 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001259 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001260 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001261 // Class is not yet loaded.
1262 if (descriptor[0] == '[') {
1263 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001264
Jesse Wilson47daf872011-11-23 11:42:45 -05001265 } else if (class_loader == NULL) {
1266 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1267 if (pair.second != NULL) {
1268 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1269 }
1270
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001271 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001272 // first try the boot class path
1273 Class* system_class = FindSystemClass(descriptor);
1274 if (system_class != NULL) {
1275 return system_class;
1276 }
1277 CHECK(self->IsExceptionPending());
1278 self->ClearException();
1279
1280 // next try the compile time class path
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001281 const std::vector<const DexFile*>* class_path;
1282 {
1283 ScopedObjectAccessUnchecked soa(Thread::Current());
1284 ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
1285 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1286 }
1287
1288 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001289 if (pair.second != NULL) {
1290 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001291 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001292
1293 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001294 ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1295 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
1296 soa.AddLocalReference<jobject>(class_loader));
Elliott Hughes95572412011-12-13 18:14:20 -08001297 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001298 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001299 {
1300 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001301 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1302 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001303 if (class_name_object.get() == NULL) {
1304 return NULL;
1305 }
1306 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001307 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1308 WellKnownClasses::java_lang_ClassLoader_loadClass,
1309 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001310 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001311 if (soa.Env()->ExceptionCheck()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001312 // If the ClassLoader threw, pass that exception up.
1313 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001314 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001315 // broken loader - throw NPE to be compatible with Dalvik
1316 ThrowNullPointerException("ClassLoader.loadClass returned null for %s",
1317 class_name_string.c_str());
1318 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001319 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08001320 // success, return Class*
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001321 return soa.Decode<Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001322 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001323 }
1324
Elliott Hughes82914b62012-04-09 15:56:29 -07001325 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001326 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001327}
1328
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001329Class* ClassLinker::DefineClass(const StringPiece& descriptor,
Ian Rogers365c1022012-06-22 15:05:28 -07001330 ClassLoader* class_loader,
Brian Carlstromaded5f72011-10-07 17:15:04 -07001331 const DexFile& dex_file,
1332 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001333 Thread* self = Thread::Current();
1334 SirtRef<Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001335 // Load the class from the dex file.
1336 if (!init_done_) {
1337 // finish up init of hand crafted class_roots_
1338 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001339 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001340 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001341 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001342 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001343 klass.reset(GetClassRoot(kJavaLangString));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001344 } else if (descriptor == "Ljava/lang/DexCache;") {
1345 klass.reset(GetClassRoot(kJavaLangDexCache));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001346 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001347 klass.reset(GetClassRoot(kJavaLangReflectField));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001348 } else if (descriptor == "Ljava/lang/reflect/AbstractMethod;") {
1349 klass.reset(GetClassRoot(kJavaLangReflectAbstractMethod));
1350 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
1351 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001352 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001353 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001354 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001355 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001356 }
1357 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001358 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001359 }
1360 klass->SetDexCache(FindDexCache(dex_file));
1361 LoadClass(dex_file, dex_class_def, klass, class_loader);
1362 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001363 if (self->IsExceptionPending()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08001364 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001365 return NULL;
1366 }
Ian Rogers1f539342012-10-03 21:09:42 -07001367 ObjectLock lock(self, klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001368 klass->SetClinitThreadId(self->GetTid());
1369 // Add the newly loaded class to the loaded classes table.
Ian Rogers1f539342012-10-03 21:09:42 -07001370 SirtRef<Class> existing(self, InsertClass(descriptor, klass.get(), false));
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001371 if (existing.get() != NULL) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001372 // We failed to insert because we raced with another thread.
Ian Rogers50b35e22012-10-04 10:09:15 -07001373 return EnsureResolved(self, existing.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001374 }
1375 // Finish loading (if necessary) by finding parents
1376 CHECK(!klass->IsLoaded());
1377 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1378 // Loading failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001379 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001380 lock.NotifyAll();
1381 return NULL;
1382 }
1383 CHECK(klass->IsLoaded());
1384 // Link the class (if necessary)
1385 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001386 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001387 // Linking failed.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001388 klass->SetStatus(Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001389 lock.NotifyAll();
1390 return NULL;
1391 }
1392 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001393
1394 /*
1395 * We send CLASS_PREPARE events to the debugger from here. The
1396 * definition of "preparation" is creating the static fields for a
1397 * class and initializing them to the standard default values, but not
1398 * executing any code (that comes later, during "initialization").
1399 *
1400 * We did the static preparation in LinkClass.
1401 *
1402 * The class has been prepared and resolved but possibly not yet verified
1403 * at this point.
1404 */
1405 Dbg::PostClassPrepare(klass.get());
1406
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001407 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001408}
1409
Brian Carlstrom4873d462011-08-21 15:23:39 -07001410// Precomputes size that will be needed for Class, matching LinkStaticFields
1411size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1412 const DexFile::ClassDef& dex_class_def) {
1413 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001414 size_t num_ref = 0;
1415 size_t num_32 = 0;
1416 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001417 if (class_data != NULL) {
1418 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1419 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001420 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001421 char c = descriptor[0];
1422 if (c == 'L' || c == '[') {
1423 num_ref++;
1424 } else if (c == 'J' || c == 'D') {
1425 num_64++;
1426 } else {
1427 num_32++;
1428 }
1429 }
1430 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001431 // start with generic class data
1432 size_t size = sizeof(Class);
1433 // follow with reference fields which must be contiguous at start
1434 size += (num_ref * sizeof(uint32_t));
1435 // if there are 64-bit fields to add, make sure they are aligned
1436 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
1437 if (num_32 != 0) {
1438 // use an available 32-bit field for padding
1439 num_32--;
1440 }
1441 size += sizeof(uint32_t); // either way, we are adding a word
1442 DCHECK_EQ(size, RoundUp(size, 8));
1443 }
1444 // tack on any 64-bit fields now that alignment is assured
1445 size += (num_64 * sizeof(uint64_t));
1446 // tack on any remaining 32-bit fields
1447 size += (num_32 * sizeof(uint32_t));
1448 return size;
1449}
1450
Ian Rogers19846512012-02-24 11:42:47 -08001451const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1452 DCHECK(descriptor != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001453 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1454 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1455 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1456 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1457 uint32_t class_def_index;
1458 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1459 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1460 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1461 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1462 return oat_class;
1463}
1464
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001465static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint32_t method_idx) {
1466 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1467 const DexFile::TypeId& type_id = dex_file.GetTypeId(method_id.class_idx_);
1468 const DexFile::ClassDef* class_def = dex_file.FindClassDef(dex_file.GetTypeDescriptor(type_id));
1469 CHECK(class_def != NULL);
1470 const byte* class_data = dex_file.GetClassData(*class_def);
1471 CHECK(class_data != NULL);
1472 ClassDataItemIterator it(dex_file, class_data);
1473 // Skip fields
1474 while (it.HasNextStaticField()) {
1475 it.Next();
1476 }
1477 while (it.HasNextInstanceField()) {
1478 it.Next();
1479 }
1480 // Process methods
1481 size_t class_def_method_index = 0;
1482 while (it.HasNextDirectMethod()) {
1483 if (it.GetMemberIndex() == method_idx) {
1484 return class_def_method_index;
1485 }
1486 class_def_method_index++;
1487 it.Next();
1488 }
1489 while (it.HasNextVirtualMethod()) {
1490 if (it.GetMemberIndex() == method_idx) {
1491 return class_def_method_index;
1492 }
1493 class_def_method_index++;
1494 it.Next();
1495 }
1496 DCHECK(!it.HasNext());
1497 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1498 return 0;
1499}
1500
Mathieu Chartier66f19252012-09-18 08:57:04 -07001501const OatFile::OatMethod ClassLinker::GetOatMethodFor(const AbstractMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001502 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001503 // method for direct methods (or virtual methods made direct).
1504 Class* declaring_class = method->GetDeclaringClass();
1505 size_t oat_method_index;
1506 if (method->IsStatic() || method->IsDirect()) {
1507 // Simple case where the oat method index was stashed at load time.
1508 oat_method_index = method->GetMethodIndex();
1509 } else {
1510 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1511 // by search for its position in the declared virtual methods.
1512 oat_method_index = declaring_class->NumDirectMethods();
1513 size_t end = declaring_class->NumVirtualMethods();
1514 bool found = false;
1515 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001516 if (declaring_class->GetVirtualMethod(i) == method) {
1517 found = true;
1518 break;
1519 }
Ian Rogersf320b632012-03-13 18:47:47 -07001520 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001521 }
1522 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1523 }
1524 ClassHelper kh(declaring_class);
Ian Rogers19846512012-02-24 11:42:47 -08001525 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001526 CHECK(oat_class.get() != NULL);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001527 DCHECK_EQ(oat_method_index,
1528 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
1529 method->GetDexMethodIndex()));
1530
TDYa12785321912012-04-01 15:24:56 -07001531 return oat_class->GetOatMethod(oat_method_index);
1532}
1533
1534// Special case to get oat code without overwriting a trampoline.
Mathieu Chartier66f19252012-09-18 08:57:04 -07001535const void* ClassLinker::GetOatCodeFor(const AbstractMethod* method) {
TDYa127ccffd9e2012-04-08 14:37:03 -07001536 CHECK(Runtime::Current()->IsCompiler() || method->GetDeclaringClass()->IsInitializing());
TDYa12785321912012-04-01 15:24:56 -07001537 return GetOatMethodFor(method).GetCode();
1538}
1539
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001540const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx) {
1541 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1542 const char* descriptor = dex_file.GetTypeDescriptor(dex_file.GetTypeId(method_id.class_idx_));
1543 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, method_idx);
1544 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, descriptor));
1545 CHECK(oat_class.get() != NULL);
1546 return oat_class->GetOatMethod(oat_method_idx).GetCode();
1547}
1548
Ian Rogers19846512012-02-24 11:42:47 -08001549void ClassLinker::FixupStaticTrampolines(Class* klass) {
1550 ClassHelper kh(klass);
1551 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1552 CHECK(dex_class_def != NULL);
1553 const DexFile& dex_file = kh.GetDexFile();
1554 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1555 if (class_data == NULL) {
1556 return; // no fields or methods - for example a marker interface
1557 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001558 if (!Runtime::Current()->IsStarted() || Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001559 // OAT file unavailable
1560 return;
1561 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001562 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1563 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001564 ClassDataItemIterator it(dex_file, class_data);
1565 // Skip fields
1566 while (it.HasNextStaticField()) {
1567 it.Next();
1568 }
1569 while (it.HasNextInstanceField()) {
1570 it.Next();
1571 }
1572 size_t method_index = 0;
1573 // Link the code of methods skipped by LinkCode
1574 const void* trampoline = Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData();
1575 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001576 AbstractMethod* method = klass->GetDirectMethod(i);
jeffhaob5e81852012-03-12 11:15:45 -07001577 if (Runtime::Current()->IsMethodTracingActive()) {
1578 Trace* tracer = Runtime::Current()->GetTracer();
1579 if (tracer->GetSavedCodeFromMap(method) == trampoline) {
1580 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1581 tracer->ResetSavedCode(method);
1582 method->SetCode(code);
1583 tracer->SaveAndUpdateCode(method);
1584 }
1585 } else if (method->GetCode() == trampoline) {
Ian Rogers19846512012-02-24 11:42:47 -08001586 const void* code = oat_class->GetOatMethod(method_index).GetCode();
Ian Rogers08f753d2012-08-24 14:35:25 -07001587 CHECK(code != NULL)
1588 << "Resolving a static trampoline but found no code for: " << PrettyMethod(method);
Ian Rogers19846512012-02-24 11:42:47 -08001589 method->SetCode(code);
1590 }
1591 method_index++;
1592 }
1593}
1594
Mathieu Chartier66f19252012-09-18 08:57:04 -07001595static void LinkCode(SirtRef<AbstractMethod>& method, const OatFile::OatClass* oat_class,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001596 uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001597 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001598 // Every kind of method should at least get an invoke stub from the oat_method.
1599 // non-abstract methods also get their code pointers.
1600 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstromae826982011-11-09 01:33:42 -08001601 oat_method.LinkMethodPointers(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001602
Ian Rogers19846512012-02-24 11:42:47 -08001603 Runtime* runtime = Runtime::Current();
Brian Carlstrom92827a52011-10-10 15:50:01 -07001604 if (method->IsAbstract()) {
Ian Rogers19846512012-02-24 11:42:47 -08001605 method->SetCode(runtime->GetAbstractMethodErrorStubArray()->GetData());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001606 return;
1607 }
Ian Rogers19846512012-02-24 11:42:47 -08001608
1609 if (method->IsStatic() && !method->IsConstructor()) {
1610 // For static methods excluding the class initializer, install the trampoline
1611 method->SetCode(runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData());
Ian Rogers0d6de042012-02-29 08:50:26 -08001612 }
1613 if (method->IsNative()) {
Brian Carlstrom92827a52011-10-10 15:50:01 -07001614 // unregistering restores the dlsym lookup stub
Ian Rogers19846512012-02-24 11:42:47 -08001615 method->UnregisterNative(Thread::Current());
jeffhao26c0a1a2012-01-17 16:28:33 -08001616 }
1617
1618 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhao26c0a1a2012-01-17 16:28:33 -08001619 Trace* tracer = Runtime::Current()->GetTracer();
jeffhaob5e81852012-03-12 11:15:45 -07001620 tracer->SaveAndUpdateCode(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001621 }
1622}
1623
Brian Carlstromf615a612011-07-23 12:50:34 -07001624void ClassLinker::LoadClass(const DexFile& dex_file,
1625 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001626 SirtRef<Class>& klass,
Ian Rogers365c1022012-06-22 15:05:28 -07001627 ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001628 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001629 CHECK(klass->GetDexCache() != NULL);
1630 CHECK_EQ(Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001631 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001632 CHECK(descriptor != NULL);
1633
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001634 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001635 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001636 // Make sure that none of our runtime-only flags are set.
mikaelpeltier6ffd0962012-10-25 15:37:45 +02001637 // TODO: JACK CLASS ACCESS (HACK TO BE REMOVED)
1638 CHECK_EQ(access_flags & ~(kAccJavaFlagsMask | kAccClassJack), 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001639 klass->SetAccessFlags(access_flags);
1640 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001641 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001642 klass->SetStatus(Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001643
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001644 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001645
Ian Rogers0571d352011-11-03 19:51:38 -07001646 // Load fields fields.
1647 const byte* class_data = dex_file.GetClassData(dex_class_def);
1648 if (class_data == NULL) {
1649 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001650 }
Ian Rogers0571d352011-11-03 19:51:38 -07001651 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001652 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001653 if (it.NumStaticFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001654 klass->SetSFields(AllocFieldArray(self, it.NumStaticFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001655 }
1656 if (it.NumInstanceFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001657 klass->SetIFields(AllocFieldArray(self, it.NumInstanceFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001658 }
1659 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001660 SirtRef<Field> sfield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001661 klass->SetStaticField(i, sfield.get());
1662 LoadField(dex_file, it, klass, sfield);
1663 }
1664 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001665 SirtRef<Field> ifield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001666 klass->SetInstanceField(i, ifield.get());
1667 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001668 }
1669
Brian Carlstromf5822582012-03-19 22:34:31 -07001670 UniquePtr<const OatFile::OatClass> oat_class;
1671 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1672 oat_class.reset(GetOatClass(dex_file, descriptor));
1673 }
Ian Rogers19846512012-02-24 11:42:47 -08001674
Ian Rogers0571d352011-11-03 19:51:38 -07001675 // Load methods.
1676 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001677 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001678 klass->SetDirectMethods(AllocAbstractMethodArray(self, it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001679 }
Ian Rogers0571d352011-11-03 19:51:38 -07001680 if (it.NumVirtualMethods() != 0) {
1681 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001682 klass->SetVirtualMethods(AllocMethodArray(self, it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001683 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001684 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001685 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001686 SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001687 klass->SetDirectMethod(i, method.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001688 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001689 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001690 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001691 method->SetMethodIndex(class_def_method_index);
1692 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001693 }
1694 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001695 SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001696 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001697 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001698 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001699 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001700 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001701 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001702 }
1703 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001704}
1705
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001706void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Ian Rogers0571d352011-11-03 19:51:38 -07001707 SirtRef<Class>& klass, SirtRef<Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001708 uint32_t field_idx = it.GetMemberIndex();
1709 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001710 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001711 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001712}
1713
Ian Rogers50b35e22012-10-04 10:09:15 -07001714AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
1715 const ClassDataItemIterator& it,
1716 SirtRef<Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001717 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001718 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001719 StringPiece method_name(dex_file.GetMethodName(method_id));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001720
1721 AbstractMethod* dst = NULL;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001722 if (method_name == "<init>") {
Ian Rogers50b35e22012-10-04 10:09:15 -07001723 dst = AllocConstructor(self);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001724 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001725 dst = AllocMethod(self);
Elliott Hughes80609252011-09-23 17:24:51 -07001726 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07001727 DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
1728
Ian Rogers50b35e22012-10-04 10:09:15 -07001729 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07001730 dst->SetDexMethodIndex(dex_method_idx);
1731 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001732
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001733 if (method_name == "finalize") {
1734 // Create the prototype for a signature of "()V"
1735 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1736 if (void_string_id != NULL) {
1737 const DexFile::TypeId* void_type_id =
1738 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1739 if (void_type_id != NULL) {
1740 std::vector<uint16_t> no_args;
1741 const DexFile::ProtoId* finalizer_proto =
1742 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1743 if (finalizer_proto != NULL) {
1744 // We have the prototype in the dex file
1745 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1746 klass->SetFinalizable();
1747 } else {
1748 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1749 // The Enum class declares a "final" finalize() method to prevent subclasses from
1750 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1751 // subclasses, so we exclude it here.
1752 // We also want to avoid setting the flag on Object, where we know that finalize() is
1753 // empty.
1754 if (klass_descriptor != "Ljava/lang/Object;" &&
1755 klass_descriptor != "Ljava/lang/Enum;") {
1756 klass->SetFinalizable();
1757 }
1758 }
1759 }
1760 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001761 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001762 }
Ian Rogers0571d352011-11-03 19:51:38 -07001763 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001764 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001765
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001766 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001767 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001768 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001769 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001770
1771 CHECK(dst->IsMethod());
1772
Ian Rogers50b35e22012-10-04 10:09:15 -07001773 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001774 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07001775}
1776
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001777void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001778 Thread* self = Thread::Current();
1779 SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001780 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001781}
1782
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001783void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
1784 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001785 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001786 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001787}
1788
Brian Carlstromaded5f72011-10-07 17:15:04 -07001789bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001790 dex_lock_.AssertHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001791 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1792 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001793 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001794 }
1795 }
1796 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001797}
1798
Brian Carlstromaded5f72011-10-07 17:15:04 -07001799bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001800 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001801 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001802}
1803
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001804void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001805 dex_lock_.AssertHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001806 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001807 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001808 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001809 dex_cache->SetDexFile(&dex_file);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001810 Dirty();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001811}
1812
Brian Carlstromaded5f72011-10-07 17:15:04 -07001813void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07001814 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001815 {
Ian Rogers1f539342012-10-03 21:09:42 -07001816 MutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001817 if (IsDexFileRegisteredLocked(dex_file)) {
1818 return;
1819 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001820 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001821 // Don't alloc while holding the lock, since allocation may need to
1822 // suspend all threads and another thread may need the dex_lock_ to
1823 // get to a suspend point.
Ian Rogers50b35e22012-10-04 10:09:15 -07001824 SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001825 {
Ian Rogers1f539342012-10-03 21:09:42 -07001826 MutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001827 if (IsDexFileRegisteredLocked(dex_file)) {
1828 return;
1829 }
1830 RegisterDexFileLocked(dex_file, dex_cache);
1831 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001832}
1833
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001834void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001835 MutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001836 RegisterDexFileLocked(dex_file, dex_cache);
1837}
1838
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001839DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001840 MutexLock mu(Thread::Current(), dex_lock_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001841 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1842 DexCache* dex_cache = dex_caches_[i];
1843 if (dex_cache->GetDexFile() == &dex_file) {
1844 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001845 }
1846 }
Elliott Hughes7b9d9962012-04-20 18:48:18 -07001847 LOG(FATAL) << "Failed to find DexCache for DexFile " << dex_file.GetLocation();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001848 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001849}
1850
Mathieu Chartier66f19252012-09-18 08:57:04 -07001851void ClassLinker::FixupDexCaches(AbstractMethod* resolution_method) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07001852 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08001853 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1854 dex_caches_[i]->Fixup(resolution_method);
1855 }
1856}
1857
Ian Rogersc8982582012-09-07 16:53:25 -07001858Class* ClassLinker::InitializePrimitiveClass(Class* primitive_class, Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001859 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07001860 // Must hold lock on object when initializing.
1861 ObjectLock lock(Thread::Current(), primitive_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001862 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001863 primitive_class->SetPrimitiveType(type);
1864 primitive_class->SetStatus(Class::kStatusInitialized);
Ian Rogersc8982582012-09-07 16:53:25 -07001865 Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
1866 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001867 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001868}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001869
Brian Carlstrombe977852011-07-19 14:54:54 -07001870// Create an array class (i.e. the class object for the array, not the
1871// array itself). "descriptor" looks like "[C" or "[[[[B" or
1872// "[Ljava/lang/String;".
1873//
1874// If "descriptor" refers to an array of primitives, look up the
1875// primitive type's internally-generated class object.
1876//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001877// "class_loader" is the class loader of the class that's referring to
1878// us. It's used to ensure that we're looking for the element type in
1879// the right context. It does NOT become the class loader for the
1880// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001881//
1882// Returns NULL with an exception raised on failure.
Ian Rogers365c1022012-06-22 15:05:28 -07001883Class* ClassLinker::CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001884 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001885
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001886 // Identify the underlying component type
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001887 Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001888 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001889 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001890 return NULL;
1891 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001892
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001893 // See if the component type is already loaded. Array classes are
1894 // always associated with the class loader of their underlying
1895 // element type -- an array of Strings goes with the loader for
1896 // java/lang/String -- so we need to look for it there. (The
1897 // caller should have checked for the existence of the class
1898 // before calling here, but they did so with *their* class loader,
1899 // not the component type's loader.)
1900 //
1901 // If we find it, the caller adds "loader" to the class' initiating
1902 // loader list, which should prevent us from going through this again.
1903 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001904 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001905 // are the same, because our caller (FindClass) just did the
1906 // lookup. (Even if we get this wrong we still have correct behavior,
1907 // because we effectively do this lookup again when we add the new
1908 // class to the hash table --- necessary because of possible races with
1909 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001910 if (class_loader != component_type->GetClassLoader()) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001911 Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001912 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001913 return new_class;
1914 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001915 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001916
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001917 // Fill out the fields in the Class.
1918 //
1919 // It is possible to execute some methods against arrays, because
1920 // all arrays are subclasses of java_lang_Object_, so we need to set
1921 // up a vtable. We can just point at the one in java_lang_Object_.
1922 //
1923 // Array classes are simple enough that we don't need to do a full
1924 // link step.
Ian Rogers1f539342012-10-03 21:09:42 -07001925 Thread* self = Thread::Current();
1926 SirtRef<Class> new_class(self, NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001927 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001928 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07001929 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001930 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07001931 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001932 new_class.reset(GetClassRoot(kObjectArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001933 } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
1934 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001935 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]) {
1936 new_class.reset(GetClassRoot(kJavaLangReflectAbstractMethodArrayClass));
Ian Rogers4445a7e2012-10-05 17:19:13 -07001937 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectFieldArrayClass]) {
1938 new_class.reset(GetClassRoot(kJavaLangReflectFieldArrayClass));
1939 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectMethodArrayClass]) {
1940 new_class.reset(GetClassRoot(kJavaLangReflectMethodArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001941 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001942 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001943 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001944 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001945 }
1946 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001947 if (new_class.get() == NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001948 new_class.reset(AllocClass(self, sizeof(Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001949 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001950 return NULL;
1951 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001952 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001953 }
Ian Rogers1f539342012-10-03 21:09:42 -07001954 ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001955 DCHECK(new_class->GetComponentType() != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001956 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001957 new_class->SetSuperClass(java_lang_Object);
1958 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001959 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001960 new_class->SetClassLoader(component_type->GetClassLoader());
1961 new_class->SetStatus(Class::kStatusInitialized);
1962 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001963 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001964
1965
1966 // All arrays have java/lang/Cloneable and java/io/Serializable as
1967 // interfaces. We need to set that up here, so that stuff like
1968 // "instanceof" works right.
1969 //
1970 // Note: The GC could run during the call to FindSystemClass,
1971 // so we need to make sure the class object is GC-valid while we're in
1972 // there. Do this by clearing the interface list so the GC will just
1973 // think that the entries are null.
1974
1975
1976 // Use the single, global copies of "interfaces" and "iftable"
1977 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07001978 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07001979 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001980
1981 // Inherit access flags from the component type. Arrays can't be
1982 // used as a superclass or interface, so we want to add "final"
1983 // and remove "interface".
1984 //
1985 // Don't inherit any non-standard flags (e.g., kAccFinal)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001986 // from component_type. We assume that the array class does not
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001987 // override finalize().
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001988 new_class->SetAccessFlags(((new_class->GetComponentType()->GetAccessFlags() &
1989 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001990
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001991 Class* existing = InsertClass(descriptor, new_class.get(), false);
1992 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001993 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001994 }
1995 // Another thread must have loaded the class after we
1996 // started but before we finished. Abandon what we've
1997 // done.
1998 //
1999 // (Yes, this happens.)
2000
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002001 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002002}
2003
2004Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002005 switch (Primitive::GetType(type)) {
2006 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002007 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002008 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002009 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002010 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002011 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002012 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002013 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002014 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002015 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002016 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002017 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002018 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002019 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002020 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002021 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002022 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002023 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002024 case Primitive::kPrimNot:
2025 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002026 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002027 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002028 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002029 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002030}
2031
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002032Class* ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass, bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002033 if (VLOG_IS_ON(class_linker)) {
Brian Carlstromae826982011-11-09 01:33:42 -08002034 DexCache* dex_cache = klass->GetDexCache();
2035 std::string source;
2036 if (dex_cache != NULL) {
2037 source += " from ";
2038 source += dex_cache->GetLocation()->ToModifiedUtf8();
2039 }
2040 LOG(INFO) << "Loaded class " << descriptor << source;
2041 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002042 size_t hash = StringPieceHash()(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002043 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002044 Table& classes = image_class ? image_classes_ : classes_;
Elliott Hughesf8349362012-06-18 15:00:06 -07002045 Class* existing = LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002046#ifndef NDEBUG
2047 // Check we don't have the class in the other table in error
2048 Table& other_classes = image_class ? classes_ : image_classes_;
Elliott Hughesf8349362012-06-18 15:00:06 -07002049 CHECK(LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002050#endif
2051 if (existing != NULL) {
2052 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002053 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002054 classes.insert(std::make_pair(hash, klass));
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07002055 Dirty();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002056 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002057}
2058
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002059bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
2060 size_t hash = Hash(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002061 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08002062 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08002063 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002064 ClassHelper kh;
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002065 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08002066 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002067 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002068 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002069 classes_.erase(it);
2070 return true;
2071 }
2072 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002073 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Brian Carlstromae826982011-11-09 01:33:42 -08002074 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002075 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002076 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002077 image_classes_.erase(it);
2078 return true;
2079 }
2080 }
2081 return false;
2082}
2083
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002084Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
2085 size_t hash = Hash(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002086 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07002087 // TODO: determine if its better to search classes_ or image_classes_ first
Elliott Hughesf8349362012-06-18 15:00:06 -07002088 Class* klass = LookupClassLocked(descriptor, class_loader, hash, classes_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002089 if (klass != NULL) {
2090 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002091 }
Elliott Hughesf8349362012-06-18 15:00:06 -07002092 return LookupClassLocked(descriptor, class_loader, hash, image_classes_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002093}
2094
Elliott Hughesf8349362012-06-18 15:00:06 -07002095Class* ClassLinker::LookupClassLocked(const char* descriptor, const ClassLoader* class_loader,
2096 size_t hash, const Table& classes) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002097 ClassHelper kh(NULL, this);
2098 typedef Table::const_iterator It; // TODO: C++0x auto
2099 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers5d76c432011-10-31 21:42:49 -07002100 Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002101 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002102 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002103#ifndef NDEBUG
2104 for (++it; it != end && it->first == hash; ++it) {
Ian Rogersd85016c2012-02-03 18:27:34 -08002105 Class* klass2 = it->second;
2106 kh.ChangeClass(klass2);
2107 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002108 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08002109 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002110 }
2111#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07002112 return klass;
2113 }
2114 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002115 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002116}
2117
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002118void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002119 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002120 size_t hash = Hash(descriptor);
Ian Rogers50b35e22012-10-04 10:09:15 -07002121 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002122 typedef Table::const_iterator It; // TODO: C++0x auto
2123 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002124 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002125 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002126 Class* klass = it->second;
2127 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002128 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002129 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002130 }
2131 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002132 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002133 Class* klass = it->second;
2134 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002135 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002136 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002137 }
2138 }
2139}
2140
jeffhao98eacac2011-09-14 16:11:53 -07002141void ClassLinker::VerifyClass(Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002142 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002143 Thread* self = Thread::Current();
2144 ObjectLock lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002145
Ian Rogers9ffb0392012-09-10 11:56:50 -07002146 // Don't attempt to re-verify if already sufficiently verified.
2147 if (klass->IsVerified() ||
2148 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002149 return;
2150 }
2151
Ian Rogers9ffb0392012-09-10 11:56:50 -07002152 // The class might already be erroneous, for example at compile time if we attempted to verify
2153 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002154 if (klass->IsErroneous()) {
2155 ThrowEarlierClassFailure(klass);
2156 return;
2157 }
2158
Ian Rogers9ffb0392012-09-10 11:56:50 -07002159 if (klass->GetStatus() == Class::kStatusResolved) {
2160 klass->SetStatus(Class::kStatusVerifying);
2161 } else {
2162 CHECK_EQ(klass->GetStatus(), Class::kStatusRetryVerificationAtRuntime) << PrettyClass(klass);
2163 CHECK(!Runtime::Current()->IsCompiler());
2164 klass->SetStatus(Class::kStatusVerifyingAtRuntime);
2165 }
jeffhao98eacac2011-09-14 16:11:53 -07002166
Ian Rogers9ffb0392012-09-10 11:56:50 -07002167 // Verify super class.
Ian Rogers1c5eb702012-02-01 09:18:34 -08002168 Class* super = klass->GetSuperClass();
2169 std::string error_msg;
2170 if (super != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002171 // Acquire lock to prevent races on verifying the super class.
Ian Rogers1f539342012-10-03 21:09:42 -07002172 ObjectLock lock(self, super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002173
2174 if (!super->IsVerified() && !super->IsErroneous()) {
2175 Runtime::Current()->GetClassLinker()->VerifyClass(super);
2176 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002177 if (!super->IsCompileTimeVerified()) {
Ian Rogers1c5eb702012-02-01 09:18:34 -08002178 error_msg = "Rejecting class ";
2179 error_msg += PrettyDescriptor(klass);
2180 error_msg += " that attempts to sub-class erroneous class ";
2181 error_msg += PrettyDescriptor(super);
2182 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers1f539342012-10-03 21:09:42 -07002183 SirtRef<Throwable> cause(self, self->GetException());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002184 if (cause.get() != NULL) {
2185 self->ClearException();
2186 }
2187 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2188 if (cause.get() != NULL) {
2189 self->GetException()->SetCause(cause.get());
2190 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08002191 klass->SetStatus(Class::kStatusError);
2192 return;
2193 }
2194 }
2195
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002196 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002197 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002198 Class::Status oat_file_class_status(Class::kStatusNotReady);
2199 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
jeffhaof1e6b7c2012-06-05 18:33:30 -07002200 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
jeffhaoec014232012-09-05 10:42:25 -07002201 if (oat_file_class_status == Class::kStatusError) {
2202 LOG(WARNING) << "Skipping runtime verification of erroneous class " << PrettyDescriptor(klass)
2203 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
2204 error_msg = "Rejecting class ";
2205 error_msg += PrettyDescriptor(klass);
2206 error_msg += " because it failed compile-time verification";
2207 Thread::Current()->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
2208 klass->SetStatus(Class::kStatusError);
2209 return;
2210 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002211 if (!preverified) {
2212 verifier_failure = verifier::MethodVerifier::VerifyClass(klass, error_msg);
2213 }
2214 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002215 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
2216 LOG(WARNING) << "Soft verification failure in class " << PrettyDescriptor(klass)
2217 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2218 << " because: " << error_msg;
2219 }
Ian Rogers1f539342012-10-03 21:09:42 -07002220 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002221 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002222 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002223 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
2224 klass->SetStatus(Class::kStatusVerified);
2225 } else {
2226 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2227 // Soft failures at compile time should be retried at runtime. Soft
2228 // failures at runtime will be handled by slow paths in the generated
2229 // code. Set status accordingly.
2230 if (Runtime::Current()->IsCompiler()) {
2231 klass->SetStatus(Class::kStatusRetryVerificationAtRuntime);
2232 } else {
2233 klass->SetStatus(Class::kStatusVerified);
2234 }
2235 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002236 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002237 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002238 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2239 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002240 self->AssertNoPendingException();
Ian Rogers1c5eb702012-02-01 09:18:34 -08002241 self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07002242 klass->SetStatus(Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002243 }
jeffhao98eacac2011-09-14 16:11:53 -07002244}
2245
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002246bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
2247 Class::Status& oat_file_class_status) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002248 if (!Runtime::Current()->IsStarted()) {
2249 return false;
2250 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002251 if (Runtime::Current()->UseCompileTimeClassPath()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002252 return false;
2253 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002254 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
2255 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002256 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002257 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002258 const char* descriptor = ClassHelper(klass).GetDescriptor();
2259 uint32_t class_def_index;
2260 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002261 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002262 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002263 CHECK(oat_class.get() != NULL)
2264 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002265 oat_file_class_status = oat_class->GetStatus();
Ian Rogers9ffb0392012-09-10 11:56:50 -07002266 if (oat_file_class_status == Class::kStatusVerified ||
2267 oat_file_class_status == Class::kStatusInitialized) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002268 return true;
2269 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002270 if (oat_file_class_status == Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002271 // Compile time verification failed with a soft error. Compile time verification can fail
2272 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002273 // class ... {
2274 // Foo x;
2275 // .... () {
2276 // if (...) {
2277 // v1 gets assigned a type of resolved class Foo
2278 // } else {
2279 // v1 gets assigned a type of unresolved class Bar
2280 // }
2281 // iput x = v1
2282 // } }
2283 // when we merge v1 following the if-the-else it results in Conflict
2284 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2285 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2286 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2287 // at compile time).
2288 return false;
2289 }
jeffhao1ac29442012-03-26 11:37:32 -07002290 if (oat_file_class_status == Class::kStatusError) {
2291 // Compile time verification failed with a hard error. This is caused by invalid instructions
2292 // in the class. These errors are unrecoverable.
2293 return false;
2294 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002295 if (oat_file_class_status == Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002296 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2297 // not loading the class.
2298 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2299 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002300 return false;
2301 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002302 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002303 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2304
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002305 return false;
2306}
2307
2308void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
2309 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2310 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2311 }
2312 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2313 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2314 }
2315}
2316
Mathieu Chartier66f19252012-09-18 08:57:04 -07002317void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, AbstractMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002318 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2319 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2320 if (code_item == NULL) {
2321 return; // native or abstract method
2322 }
2323 if (code_item->tries_size_ == 0) {
2324 return; // nothing to process
2325 }
2326 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2327 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2328 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2329 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2330 CatchHandlerIterator iterator(handlers_ptr);
2331 for (; iterator.HasNext(); iterator.Next()) {
2332 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2333 // unresolved exception types will be ignored by exception delivery
2334 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
2335 Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
2336 if (exception_type == NULL) {
2337 DCHECK(Thread::Current()->IsExceptionPending());
2338 Thread::Current()->ClearException();
2339 }
2340 }
2341 }
2342 handlers_ptr = iterator.EndDataPointer();
2343 }
2344}
2345
Mathieu Chartier66f19252012-09-18 08:57:04 -07002346static void CheckProxyConstructor(AbstractMethod* constructor);
2347static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002348
Jesse Wilson95caa792011-10-12 18:14:17 -04002349Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
Mathieu Chartier66f19252012-09-18 08:57:04 -07002350 ClassLoader* loader, ObjectArray<AbstractMethod>* methods,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002351 ObjectArray<ObjectArray<Class> >* throws) {
Ian Rogers1f539342012-10-03 21:09:42 -07002352 Thread* self = Thread::Current();
Ian Rogers50b35e22012-10-04 10:09:15 -07002353 SirtRef<Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2354 sizeof(SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002355 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002356 DCHECK(klass->GetClass() != NULL);
Jesse Wilson95caa792011-10-12 18:14:17 -04002357 klass->SetObjectSize(sizeof(Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002358 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002359 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002360 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002361 klass->SetName(name);
Ian Rogers466bb252011-10-14 03:29:56 -07002362 Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002363 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002364
2365 klass->SetStatus(Class::kStatusIdx);
2366
2367 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2368
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002369 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogers4445a7e2012-10-05 17:19:13 -07002370 klass->SetSFields(AllocFieldArray(self, 2));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002371 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2372 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Ian Rogers50b35e22012-10-04 10:09:15 -07002373 SirtRef<Field> interfaces_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002374 klass->SetStaticField(0, interfaces_sfield.get());
2375 interfaces_sfield->SetDexFieldIndex(0);
2376 interfaces_sfield->SetDeclaringClass(klass.get());
2377 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2378 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Ian Rogers50b35e22012-10-04 10:09:15 -07002379 SirtRef<Field> throws_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002380 klass->SetStaticField(1, throws_sfield.get());
2381 throws_sfield->SetDexFieldIndex(1);
2382 throws_sfield->SetDeclaringClass(klass.get());
2383 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002384
Ian Rogers466bb252011-10-14 03:29:56 -07002385 // Proxies have 1 direct method, the constructor
Ian Rogers4445a7e2012-10-05 17:19:13 -07002386 klass->SetDirectMethods(AllocAbstractMethodArray(self, 1));
Ian Rogers50b35e22012-10-04 10:09:15 -07002387 klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002388
Ian Rogers466bb252011-10-14 03:29:56 -07002389 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002390 size_t num_virtual_methods = methods->GetLength();
Ian Rogers4445a7e2012-10-05 17:19:13 -07002391 klass->SetVirtualMethods(AllocMethodArray(self, num_virtual_methods));
Jesse Wilson95caa792011-10-12 18:14:17 -04002392 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers1f539342012-10-03 21:09:42 -07002393 SirtRef<AbstractMethod> prototype(self, methods->Get(i));
Ian Rogers50b35e22012-10-04 10:09:15 -07002394 klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002395 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002396
2397 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
2398 klass->SetStatus(Class::kStatusLoaded); // Class is now effectively in the loaded state
2399 DCHECK(!Thread::Current()->IsExceptionPending());
2400
2401 // Link the fields and virtual methods, creating vtable and iftables
2402 if (!LinkClass(klass, interfaces)) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002403 klass->SetStatus(Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002404 return NULL;
2405 }
Ian Rogersc8982582012-09-07 16:53:25 -07002406 {
Ian Rogers1f539342012-10-03 21:09:42 -07002407 ObjectLock lock(self, klass.get()); // Must hold lock on object when initializing.
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002408 interfaces_sfield->SetObject(klass.get(), interfaces);
2409 throws_sfield->SetObject(klass.get(), throws);
Ian Rogersc8982582012-09-07 16:53:25 -07002410 klass->SetStatus(Class::kStatusInitialized);
2411 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002412
2413 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002414 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002415 CHECK(klass->GetIFields() == NULL);
2416 CheckProxyConstructor(klass->GetDirectMethod(0));
2417 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers1f539342012-10-03 21:09:42 -07002418 SirtRef<AbstractMethod> prototype(self, methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002419 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2420 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002421
2422 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2423 name->ToModifiedUtf8().c_str()));
2424 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2425
2426 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2427 name->ToModifiedUtf8().c_str()));
2428 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002429
2430 SynthesizedProxyClass* synth_proxy_class = down_cast<SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002431 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002432 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2433 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002434 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002435}
2436
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002437std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
2438 DCHECK(proxy_class->IsProxyClass());
2439 String* name = proxy_class->GetName();
2440 DCHECK(name != NULL);
2441 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2442}
2443
Mathieu Chartier66f19252012-09-18 08:57:04 -07002444AbstractMethod* ClassLinker::FindMethodForProxy(const Class* proxy_class, const AbstractMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002445 DCHECK(proxy_class->IsProxyClass());
2446 DCHECK(proxy_method->IsProxyMethod());
2447 // Locate the dex cache of the original interface/Object
2448 DexCache* dex_cache = NULL;
2449 {
2450 ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers50b35e22012-10-04 10:09:15 -07002451 MutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002452 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2453 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2454 dex_cache = dex_caches_[i];
2455 break;
2456 }
2457 }
2458 }
2459 CHECK(dex_cache != NULL);
2460 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Mathieu Chartier66f19252012-09-18 08:57:04 -07002461 AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002462 CHECK(resolved_method != NULL);
2463 return resolved_method;
2464}
2465
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002466
Ian Rogers50b35e22012-10-04 10:09:15 -07002467AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self, SirtRef<Class>& klass, Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002468 // Create constructor for Proxy that must initialize h
Mathieu Chartier66f19252012-09-18 08:57:04 -07002469 ObjectArray<AbstractMethod>* proxy_direct_methods = proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002470 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002471 AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002472 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2473 // code_ too)
Ian Rogers50b35e22012-10-04 10:09:15 -07002474 AbstractMethod* constructor = down_cast<AbstractMethod*>(proxy_constructor->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002475 // Make this constructor public and fix the class to be our Proxy version
2476 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002477 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002478 return constructor;
2479}
2480
Mathieu Chartier66f19252012-09-18 08:57:04 -07002481static void CheckProxyConstructor(AbstractMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002482 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002483 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002484 MethodHelper mh(constructor);
2485 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002486 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002487 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002488}
2489
Ian Rogers50b35e22012-10-04 10:09:15 -07002490AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<Class>& klass,
2491 SirtRef<AbstractMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002492 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2493 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002494 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2495 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002496 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002497 // as necessary
Ian Rogers50b35e22012-10-04 10:09:15 -07002498 AbstractMethod* method = down_cast<AbstractMethod*>(prototype->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002499
2500 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2501 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002502 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002503 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002504
Ian Rogers466bb252011-10-14 03:29:56 -07002505 // At runtime the method looks like a reference and argument saving method, clone the code
2506 // related parameters from this method.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002507 AbstractMethod* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07002508 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2509 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2510 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
TDYa1275bb86012012-04-11 05:57:28 -07002511#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers466bb252011-10-14 03:29:56 -07002512 method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
TDYa1275bb86012012-04-11 05:57:28 -07002513#else
Logan Chien7a2a23a2012-06-06 11:01:00 +08002514 OatFile::OatMethod oat_method = GetOatMethodFor(prototype.get());
2515 method->SetCode(oat_method.GetProxyStub());
TDYa1275bb86012012-04-11 05:57:28 -07002516#endif
Ian Rogers16f93672012-02-14 12:29:06 -08002517
Ian Rogersc2b44472011-12-14 21:17:17 -08002518 return method;
2519}
Jesse Wilson95caa792011-10-12 18:14:17 -04002520
Mathieu Chartier66f19252012-09-18 08:57:04 -07002521static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002522 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002523 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002524 CHECK(!prototype->IsFinal());
2525 CHECK(method->IsFinal());
2526 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002527
2528 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2529 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2530 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2531 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2532 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2533 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2534 method->GetDexCacheInitializedStaticStorage());
2535 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2536
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002537 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002538 MethodHelper mh2(prototype.get());
2539 CHECK_STREQ(mh.GetName(), mh2.GetName());
2540 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002541 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002542 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002543}
2544
Ian Rogers0045a292012-03-31 21:08:41 -07002545bool ClassLinker::InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002546 CHECK(klass->IsResolved() || klass->IsErroneous())
Ian Rogers9ffb0392012-09-10 11:56:50 -07002547 << PrettyClass(klass) << ": state=" << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002548
Carl Shapirob5573532011-07-12 18:22:59 -07002549 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002550
Mathieu Chartier66f19252012-09-18 08:57:04 -07002551 AbstractMethod* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002552 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002553 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Ian Rogers1f539342012-10-03 21:09:42 -07002554 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002555
Brian Carlstromd1422f82011-09-28 11:37:09 -07002556 if (klass->GetStatus() == Class::kStatusInitialized) {
2557 return true;
2558 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002559
Brian Carlstromd1422f82011-09-28 11:37:09 -07002560 if (klass->IsErroneous()) {
2561 ThrowEarlierClassFailure(klass);
2562 return false;
2563 }
2564
jeffhaoebe2e0f2012-06-06 15:19:40 -07002565 if (klass->GetStatus() == Class::kStatusResolved ||
2566 klass->GetStatus() == Class::kStatusRetryVerificationAtRuntime) {
jeffhao98eacac2011-09-14 16:11:53 -07002567 VerifyClass(klass);
2568 if (klass->GetStatus() != Class::kStatusVerified) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07002569 if (klass->GetStatus() == Class::kStatusError) {
2570 CHECK(self->IsExceptionPending());
2571 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002572 return false;
2573 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002574 }
2575
Brian Carlstrom25c33252011-09-18 15:58:35 -07002576 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2577 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002578 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002579 // don't bother going to kStatusInitializing. We return false so that
2580 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002581 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2582 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002583 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002584 }
2585
Brian Carlstromd1422f82011-09-28 11:37:09 -07002586 // If the class is kStatusInitializing, either this thread is
2587 // initializing higher up the stack or another thread has beat us
2588 // to initializing and we need to wait. Either way, this
2589 // invocation of InitializeClass will not be responsible for
2590 // running <clinit> and will return.
2591 if (klass->GetStatus() == Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002592 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002593 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002594 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002595 return true;
2596 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002597 // No. That's fine. Wait for another thread to finish initializing.
2598 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002599 }
2600
2601 if (!ValidateSuperClassDescriptors(klass)) {
2602 klass->SetStatus(Class::kStatusError);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002603 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002604 return false;
2605 }
2606
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002607 DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002608
Elliott Hughesdcc24742011-09-07 14:02:44 -07002609 klass->SetClinitThreadId(self->GetTid());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002610 klass->SetStatus(Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002611 }
2612
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002613 uint64_t t0 = NanoTime();
2614
Ian Rogers0045a292012-03-31 21:08:41 -07002615 if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002616 // Super class initialization failed, this can be because we can't run
2617 // super-class class initializers in which case we'll be verified.
2618 // Otherwise this class is erroneous.
2619 if (!can_run_clinit) {
2620 CHECK(klass->IsVerified());
2621 } else {
2622 CHECK(klass->IsErroneous());
2623 }
Ian Rogers3d1548d2012-09-24 14:08:03 -07002624 // Signal to any waiting threads that saw this class as initializing.
Ian Rogers1f539342012-10-03 21:09:42 -07002625 ObjectLock lock(self, klass);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002626 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002627 return false;
2628 }
2629
Ian Rogers0045a292012-03-31 21:08:41 -07002630 bool has_static_field_initializers = InitializeStaticFields(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002631
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002632 if (clinit != NULL) {
Ian Rogers64b6d142012-10-29 16:34:15 -07002633 if (Runtime::Current()->IsStarted()) {
2634 clinit->Invoke(self, NULL, NULL, NULL);
2635 } else {
2636 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
2637 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002638 }
2639
Ian Rogers19846512012-02-24 11:42:47 -08002640 FixupStaticTrampolines(klass);
2641
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002642 uint64_t t1 = NanoTime();
2643
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002644 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002645 {
Ian Rogers1f539342012-10-03 21:09:42 -07002646 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002647
2648 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002649 WrapExceptionInInitializer();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002650 klass->SetStatus(Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002651 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002652 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002653 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2654 RuntimeStats* thread_stats = self->GetStats();
2655 ++global_stats->class_init_count;
2656 ++thread_stats->class_init_count;
2657 global_stats->class_init_time_ns += (t1 - t0);
2658 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogers0045a292012-03-31 21:08:41 -07002659 // Set the class as initialized except if we can't initialize static fields and static field
2660 // initialization is necessary.
2661 if (!can_init_statics && has_static_field_initializers) {
2662 klass->SetStatus(Class::kStatusVerified); // Don't leave class in initializing state.
2663 success = false;
2664 } else {
2665 klass->SetStatus(Class::kStatusInitialized);
2666 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002667 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002668 ClassHelper kh(klass);
2669 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002670 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002671 }
2672 lock.NotifyAll();
2673 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002674 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002675}
2676
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002677bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002678 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002679 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002680 self->AssertNoPendingException();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002681 lock.Wait();
2682
2683 // When we wake up, repeat the test for init-in-progress. If
2684 // there's an exception pending (only possible if
2685 // "interruptShouldThrow" was set), bail out.
2686 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002687 WrapExceptionInInitializer();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002688 klass->SetStatus(Class::kStatusError);
2689 return false;
2690 }
2691 // Spurious wakeup? Go back to waiting.
2692 if (klass->GetStatus() == Class::kStatusInitializing) {
2693 continue;
2694 }
Ian Rogers3d1548d2012-09-24 14:08:03 -07002695 if (klass->GetStatus() == Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
2696 // Compile time initialization failed.
2697 return false;
2698 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002699 if (klass->IsErroneous()) {
2700 // The caller wants an exception, but it was thrown in a
2701 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002702 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002703 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002704 return false;
2705 }
2706 if (klass->IsInitialized()) {
2707 return true;
2708 }
2709 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2710 }
2711 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2712}
2713
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002714bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
2715 if (klass->IsInterface()) {
2716 return true;
2717 }
2718 // begin with the methods local to the superclass
2719 if (klass->HasSuperClass() &&
2720 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
2721 const Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002722 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002723 const AbstractMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08002724 if (method != super->GetVTable()->Get(i) &&
2725 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002726 ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
2727 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2728 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002729 return false;
2730 }
2731 }
2732 }
Ian Rogers9bc81912012-10-11 21:43:36 -07002733 IfTable* iftable = klass->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002734 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07002735 Class* interface = iftable->GetInterface(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002736 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2737 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Ian Rogers9bc81912012-10-11 21:43:36 -07002738 const AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002739 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2740 method->GetDeclaringClass())) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002741 ThrowLinkageError("Class %s method %s resolves differently in interface %s",
2742 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2743 PrettyMethod(method).c_str(),
2744 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002745 return false;
2746 }
2747 }
2748 }
2749 }
2750 return true;
2751}
2752
Ian Rogers595799e2012-01-11 17:32:51 -08002753// Returns true if classes referenced by the signature of the method are the
2754// same classes in klass1 as they are in klass2.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002755bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const AbstractMethod* method,
Ian Rogers595799e2012-01-11 17:32:51 -08002756 const Class* klass1,
2757 const Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002758 if (klass1 == klass2) {
2759 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002760 }
Ian Rogers4445a7e2012-10-05 17:19:13 -07002761 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002762 const DexFile::ProtoId& proto_id =
2763 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002764 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2765 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002766 if (descriptor == NULL) {
2767 break;
2768 }
2769 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2770 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002771 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002772 return false;
2773 }
2774 }
2775 }
2776 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002777 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002778 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002779 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002780 return false;
2781 }
2782 }
2783 return true;
2784}
2785
Ian Rogers595799e2012-01-11 17:32:51 -08002786// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2787bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
2788 const Class* klass1,
2789 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002790 CHECK(descriptor != NULL);
2791 CHECK(klass1 != NULL);
2792 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002793 if (klass1 == klass2) {
2794 return true;
2795 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002796 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002797 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002798 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002799 }
Ian Rogers595799e2012-01-11 17:32:51 -08002800 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
2801 if (found2 == NULL) {
2802 Thread::Current()->ClearException();
2803 }
2804 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002805}
2806
Ian Rogers0045a292012-03-31 21:08:41 -07002807bool ClassLinker::InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002808 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002809 if (!klass->IsInterface() && klass->HasSuperClass()) {
2810 Class* super_class = klass->GetSuperClass();
Ian Rogers9ffb0392012-09-10 11:56:50 -07002811 if (!super_class->IsInitialized()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002812 CHECK(!super_class->IsInterface());
Ian Rogers1f539342012-10-03 21:09:42 -07002813 // Must hold lock on object when initializing and setting status.
2814 ObjectLock lock(Thread::Current(), klass);
Ian Rogers0045a292012-03-31 21:08:41 -07002815 bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002816 // TODO: check for a pending exception
2817 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002818 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002819 // Don't set status to error when we can't run <clinit>.
2820 CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
2821 klass->SetStatus(Class::kStatusVerified);
2822 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002823 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002824 klass->SetStatus(Class::kStatusError);
2825 klass->NotifyAll();
2826 return false;
2827 }
2828 }
2829 }
2830 return true;
2831}
2832
Ian Rogers0045a292012-03-31 21:08:41 -07002833bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields) {
Mathieu Chartier155dfe92012-10-09 14:24:49 -07002834 DCHECK(c != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002835 if (c->IsInitialized()) {
2836 return true;
2837 }
2838
Elliott Hughes5f791332011-09-15 17:45:30 -07002839 Thread* self = Thread::Current();
Elliott Hughes34e06962012-04-09 13:55:55 -07002840 ScopedThreadStateChange tsc(self, kRunnable);
Ian Rogers0045a292012-03-31 21:08:41 -07002841 bool success = InitializeClass(c, can_run_clinit, can_init_fields);
Ian Rogers595799e2012-01-11 17:32:51 -08002842 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002843 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002844 }
2845 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002846}
2847
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002848void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Elliott Hughesa0e18062012-04-13 15:59:59 -07002849 Class* c, SafeMap<uint32_t, Field*>& field_map) {
Ian Rogers365c1022012-06-22 15:05:28 -07002850 ClassLoader* cl = c->GetClassLoader();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002851 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002852 ClassDataItemIterator it(dex_file, class_data);
2853 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002854 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002855 }
2856}
2857
Ian Rogers0045a292012-03-31 21:08:41 -07002858bool ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002859 size_t num_static_fields = klass->NumStaticFields();
2860 if (num_static_fields == 0) {
Ian Rogers0045a292012-03-31 21:08:41 -07002861 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002862 }
Brian Carlstromf615a612011-07-23 12:50:34 -07002863 DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002864 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002865 if (dex_cache == NULL) {
Ian Rogers0045a292012-03-31 21:08:41 -07002866 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002867 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002868 ClassHelper kh(klass);
2869 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002870 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002871 const DexFile& dex_file = kh.GetDexFile();
Brian Carlstrom88f36542012-10-16 23:24:21 -07002872 EncodedStaticFieldValueIterator it(dex_file, dex_cache, klass->GetClassLoader(),
2873 this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002874
Ian Rogers0571d352011-11-03 19:51:38 -07002875 if (it.HasNext()) {
2876 // 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 -07002877 SafeMap<uint32_t, Field*> field_map;
Ian Rogers0571d352011-11-03 19:51:38 -07002878 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
2879 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002880 it.ReadValueToField(field_map.Get(i));
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002881 }
Ian Rogers0045a292012-03-31 21:08:41 -07002882 return true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002883 }
Ian Rogers0045a292012-03-31 21:08:41 -07002884 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002885}
2886
Ian Rogersc2b44472011-12-14 21:17:17 -08002887bool ClassLinker::LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002888 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002889 if (!LinkSuperClass(klass)) {
2890 return false;
2891 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002892 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002893 return false;
2894 }
2895 if (!LinkInstanceFields(klass)) {
2896 return false;
2897 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07002898 if (!LinkStaticFields(klass)) {
2899 return false;
2900 }
2901 CreateReferenceInstanceOffsets(klass);
2902 CreateReferenceStaticOffsets(klass);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002903 CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
2904 klass->SetStatus(Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002905 return true;
2906}
2907
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002908bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002909 CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002910 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
2911 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08002912 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002913 uint16_t super_class_idx = class_def->superclass_idx_;
2914 if (super_class_idx != DexFile::kDexNoIndex16) {
2915 Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002916 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07002917 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002918 return false;
2919 }
Ian Rogersbe125a92012-01-11 15:19:49 -08002920 // Verify
2921 if (!klass->CanAccess(super_class)) {
2922 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2923 "Class %s extended by class %s is inaccessible",
2924 PrettyDescriptor(super_class).c_str(),
2925 PrettyDescriptor(klass.get()).c_str());
2926 return false;
2927 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002928 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002929 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002930 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
2931 if (interfaces != NULL) {
2932 for (size_t i = 0; i < interfaces->Size(); i++) {
2933 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
2934 Class* interface = ResolveType(dex_file, idx, klass.get());
2935 if (interface == NULL) {
2936 DCHECK(Thread::Current()->IsExceptionPending());
2937 return false;
2938 }
2939 // Verify
2940 if (!klass->CanAccess(interface)) {
2941 // TODO: the RI seemed to ignore this in my testing.
2942 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
2943 "Interface %s implemented by class %s is inaccessible",
2944 PrettyDescriptor(interface).c_str(),
2945 PrettyDescriptor(klass.get()).c_str());
2946 return false;
2947 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002948 }
2949 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002950 // Mark the class as loaded.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002951 klass->SetStatus(Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002952 return true;
2953}
2954
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002955bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002956 CHECK(!klass->IsPrimitive());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002957 Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002958 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002959 if (super != NULL) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002960 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002961 "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002962 return false;
2963 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002964 return true;
2965 }
2966 if (super == NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002967 ThrowLinkageError("No superclass defined for class %s", PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002968 return false;
2969 }
2970 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002971 if (super->IsFinal() || super->IsInterface()) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002972 Thread* self = Thread::Current();
2973 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002974 "Superclass %s of %s is %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002975 PrettyDescriptor(super).c_str(),
2976 PrettyDescriptor(klass.get()).c_str(),
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002977 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002978 return false;
2979 }
2980 if (!klass->CanAccess(super)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002981 Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
Elliott Hughese555dc02011-09-25 10:46:35 -07002982 "Superclass %s is inaccessible by %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002983 PrettyDescriptor(super).c_str(),
2984 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002985 return false;
2986 }
Elliott Hughes20cde902011-10-04 17:37:27 -07002987
2988 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
2989 if (super->IsFinalizable()) {
2990 klass->SetFinalizable();
2991 }
2992
Elliott Hughes2da50362011-10-10 16:57:08 -07002993 // Inherit reference flags (if any) from the superclass.
2994 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
2995 if (reference_flags != 0) {
2996 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
2997 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07002998 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07002999 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003000 ThrowLinkageError("Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003001 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003002 return false;
3003 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003004
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003005#ifndef NDEBUG
3006 // Ensure super classes are fully resolved prior to resolving fields..
3007 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003008 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003009 super = super->GetSuperClass();
3010 }
3011#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003012 return true;
3013}
3014
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003015// Populate the class vtable and itable. Compute return type indices.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003016bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003017 if (klass->IsInterface()) {
3018 // No vtable.
3019 size_t count = klass->NumVirtualMethods();
3020 if (!IsUint(16, count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08003021 ThrowClassFormatError("Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003022 return false;
3023 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003024 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003025 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003026 }
jeffhaobdb76512011-09-07 11:43:16 -07003027 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003028 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003029 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003030 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003031 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003032 }
3033 return true;
3034}
3035
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003036bool ClassLinker::LinkVirtualMethods(SirtRef<Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003037 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003038 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003039 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3040 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003041 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003042 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers1f539342012-10-03 21:09:42 -07003043 SirtRef<ObjectArray<AbstractMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003044 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003045 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003046 MethodHelper local_mh(NULL, this);
3047 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003048 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003049 AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003050 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003051 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003052 for (; j < actual_count; ++j) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003053 AbstractMethod* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003054 super_mh.ChangeMethod(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003055 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3056 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3057 if (super_method->IsFinal()) {
3058 ThrowLinkageError("Method %s overrides final method in class %s",
3059 PrettyMethod(local_method).c_str(),
3060 super_mh.GetDeclaringClassDescriptor());
3061 return false;
3062 }
3063 vtable->Set(j, local_method);
3064 local_method->SetMethodIndex(j);
3065 break;
3066 } else {
3067 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3068 << " would have incorrectly overridden the package-private method in "
3069 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003070 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003071 }
3072 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003073 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003074 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003075 vtable->Set(actual_count, local_method);
3076 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003077 actual_count += 1;
3078 }
3079 }
3080 if (!IsUint(16, actual_count)) {
Elliott Hughes92cb4982011-12-16 16:57:28 -08003081 ThrowClassFormatError("Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003082 return false;
3083 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003084 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003085 CHECK_LE(actual_count, max_count);
3086 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003087 vtable.reset(vtable->CopyOf(self, actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003088 }
Ian Rogers30fab402012-01-23 15:43:46 -08003089 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003090 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003091 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003092 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003093 if (!IsUint(16, num_virtual_methods)) {
Elliott Hughese555dc02011-09-25 10:46:35 -07003094 ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003095 return false;
3096 }
Ian Rogers1f539342012-10-03 21:09:42 -07003097 SirtRef<ObjectArray<AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07003098 vtable(self, AllocMethodArray(self, num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003099 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003100 AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003101 vtable->Set(i, virtual_method);
3102 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003103 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003104 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003105 }
3106 return true;
3107}
3108
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003109bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003110 size_t super_ifcount;
3111 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003112 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003113 } else {
3114 super_ifcount = 0;
3115 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003116 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003117 ClassHelper kh(klass.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -07003118 uint32_t num_interfaces = interfaces == NULL ? kh.NumDirectInterfaces() : interfaces->GetLength();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003119 ifcount += num_interfaces;
3120 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogersd24e2642012-06-06 21:21:43 -07003121 Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003122 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003123 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003124 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003125 // Class implements no interfaces.
3126 DCHECK_EQ(klass->GetIfTableCount(), 0);
3127 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003128 return true;
3129 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003130 if (ifcount == super_ifcount) {
3131 // Class implements same interfaces as parent, are any of these not marker interfaces?
3132 bool has_non_marker_interface = false;
3133 IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
3134 for (size_t i = 0; i < ifcount; ++i) {
3135 if (super_iftable->GetMethodArrayCount(i) > 0) {
3136 has_non_marker_interface = true;
3137 break;
3138 }
3139 }
3140 if (!has_non_marker_interface) {
3141 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3142 klass->SetIfTable(super_iftable);
3143 return true;
3144 }
3145 }
Ian Rogers1f539342012-10-03 21:09:42 -07003146 Thread* self = Thread::Current();
Ian Rogers9bc81912012-10-11 21:43:36 -07003147 SirtRef<IfTable> iftable(self, AllocIfTable(self, ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003148 if (super_ifcount != 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003149 IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003150 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003151 Class* super_interface = super_iftable->GetInterface(i);
3152 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003153 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003154 }
3155 // Flatten the interface inheritance hierarchy.
3156 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003157 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogersd24e2642012-06-06 21:21:43 -07003158 Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003159 DCHECK(interface != NULL);
3160 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003161 ClassHelper ih(interface);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08003162 self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003163 "Class %s implements non-interface class %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003164 PrettyDescriptor(klass.get()).c_str(),
3165 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003166 return false;
3167 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003168 // Check if interface is already in iftable
3169 bool duplicate = false;
3170 for (size_t j = 0; j < idx; j++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003171 Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003172 if (existing_interface == interface) {
3173 duplicate = true;
3174 break;
3175 }
3176 }
3177 if (!duplicate) {
3178 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003179 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003180 // Add this interface's non-duplicate super-interfaces.
3181 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003182 Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003183 bool super_duplicate = false;
3184 for (size_t k = 0; k < idx; k++) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003185 Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003186 if (existing_interface == super_interface) {
3187 super_duplicate = true;
3188 break;
3189 }
3190 }
3191 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003192 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003193 }
3194 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003195 }
3196 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003197 // Shrink iftable in case duplicates were found
3198 if (idx < ifcount) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003199 iftable.reset(down_cast<IfTable*>(iftable->CopyOf(self, idx * IfTable::kMax)));
Ian Rogersb52b01a2012-01-12 17:01:38 -08003200 ifcount = idx;
3201 } else {
3202 CHECK_EQ(idx, ifcount);
3203 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003204 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003205
3206 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003207 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003208 return true;
3209 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07003210 std::vector<AbstractMethod*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003211 MethodHelper vtable_mh(NULL, this);
3212 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003213 for (size_t i = 0; i < ifcount; ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003214 Class* interface = iftable->GetInterface(i);
3215 size_t num_methods = interface->NumVirtualMethods();
3216 if (num_methods > 0) {
3217 ObjectArray<AbstractMethod>* method_array = AllocMethodArray(self, num_methods);
3218 iftable->SetMethodArray(i, method_array);
3219 ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
3220 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
3221 AbstractMethod* interface_method = interface->GetVirtualMethod(j);
3222 interface_mh.ChangeMethod(interface_method);
3223 int32_t k;
3224 // For each method listed in the interface's method list, find the
3225 // matching method in our class's method list. We want to favor the
3226 // subclass over the superclass, which just requires walking
3227 // back from the end of the vtable. (This only matters if the
3228 // superclass defines a private method and this class redefines
3229 // it -- otherwise it would use the same vtable slot. In .dex files
3230 // those don't end up in the virtual method table, so it shouldn't
3231 // matter which direction we go. We walk it backward anyway.)
3232 for (k = vtable->GetLength() - 1; k >= 0; --k) {
3233 AbstractMethod* vtable_method = vtable->Get(k);
3234 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003235 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003236 if (!vtable_method->IsPublic()) {
3237 self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
3238 "Implementation not public: %s",
3239 PrettyMethod(vtable_method).c_str());
3240 return false;
3241 }
3242 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003243 break;
3244 }
3245 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003246 if (k < 0) {
3247 SirtRef<AbstractMethod> miranda_method(self, NULL);
3248 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
3249 AbstractMethod* mir_method = miranda_list[mir];
3250 vtable_mh.ChangeMethod(mir_method);
3251 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3252 miranda_method.reset(miranda_list[mir]);
3253 break;
3254 }
3255 }
3256 if (miranda_method.get() == NULL) {
3257 // point the interface table at a phantom slot
3258 miranda_method.reset(down_cast<AbstractMethod*>(interface_method->Clone(self)));
3259 miranda_list.push_back(miranda_method.get());
3260 }
3261 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003262 }
3263 }
3264 }
3265 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003266 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003267 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003268 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07003269 klass->SetVirtualMethods((old_method_count == 0)
Ian Rogers4445a7e2012-10-05 17:19:13 -07003270 ? AllocMethodArray(self, new_method_count)
Ian Rogers50b35e22012-10-04 10:09:15 -07003271 : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003272
Ian Rogers1f539342012-10-03 21:09:42 -07003273 SirtRef<ObjectArray<AbstractMethod> > vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003274 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003275 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003276 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003277 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07003278 for (size_t i = 0; i < miranda_list.size(); ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003279 AbstractMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003280 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003281 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3282 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3283 klass->SetVirtualMethod(old_method_count + i, method);
3284 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003285 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003286 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003287 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003288 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003289
Mathieu Chartier66f19252012-09-18 08:57:04 -07003290 ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003291 for (int i = 0; i < vtable->GetLength(); ++i) {
3292 CHECK(vtable->Get(i) != NULL);
3293 }
3294
3295// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3296
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003297 return true;
3298}
3299
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003300bool ClassLinker::LinkInstanceFields(SirtRef<Class>& klass) {
3301 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003302 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003303}
3304
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003305bool ClassLinker::LinkStaticFields(SirtRef<Class>& klass) {
3306 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003307 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003308 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003309 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003310 return success;
3311}
3312
Brian Carlstromdbc05252011-09-09 01:59:59 -07003313struct LinkFieldsComparator {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003314 explicit LinkFieldsComparator(FieldHelper* fh)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003315 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003316 : fh_(fh) {}
3317 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
3318 bool operator()(const Field* field1, const Field* field2) NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003319 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003320 fh_->ChangeField(field1);
3321 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3322 fh_->ChangeField(field2);
3323 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003324 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3325 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3326 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3327 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003328 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3329 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3330 if (order1 != order2) {
3331 return order1 < order2;
3332 }
3333
3334 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003335 fh_->ChangeField(field1);
3336 StringPiece name1(fh_->GetName());
3337 fh_->ChangeField(field2);
3338 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003339 return name1 < name2;
3340 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003341
3342 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003343};
3344
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003345bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003346 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003347 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003348
3349 ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003350 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003351
3352 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003353 size_t size;
3354 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003355 if (is_static) {
3356 size = klass->GetClassSize();
3357 field_offset = Class::FieldsOffset();
3358 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003359 Class* super_class = klass->GetSuperClass();
3360 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003361 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003362 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003363 }
3364 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003365 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003366
Brian Carlstromdbc05252011-09-09 01:59:59 -07003367 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003368
Brian Carlstromdbc05252011-09-09 01:59:59 -07003369 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003370 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromdbc05252011-09-09 01:59:59 -07003371 std::deque<Field*> grouped_and_sorted_fields;
3372 for (size_t i = 0; i < num_fields; i++) {
3373 grouped_and_sorted_fields.push_back(fields->Get(i));
3374 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003375 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003376 std::sort(grouped_and_sorted_fields.begin(),
3377 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003378 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003379
3380 // References should be at the front.
3381 size_t current_field = 0;
3382 size_t num_reference_fields = 0;
3383 for (; current_field < num_fields; current_field++) {
3384 Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003385 fh.ChangeField(field);
3386 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003387 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003388 if (isPrimitive) {
3389 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003390 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003391 grouped_and_sorted_fields.pop_front();
3392 num_reference_fields++;
3393 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003394 field->SetOffset(field_offset);
3395 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003396 }
3397
3398 // Now we want to pack all of the double-wide fields together. If
3399 // we're not aligned, though, we want to shuffle one 32-bit field
3400 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003401 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003402 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
3403 Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003404 fh.ChangeField(field);
3405 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003406 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3407 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003408 continue;
3409 }
3410 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003411 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003412 // drop the consumed field
3413 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3414 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003415 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003416 // whether we found a 32-bit field for padding or not, we advance
3417 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003418 }
3419
3420 // Alignment is good, shuffle any double-wide fields forward, and
3421 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003422 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003423 while (!grouped_and_sorted_fields.empty()) {
3424 Field* field = grouped_and_sorted_fields.front();
3425 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003426 fh.ChangeField(field);
3427 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003428 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003429 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003430 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003431 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003432 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003433 ? sizeof(uint64_t)
3434 : sizeof(uint32_t)));
3435 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003436 }
3437
Elliott Hughesadb460d2011-10-05 17:02:34 -07003438 // 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 -07003439 if (!is_static &&
3440 StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003441 // We know there are no non-reference fields in the Reference classes, and we know
3442 // that 'referent' is alphabetically last, so this is easy...
3443 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003444 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003445 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003446 --num_reference_fields;
3447 }
3448
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003449#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003450 // Make sure that all reference fields appear before
3451 // non-reference fields, and all double-wide fields are aligned.
3452 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003453 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003454 Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003455 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003456 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003457 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003458 << " field=" << PrettyField(field)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003459 << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
3460 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003461 fh.ChangeField(field);
3462 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003463 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers64b6d142012-10-29 16:34:15 -07003464 if (StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;" &&
3465 StringPiece(fh.GetName()) == "referent") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003466 is_primitive = true; // We lied above, so we have to expect a lie here.
3467 }
3468 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003469 if (!seen_non_ref) {
3470 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003471 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003472 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003473 } else {
3474 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003475 }
3476 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003477 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003478 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003479 }
3480#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003481 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003482 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003483 if (is_static) {
3484 klass->SetNumReferenceStaticFields(num_reference_fields);
3485 klass->SetClassSize(size);
3486 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003487 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003488 if (!klass->IsVariableSize()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003489 klass->SetObjectSize(size);
3490 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003491 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003492 return true;
3493}
3494
3495// Set the bitmap of reference offsets, refOffsets, from the ifields
3496// list.
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003497void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003498 uint32_t reference_offsets = 0;
3499 Class* super_class = klass->GetSuperClass();
3500 if (super_class != NULL) {
3501 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003502 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003503 if (reference_offsets == CLASS_WALK_SUPER) {
3504 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003505 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003506 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003507 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003508 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003509}
3510
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003511void ClassLinker::CreateReferenceStaticOffsets(SirtRef<Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003512 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003513}
3514
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003515void ClassLinker::CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003516 uint32_t reference_offsets) {
3517 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003518 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3519 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003520 const ObjectArray<Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003521 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003522 // All of the fields that contain object references are guaranteed
3523 // to be at the beginning of the fields list.
3524 for (size_t i = 0; i < num_reference_fields; ++i) {
3525 // Note that byte_offset is the offset from the beginning of
3526 // object, not the offset into instance data
3527 const Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003528 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003529 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3530 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3531 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003532 CHECK_NE(new_bit, 0U);
3533 reference_offsets |= new_bit;
3534 } else {
3535 reference_offsets = CLASS_WALK_SUPER;
3536 break;
3537 }
3538 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003539 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003540 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003541 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003542 } else {
3543 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003544 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003545}
3546
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003547String* ClassLinker::ResolveString(const DexFile& dex_file,
Elliott Hughescf4c6c42011-09-01 15:16:42 -07003548 uint32_t string_idx, DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003549 DCHECK(dex_cache != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003550 String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003551 if (resolved != NULL) {
3552 return resolved;
3553 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003554 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3555 int32_t utf16_length = dex_file.GetStringLength(string_id);
3556 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom928bf022011-10-11 02:48:14 -07003557 String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003558 dex_cache->SetResolvedString(string_idx, string);
3559 return string;
3560}
3561
3562Class* ClassLinker::ResolveType(const DexFile& dex_file,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003563 uint16_t type_idx,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003564 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003565 ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003566 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003567 Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003568 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003569 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003570 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003571 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003572 // TODO: we used to throw here if resolved's class loader was not the
3573 // boot class loader. This was to permit different classes with the
3574 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003575 dex_cache->SetResolvedType(type_idx, resolved);
3576 } else {
Ian Rogerscab01012012-01-10 17:35:46 -08003577 CHECK(Thread::Current()->IsExceptionPending())
3578 << "Expected pending exception for failed resolution of: " << descriptor;
jeffhao8cd6dda2012-02-22 10:15:34 -08003579 // Convert a ClassNotFoundException to a NoClassDefFoundError
3580 if (Thread::Current()->GetException()->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
3581 Thread::Current()->ClearException();
3582 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
3583 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003584 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003585 }
3586 return resolved;
3587}
3588
Mathieu Chartier66f19252012-09-18 08:57:04 -07003589AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003590 uint32_t method_idx,
3591 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003592 ClassLoader* class_loader,
Mathieu Chartier66f19252012-09-18 08:57:04 -07003593 const AbstractMethod* referrer,
Ian Rogers08f753d2012-08-24 14:35:25 -07003594 InvokeType type) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003595 DCHECK(dex_cache != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07003596 // Check for hit in the dex cache.
Mathieu Chartier66f19252012-09-18 08:57:04 -07003597 AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003598 if (resolved != NULL) {
3599 return resolved;
3600 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003601 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003602 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
3603 Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
3604 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003605 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003606 return NULL;
3607 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003608 // Scan using method_idx, this saves string compares but will only hit for matching dex
3609 // caches/files.
3610 switch (type) {
3611 case kDirect: // Fall-through.
3612 case kStatic:
3613 resolved = klass->FindDirectMethod(dex_cache, method_idx);
3614 break;
3615 case kInterface:
3616 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
3617 break;
3618 case kSuper: // Fall-through.
3619 case kVirtual:
3620 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
3621 break;
3622 default:
3623 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003624 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003625 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07003626 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003627 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3628 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
Ian Rogers08f753d2012-08-24 14:35:25 -07003629 switch (type) {
3630 case kDirect: // Fall-through.
3631 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08003632 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003633 break;
3634 case kInterface:
3635 resolved = klass->FindInterfaceMethod(name, signature);
3636 break;
3637 case kSuper: // Fall-through.
3638 case kVirtual:
3639 resolved = klass->FindVirtualMethod(name, signature);
3640 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003641 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003642 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003643 if (resolved != NULL) {
3644 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07003645 if (resolved->CheckIncompatibleClassChange(type)) {
3646 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07003647 }
3648 }
3649 if (resolved != NULL) {
3650 // Be a good citizen and update the dex cache to speed subsequent calls.
3651 dex_cache->SetResolvedMethod(method_idx, resolved);
3652 return resolved;
3653 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07003654 // We failed to find the method which means either an access error, an incompatible class
3655 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07003656 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3657 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3658 switch (type) {
3659 case kDirect:
3660 case kStatic:
3661 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07003662 break;
3663 case kInterface:
3664 case kVirtual:
3665 case kSuper:
3666 resolved = klass->FindDirectMethod(name, signature);
3667 break;
3668 }
3669
3670 // If we found something, check that it can be accessed by the referrer.
3671 if (resolved != NULL && referrer != NULL) {
3672 Class* methods_class = resolved->GetDeclaringClass();
3673 Class* referring_class = referrer->GetDeclaringClass();
3674 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003675 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
3676 referrer, resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07003677 return NULL;
3678 } else if (!referring_class->CanAccessMember(methods_class,
3679 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003680 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07003681 return NULL;
3682 }
3683 }
3684
3685 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
3686 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
3687 switch (type) {
3688 case kDirect:
3689 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07003690 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003691 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003692 } else {
3693 resolved = klass->FindInterfaceMethod(name, signature);
3694 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003695 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003696 } else {
Ian Rogers2fc14272012-08-30 10:56:57 -07003697 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003698 }
3699 }
3700 break;
3701 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07003702 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003703 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003704 } else {
3705 resolved = klass->FindVirtualMethod(name, signature);
3706 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003707 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003708 } else {
Ian Rogers2fc14272012-08-30 10:56:57 -07003709 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003710 }
3711 }
3712 break;
3713 case kSuper:
Ian Rogers2fc14272012-08-30 10:56:57 -07003714 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003715 break;
3716 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07003717 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003718 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003719 } else {
3720 resolved = klass->FindInterfaceMethod(name, signature);
3721 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003722 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003723 } else {
Ian Rogers2fc14272012-08-30 10:56:57 -07003724 ThrowNoSuchMethodError(type, klass, name, signature, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003725 }
3726 }
3727 break;
3728 }
3729 DCHECK(Thread::Current()->IsExceptionPending());
3730 return NULL;
3731 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003732}
3733
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003734Field* ClassLinker::ResolveField(const DexFile& dex_file,
3735 uint32_t field_idx,
3736 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003737 ClassLoader* class_loader,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003738 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003739 DCHECK(dex_cache != NULL);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003740 Field* resolved = dex_cache->GetResolvedField(field_idx);
3741 if (resolved != NULL) {
3742 return resolved;
3743 }
3744 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3745 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3746 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003747 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003748 return NULL;
3749 }
3750
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003751 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003752 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003753 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003754 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003755 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003756
3757 if (resolved == NULL) {
3758 const char* name = dex_file.GetFieldName(field_id);
3759 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3760 if (is_static) {
3761 resolved = klass->FindStaticField(name, type);
3762 } else {
3763 resolved = klass->FindInstanceField(name, type);
3764 }
3765 if (resolved == NULL) {
3766 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3767 return NULL;
3768 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003769 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003770 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003771 return resolved;
3772}
3773
3774Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3775 uint32_t field_idx,
3776 DexCache* dex_cache,
Ian Rogers365c1022012-06-22 15:05:28 -07003777 ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003778 DCHECK(dex_cache != NULL);
Ian Rogersb067ac22011-12-13 18:05:09 -08003779 Field* resolved = dex_cache->GetResolvedField(field_idx);
3780 if (resolved != NULL) {
3781 return resolved;
3782 }
3783 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
3784 Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
3785 if (klass == NULL) {
3786 DCHECK(Thread::Current()->IsExceptionPending());
3787 return NULL;
3788 }
3789
3790 const char* name = dex_file.GetFieldName(field_id);
3791 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3792 resolved = klass->FindField(name, type);
3793 if (resolved != NULL) {
3794 dex_cache->SetResolvedField(field_idx, resolved);
3795 } else {
3796 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003797 }
3798 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003799}
3800
Mathieu Chartier66f19252012-09-18 08:57:04 -07003801const char* ClassLinker::MethodShorty(uint32_t method_idx, AbstractMethod* referrer, uint32_t* length) {
Ian Rogersad25ac52011-10-04 19:13:33 -07003802 Class* declaring_class = referrer->GetDeclaringClass();
3803 DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07003804 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07003805 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003806 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003807}
3808
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003809void ClassLinker::DumpAllClasses(int flags) const {
3810 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3811 // lock held, because it might need to resolve a field's type, which would try to take the lock.
3812 std::vector<Class*> all_classes;
3813 {
Ian Rogers50b35e22012-10-04 10:09:15 -07003814 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003815 typedef Table::const_iterator It; // TODO: C++0x auto
3816 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3817 all_classes.push_back(it->second);
3818 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003819 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3820 all_classes.push_back(it->second);
3821 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003822 }
3823
3824 for (size_t i = 0; i < all_classes.size(); ++i) {
3825 all_classes[i]->DumpClass(std::cerr, flags);
3826 }
3827}
3828
Elliott Hughescac6cc72011-11-03 20:31:21 -07003829void ClassLinker::DumpForSigQuit(std::ostream& os) const {
Ian Rogers50b35e22012-10-04 10:09:15 -07003830 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -07003831 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3832 << classes_.size() << " allocated classes\n";
3833}
3834
Elliott Hughese27955c2011-08-26 15:21:24 -07003835size_t ClassLinker::NumLoadedClasses() const {
Ian Rogers50b35e22012-10-04 10:09:15 -07003836 MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003837 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003838}
3839
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003840pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07003841 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003842}
3843
3844pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003845 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003846}
3847
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003848void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
3849 DCHECK(!init_done_);
3850
3851 DCHECK(klass != NULL);
3852 DCHECK(klass->GetClassLoader() == NULL);
3853
3854 DCHECK(class_roots_ != NULL);
3855 DCHECK(class_roots_->Get(class_root) == NULL);
3856 class_roots_->Set(class_root, klass);
3857}
3858
Logan Chien0c717dd2012-03-28 18:31:07 +08003859void ClassLinker::RelocateExecutable() {
Ian Rogers50b35e22012-10-04 10:09:15 -07003860 MutexLock mu(Thread::Current(), dex_lock_);
Logan Chien0c717dd2012-03-28 18:31:07 +08003861 for (size_t i = 0; i < oat_files_.size(); ++i) {
3862 const_cast<OatFile*>(oat_files_[i])->RelocateExecutable();
3863 }
3864}
3865
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003866} // namespace art