blob: c7a8f7e3d4b75f6d2dddd6313b7c57c674a87a10 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "class_linker.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070018
Brian Carlstromd601af82012-01-06 10:15:19 -080019#include <fcntl.h>
20#include <sys/file.h>
21#include <sys/stat.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080022#include <sys/types.h>
23#include <sys/wait.h>
24
Brian Carlstromdbc05252011-09-09 01:59:59 -070025#include <deque>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070026#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070027#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070028#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070029
Elliott Hughes1aa246d2012-12-13 09:29:36 -080030#include "base/casts.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080031#include "base/logging.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080032#include "base/stl_util.h"
Elliott Hughes76160052012-12-12 16:31:20 -080033#include "base/unix_file/fd_file.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034#include "class_linker-inl.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080035#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070036#include "dex_file-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070037#include "gc/accounting/card_table-inl.h"
38#include "gc/accounting/heap_bitmap.h"
39#include "gc/heap.h"
40#include "gc/space/image_space.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070041#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070042#include "interpreter/interpreter.h"
Ian Rogers0571d352011-11-03 19:51:38 -070043#include "leb128.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080044#include "oat.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070045#include "oat_file.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080046#include "mirror/class.h"
47#include "mirror/class-inl.h"
48#include "mirror/class_loader.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070049#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080050#include "mirror/field-inl.h"
51#include "mirror/iftable-inl.h"
52#include "mirror/abstract_method.h"
53#include "mirror/abstract_method-inl.h"
54#include "mirror/object-inl.h"
55#include "mirror/object_array-inl.h"
56#include "mirror/proxy.h"
57#include "mirror/stack_trace_element.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080058#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080059#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070060#include "runtime.h"
Ian Rogers7655f292013-07-29 11:07:13 -070061#include "entrypoints/entrypoint_utils.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -070062#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070063#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070064#include "sirt_ref.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070065#include "stack_indirect_reference_table.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070066#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070067#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070068#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080069#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070070#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070071
72namespace art {
73
Dragos Sbirlea08bf1962013-08-12 08:53:04 -070074extern "C" void artInterpreterToCompiledCodeBridge(Thread* self, MethodHelper& mh,
Jeff Hao0aba0ba2013-06-03 14:49:28 -070075 const DexFile::CodeItem* code_item,
76 ShadowFrame* shadow_frame, JValue* result);
Jeff Hao16743632013-05-08 10:59:04 -070077
Ian Rogers00f7d0e2012-07-19 15:28:27 -070078static void ThrowNoClassDefFoundError(const char* fmt, ...)
79 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070080 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070081static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070082 va_list args;
83 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -080084 Thread* self = Thread::Current();
85 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
86 self->ThrowNewExceptionV(throw_location, "Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -080087 va_end(args);
88}
89
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080090static void ThrowEarlierClassFailure(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -070091 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -070092 // The class failed to initialize on a previous attempt, so we want to throw
93 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
94 // failed in verification, in which case v2 5.4.1 says we need to re-throw
95 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -070096 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
97 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
98 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -070099
Elliott Hughes5c599942012-06-13 16:45:05 -0700100 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -0800101 Thread* self = Thread::Current();
102 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700103 if (c->GetVerifyErrorClass() != NULL) {
104 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800105 ClassHelper ve_ch(c->GetVerifyErrorClass());
Ian Rogers62d6c772013-02-27 08:32:07 -0800106 self->ThrowNewException(throw_location, ve_ch.GetDescriptor(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700107 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -0800108 self->ThrowNewException(throw_location, "Ljava/lang/NoClassDefFoundError;",
109 PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700110 }
111}
112
Ian Rogers62d6c772013-02-27 08:32:07 -0800113static void WrapExceptionInInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700114 Thread* self = Thread::Current();
115 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700116
117 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
118 CHECK(cause.get() != NULL);
119
120 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700121 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
122 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700123
Elliott Hughesa4f94742012-05-29 16:28:38 -0700124 // We only wrap non-Error exceptions; an Error can just be used as-is.
125 if (!is_error) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800126 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
127 self->ThrowNewWrappedException(throw_location, "Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700128 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700129}
130
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800131static size_t Hash(const char* s) {
132 // This is the java.lang.String hashcode for convenience, not interoperability.
133 size_t hash = 0;
134 for (; *s != '\0'; ++s) {
135 hash = hash * 31 + *s;
136 }
137 return hash;
138}
139
Elliott Hughes418d20f2011-09-22 14:00:39 -0700140const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700141 "Ljava/lang/Class;",
142 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700143 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700144 "[Ljava/lang/Object;",
145 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700146 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700147 "Ljava/lang/ref/Reference;",
Elliott Hughes80609252011-09-23 17:24:51 -0700148 "Ljava/lang/reflect/Constructor;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700149 "Ljava/lang/reflect/Field;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700150 "Ljava/lang/reflect/AbstractMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700151 "Ljava/lang/reflect/Method;",
Ian Rogers466bb252011-10-14 03:29:56 -0700152 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700153 "[Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700154 "[Ljava/lang/reflect/AbstractMethod;",
Ian Rogers4445a7e2012-10-05 17:19:13 -0700155 "[Ljava/lang/reflect/Field;",
156 "[Ljava/lang/reflect/Method;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700157 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800158 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800159 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700160 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700161 "Z",
162 "B",
163 "C",
164 "D",
165 "F",
166 "I",
167 "J",
168 "S",
169 "V",
170 "[Z",
171 "[B",
172 "[C",
173 "[D",
174 "[F",
175 "[I",
176 "[J",
177 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700178 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700179};
180
Brian Carlstroma004aa92012-02-08 18:05:09 -0800181ClassLinker* ClassLinker::CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
182 InternTable* intern_table) {
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700183 CHECK_NE(boot_class_path.size(), 0U);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800184 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstroma004aa92012-02-08 18:05:09 -0800185 class_linker->InitFromCompiler(boot_class_path);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700186 return class_linker.release();
187}
188
Brian Carlstroma004aa92012-02-08 18:05:09 -0800189ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800190 UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700191 class_linker->InitFromImage();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700192 return class_linker.release();
193}
194
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800195ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700196 // dex_lock_ is recursive as it may be used in stack dumping.
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700197 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700198 class_roots_(NULL),
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700199 array_iftable_(NULL),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700200 init_done_(false),
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700201 is_dirty_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700202 intern_table_(intern_table),
203 portable_resolution_trampoline_(NULL),
204 quick_resolution_trampoline_(NULL) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700205 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700206}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700207
Brian Carlstroma004aa92012-02-08 18:05:09 -0800208void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
209 VLOG(startup) << "ClassLinker::Init";
210 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700211
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700212 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700213
Elliott Hughes30646832011-10-13 16:59:46 -0700214 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700215 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700216 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800217 SirtRef<mirror::Class>
218 java_lang_Class(self,
219 down_cast<mirror::Class*>(heap->AllocObject(self, NULL,
220 sizeof(mirror::ClassClass))));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700221 CHECK(java_lang_Class.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800222 mirror::Class::SetClassClass(java_lang_Class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700223 java_lang_Class->SetClass(java_lang_Class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800224 java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
225 // AllocClass(mirror::Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700226
Elliott Hughes418d20f2011-09-22 14:00:39 -0700227 // Class[] is used for reflection support.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800228 SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700229 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700230
Ian Rogers23435d02012-09-24 11:23:12 -0700231 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800232 SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700233 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700234 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700235 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800236 java_lang_Object->SetStatus(mirror::Class::kStatusLoaded);
Brian Carlstroma0808032011-07-18 00:39:23 -0700237
Ian Rogers23435d02012-09-24 11:23:12 -0700238 // Object[] next to hold class roots.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800239 SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700240 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700241
Ian Rogers23435d02012-09-24 11:23:12 -0700242 // Setup the char class to be used for char[].
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800243 SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700244
Ian Rogers23435d02012-09-24 11:23:12 -0700245 // Setup the char[] class to be used for String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800246 SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700247 char_array_class->SetComponentType(char_class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800248 mirror::CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700249
Ian Rogers23435d02012-09-24 11:23:12 -0700250 // Setup String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800251 SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
252 mirror::String::SetClass(java_lang_String.get());
253 java_lang_String->SetObjectSize(sizeof(mirror::String));
254 java_lang_String->SetStatus(mirror::Class::kStatusResolved);
Jesse Wilson14150742011-07-29 19:04:44 -0400255
Ian Rogers23435d02012-09-24 11:23:12 -0700256 // Create storage for root classes, save away our work so far (requires descriptors).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800257 class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700258 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700259 SetClassRoot(kJavaLangClass, java_lang_Class.get());
260 SetClassRoot(kJavaLangObject, java_lang_Object.get());
261 SetClassRoot(kClassArrayClass, class_array_class.get());
262 SetClassRoot(kObjectArrayClass, object_array_class.get());
263 SetClassRoot(kCharArrayClass, char_array_class.get());
264 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700265
266 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700267 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
268 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
269 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
270 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
271 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
272 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
273 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
274 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700275
Ian Rogers23435d02012-09-24 11:23:12 -0700276 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700277 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700278
Ian Rogers23435d02012-09-24 11:23:12 -0700279 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800280 SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700281 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800282 mirror::IntArray::SetArrayClass(int_array_class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700283 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700284
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700285 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700286
Ian Rogers52813c92012-10-11 11:50:38 -0700287 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800288 SirtRef<mirror::Class>
289 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700290 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800291 java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCacheClass));
292 java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700293
Mathieu Chartier66f19252012-09-18 08:57:04 -0700294 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800295 SirtRef<mirror::Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
296 sizeof(mirror::FieldClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700297 CHECK(java_lang_reflect_Field.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800298 java_lang_reflect_Field->SetObjectSize(sizeof(mirror::Field));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700299 SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800300 java_lang_reflect_Field->SetStatus(mirror::Class::kStatusResolved);
301 mirror::Field::SetClass(java_lang_reflect_Field.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700302
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800303 SirtRef<mirror::Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
304 sizeof(mirror::AbstractMethodClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700305 CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800306 java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(mirror::AbstractMethod));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700307 SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800308 java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700309
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800310 SirtRef<mirror::Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
311 sizeof(mirror::AbstractMethodClass)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700312 CHECK(java_lang_reflect_Constructor.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800313 java_lang_reflect_Constructor->SetObjectSize(sizeof(mirror::Constructor));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700314 java_lang_reflect_Constructor->SetSuperClass(java_lang_reflect_AbstractMethod.get());
315 SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800316 java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700317
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800318 SirtRef<mirror::Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
319 sizeof(mirror::AbstractMethodClass)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700320 CHECK(java_lang_reflect_Method.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800321 java_lang_reflect_Method->SetObjectSize(sizeof(mirror::Method));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700322 java_lang_reflect_Method->SetSuperClass(java_lang_reflect_AbstractMethod.get());
323 SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800324 java_lang_reflect_Method->SetStatus(mirror::Class::kStatusResolved);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700325
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800326 mirror::AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(),
327 java_lang_reflect_Method.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700328
329 // Set up array classes for string, field, method
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800330 SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700331 object_array_string->SetComponentType(java_lang_String.get());
332 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
333
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800334 SirtRef<mirror::Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700335 object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
336 SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
337
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800338 SirtRef<mirror::Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700339 object_array_field->SetComponentType(java_lang_reflect_Field.get());
340 SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
341
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800342 SirtRef<mirror::Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700343 object_array_method->SetComponentType(java_lang_reflect_Method.get());
344 SetClassRoot(kJavaLangReflectMethodArrayClass, object_array_method.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700345
Ian Rogers23435d02012-09-24 11:23:12 -0700346 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
347 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
348 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700349 CHECK_NE(0U, boot_class_path.size());
350 for (size_t i = 0; i != boot_class_path.size(); ++i) {
351 const DexFile* dex_file = boot_class_path[i];
352 CHECK(dex_file != NULL);
353 AppendToBootClassPath(*dex_file);
354 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700355
356 // now we can use FindSystemClass
357
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700358 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700359 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700360 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700361
Mathieu Chartier66f19252012-09-18 08:57:04 -0700362 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800363 java_lang_Object->SetStatus(mirror::Class::kStatusNotReady);
364 mirror::Class* Object_class = FindSystemClass("Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700365 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800366 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
367 java_lang_String->SetStatus(mirror::Class::kStatusNotReady);
368 mirror::Class* String_class = FindSystemClass("Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700369 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800370 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
371 java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady);
372 mirror::Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700373 CHECK_EQ(java_lang_String.get(), String_class);
374 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800375 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700376
Ian Rogers23435d02012-09-24 11:23:12 -0700377 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700378 SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800379 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700380
381 SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800382 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700383
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800384 mirror::Class* found_char_array_class = FindSystemClass("[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700385 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700386
387 SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800388 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700389
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800390 mirror::Class* found_int_array_class = FindSystemClass("[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700391 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700392
393 SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800394 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700395
396 SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800397 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700398
399 SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800400 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700401
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800402 mirror::Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700403 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700404
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800405 mirror::Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700406 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700407
Ian Rogers23435d02012-09-24 11:23:12 -0700408 // Setup the single, global copy of "iftable".
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800409 mirror::Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700410 CHECK(java_lang_Cloneable != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800411 mirror::Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700412 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700413 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
414 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700415 array_iftable_->SetInterface(0, java_lang_Cloneable);
416 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700417
Ian Rogers23435d02012-09-24 11:23:12 -0700418 // Sanity check Class[] and Object[]'s interfaces.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800419 ClassHelper kh(class_array_class.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -0700420 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
421 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800422 kh.ChangeClass(object_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700423 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
424 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers23435d02012-09-24 11:23:12 -0700425 // Run Class, Constructor, Field, and Method through FindSystemClass. This initializes their
426 // dex_cache_ fields and register them in classes_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800427 mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700428 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700429
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800430 java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusNotReady);
431 mirror::Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700432 CHECK_EQ(java_lang_reflect_AbstractMethod.get(), Abstract_method_class);
433
434 // Method extends AbstractMethod so must reset after.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800435 java_lang_reflect_Method->SetStatus(mirror::Class::kStatusNotReady);
436 mirror::Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700437 CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
438
439 // Constructor extends AbstractMethod so must reset after.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800440 java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusNotReady);
441 mirror::Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700442 CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
Elliott Hughes80609252011-09-23 17:24:51 -0700443
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800444 java_lang_reflect_Field->SetStatus(mirror::Class::kStatusNotReady);
445 mirror::Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700446 CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700447
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800448 mirror::Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700449 CHECK_EQ(object_array_string.get(), String_array_class);
450
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800451 mirror::Class* Abstract_method_array_class =
Mathieu Chartier66f19252012-09-18 08:57:04 -0700452 FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
453 CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700454
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800455 mirror::Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700456 CHECK_EQ(object_array_field.get(), Field_array_class);
457
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800458 mirror::Class* Method_array_class =
Ian Rogers4445a7e2012-10-05 17:19:13 -0700459 FindSystemClass(class_roots_descriptors_[kJavaLangReflectMethodArrayClass]);
460 CHECK_EQ(object_array_method.get(), Method_array_class);
461
Ian Rogers23435d02012-09-24 11:23:12 -0700462 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700463
Ian Rogers23435d02012-09-24 11:23:12 -0700464 // Create java.lang.reflect.Proxy root.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800465 mirror::Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
Ian Rogers466bb252011-10-14 03:29:56 -0700466 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
467
Brian Carlstrom1f870082011-08-23 16:02:11 -0700468 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800469 mirror::Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700470 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800471 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700472 java_lang_ref_FinalizerReference->SetAccessFlags(
473 java_lang_ref_FinalizerReference->GetAccessFlags() |
474 kAccClassIsReference | kAccClassIsFinalizerReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800475 mirror::Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700476 java_lang_ref_PhantomReference->SetAccessFlags(
477 java_lang_ref_PhantomReference->GetAccessFlags() |
478 kAccClassIsReference | kAccClassIsPhantomReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800479 mirror::Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700480 java_lang_ref_SoftReference->SetAccessFlags(
481 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800482 mirror::Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700483 java_lang_ref_WeakReference->SetAccessFlags(
484 java_lang_ref_WeakReference->GetAccessFlags() |
485 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700486
Ian Rogers23435d02012-09-24 11:23:12 -0700487 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800488 mirror::Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
489 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700490 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
491
jeffhao8cd6dda2012-02-22 10:15:34 -0800492 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700493 // java.lang.StackTraceElement as a convenience.
Ian Rogers5167c972012-02-03 10:41:20 -0800494 SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800495 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
jeffhao8cd6dda2012-02-22 10:15:34 -0800496 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700497 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
498 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800499 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700500
Brian Carlstroma663ea52011-08-19 23:33:41 -0700501 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700502
Brian Carlstroma004aa92012-02-08 18:05:09 -0800503 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700504}
505
506void ClassLinker::FinishInit() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800507 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700508
509 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700510 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700511 // as the types of the field can't be resolved prior to the runtime being
512 // fully initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800513 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
514 mirror::Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
515 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700516
Ian Rogers4445a7e2012-10-05 17:19:13 -0700517 const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800518
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800519 mirror::Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800520 FieldHelper fh(pendingNext, this);
521 CHECK_STREQ(fh.GetName(), "pendingNext");
522 CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
523 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700524
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800525 mirror::Field* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800526 fh.ChangeField(queue);
527 CHECK_STREQ(fh.GetName(), "queue");
528 CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
529 java_lang_ref_ReferenceQueue->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700530
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800531 mirror::Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800532 fh.ChangeField(queueNext);
533 CHECK_STREQ(fh.GetName(), "queueNext");
534 CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
535 java_lang_ref_Reference->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700536
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800537 mirror::Field* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800538 fh.ChangeField(referent);
539 CHECK_STREQ(fh.GetName(), "referent");
540 CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
541 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700542
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800543 mirror::Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800544 fh.ChangeField(zombie);
545 CHECK_STREQ(fh.GetName(), "zombie");
546 CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
547 GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
Brian Carlstrom16192862011-09-12 17:50:06 -0700548
Ian Rogers1d54e732013-05-02 21:10:01 -0700549 gc::Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800550 heap->SetReferenceOffsets(referent->GetOffset(),
Brian Carlstrom16192862011-09-12 17:50:06 -0700551 queue->GetOffset(),
552 queueNext->GetOffset(),
553 pendingNext->GetOffset(),
554 zombie->GetOffset());
555
Brian Carlstroma663ea52011-08-19 23:33:41 -0700556 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700557 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700558 ClassRoot class_root = static_cast<ClassRoot>(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800559 mirror::Class* klass = GetClassRoot(class_root);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700560 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700561 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700562 // note SetClassRoot does additional validation.
563 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700564 }
565
Elliott Hughes92f14b22011-10-06 12:29:54 -0700566 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700567
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700568 // disable the slow paths in FindClass and CreatePrimitiveClass now
569 // that Object, Class, and Object[] are setup
570 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700571
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800572 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700573}
574
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700575void ClassLinker::RunRootClinits() {
576 Thread* self = Thread::Current();
577 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800578 mirror::Class* c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700579 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Ian Rogers0045a292012-03-31 21:08:41 -0700580 EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700581 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700582 }
583 }
584}
585
Brian Carlstromd601af82012-01-06 10:15:19 -0800586bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
587 int oat_fd,
588 const std::string& oat_cache_filename) {
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800589 std::string dex2oat_string(GetAndroidRoot());
Elliott Hughes67d92002012-03-26 15:08:51 -0700590 dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800591 const char* dex2oat = dex2oat_string.c_str();
592
Brian Carlstroma004aa92012-02-08 18:05:09 -0800593 const char* class_path = Runtime::Current()->GetClassPathString().c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800594
Ian Rogers1d54e732013-05-02 21:10:01 -0700595 gc::Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800596 std::string boot_image_option_string("--boot-image=");
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700597 boot_image_option_string += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800598 const char* boot_image_option = boot_image_option_string.c_str();
599
600 std::string dex_file_option_string("--dex-file=");
Brian Carlstromd601af82012-01-06 10:15:19 -0800601 dex_file_option_string += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800602 const char* dex_file_option = dex_file_option_string.c_str();
603
Brian Carlstromd601af82012-01-06 10:15:19 -0800604 std::string oat_fd_option_string("--oat-fd=");
Brian Carlstrom866c8622012-01-06 16:35:13 -0800605 StringAppendF(&oat_fd_option_string, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800606 const char* oat_fd_option = oat_fd_option_string.c_str();
607
Brian Carlstroma004aa92012-02-08 18:05:09 -0800608 std::string oat_location_option_string("--oat-location=");
609 oat_location_option_string += oat_cache_filename;
610 const char* oat_location_option = oat_location_option_string.c_str();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800611
buzbeea024a062013-07-31 10:47:37 -0700612 std::string oat_compiler_filter_string("-compiler-filter:");
613 switch (Runtime::Current()->GetCompilerFilter()) {
614 case Runtime::kInterpretOnly:
615 oat_compiler_filter_string += "interpret-only";
616 break;
617 case Runtime::kDeferCompilation:
618 oat_compiler_filter_string += "defer-compilation";
619 break;
620 case Runtime::kSpace:
621 oat_compiler_filter_string += "space";
622 break;
623 case Runtime::kBalanced:
624 oat_compiler_filter_string += "balanced";
625 break;
626 case Runtime::kSpeed:
627 oat_compiler_filter_string += "speed";
628 break;
629 default:
630 LOG(FATAL) << "Unexpected case.";
631 }
632 const char* oat_compiler_filter_option = oat_compiler_filter_string.c_str();
633
jeffhao262bf462011-10-20 18:36:32 -0700634 // fork and exec dex2oat
635 pid_t pid = fork();
636 if (pid == 0) {
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800637 // no allocation allowed between fork and exec
Ian Rogers725aee52012-01-11 11:56:56 -0800638
639 // change process groups, so we don't get reaped by ProcessManager
640 setpgid(0, 0);
641
jeffhao10037c82012-01-23 15:06:23 -0800642 VLOG(class_linker) << dex2oat
643 << " --runtime-arg -Xms64m"
644 << " --runtime-arg -Xmx64m"
645 << " --runtime-arg -classpath"
646 << " --runtime-arg " << class_path
buzbeea024a062013-07-31 10:47:37 -0700647 << " --runtime-arg " << oat_compiler_filter_option
Brian Carlstrom265091e2013-01-30 14:08:26 -0800648#if !defined(ART_TARGET)
649 << " --host"
650#endif
jeffhao10037c82012-01-23 15:06:23 -0800651 << " " << boot_image_option
652 << " " << dex_file_option
653 << " " << oat_fd_option
Brian Carlstroma004aa92012-02-08 18:05:09 -0800654 << " " << oat_location_option;
jeffhao10037c82012-01-23 15:06:23 -0800655
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800656 execl(dex2oat, dex2oat,
jeffhao5d840402011-10-24 17:09:45 -0700657 "--runtime-arg", "-Xms64m",
658 "--runtime-arg", "-Xmx64m",
Jesse Wilson254db0f2011-11-16 16:44:11 -0500659 "--runtime-arg", "-classpath",
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800660 "--runtime-arg", class_path,
buzbeea024a062013-07-31 10:47:37 -0700661 "--runtime-arg", oat_compiler_filter_option,
Brian Carlstrom265091e2013-01-30 14:08:26 -0800662#if !defined(ART_TARGET)
663 "--host",
664#endif
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800665 boot_image_option,
666 dex_file_option,
Brian Carlstromd601af82012-01-06 10:15:19 -0800667 oat_fd_option,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800668 oat_location_option,
jeffhao262bf462011-10-20 18:36:32 -0700669 NULL);
670
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800671 PLOG(FATAL) << "execl(" << dex2oat << ") failed";
Brian Carlstromd601af82012-01-06 10:15:19 -0800672 return false;
jeffhao262bf462011-10-20 18:36:32 -0700673 } else {
674 // wait for dex2oat to finish
675 int status;
676 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
677 if (got_pid != pid) {
678 PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
Brian Carlstromd601af82012-01-06 10:15:19 -0800679 return false;
jeffhao262bf462011-10-20 18:36:32 -0700680 }
681 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
Brian Carlstromd601af82012-01-06 10:15:19 -0800682 LOG(ERROR) << dex2oat << " failed with dex-file=" << dex_filename;
683 return false;
jeffhao262bf462011-10-20 18:36:32 -0700684 }
685 }
Brian Carlstromd601af82012-01-06 10:15:19 -0800686 return true;
jeffhao262bf462011-10-20 18:36:32 -0700687}
688
Brian Carlstrom866c8622012-01-06 16:35:13 -0800689void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700690 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800691 RegisterOatFileLocked(oat_file);
692}
693
694void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700695 dex_lock_.AssertExclusiveHeld(Thread::Current());
696 if (kIsDebugBuild) {
697 for (size_t i = 0; i < oat_files_.size(); ++i) {
698 CHECK_NE(&oat_file, oat_files_[i]) << oat_file.GetLocation();
699 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800700 }
Brian Carlstrom866c8622012-01-06 16:35:13 -0800701 oat_files_.push_back(&oat_file);
702}
703
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700704OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
705 VLOG(startup) << "ClassLinker::GetImageOatFile entering";
706 OatFile& oat_file = space->ReleaseOatFile();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700707 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700708 RegisterOatFileLocked(oat_file);
709 VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700710 return oat_file;
711}
712
Brian Carlstromae826982011-11-09 01:33:42 -0800713const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700714 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800715 return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800716}
717
Brian Carlstroma004aa92012-02-08 18:05:09 -0800718const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
Brian Carlstromae826982011-11-09 01:33:42 -0800719 for (size_t i = 0; i < oat_files_.size(); i++) {
720 const OatFile* oat_file = oat_files_[i];
721 DCHECK(oat_file != NULL);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800722 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800723 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800724 return oat_file;
725 }
726 }
727 return NULL;
728}
729
Ian Rogerse3359f72013-06-11 15:14:11 -0700730const DexFile* ClassLinker::FindDexFileInOatLocation(const std::string& dex_location,
731 uint32_t dex_location_checksum,
732 const std::string& oat_location) {
Brian Carlstromf1d34552013-07-12 20:22:23 -0700733 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
734 !Runtime::Current()->IsCompiler()));
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800735 if (oat_file.get() == NULL) {
736 return NULL;
737 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700738 Runtime* runtime = Runtime::Current();
739 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700740 if (oat_file->GetOatHeader().GetImageFileLocationOatChecksum() != image_header.GetOatChecksum()) {
741 return NULL;
742 }
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800743 if (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
744 != reinterpret_cast<uint32_t>(image_header.GetOatDataBegin())) {
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700745 return NULL;
746 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800747 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
748 if (oat_dex_file == NULL) {
749 return NULL;
750 }
751 if (oat_dex_file->GetDexFileLocationChecksum() != dex_location_checksum) {
752 return NULL;
753 }
Ian Rogerse3359f72013-06-11 15:14:11 -0700754 RegisterOatFileLocked(*oat_file.release());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800755 return oat_dex_file->OpenDexFile();
756}
757
758const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
759 const std::string& oat_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700760 WriterMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700761 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_location);
762}
763
764const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
765 const std::string& oat_location) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800766 uint32_t dex_location_checksum;
767 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
768 LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
769 return NULL;
770 }
771
772 // Check if we already have an up-to-date output file
773 const DexFile* dex_file = FindDexFileInOatLocation(dex_location,
774 dex_location_checksum,
775 oat_location);
776 if (dex_file != NULL) {
777 return dex_file;
778 }
779
780 // Generate the output oat file for the dex file
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800781 UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
782 if (file.get() == NULL) {
783 LOG(ERROR) << "Failed to create oat file: " << oat_location;
784 return NULL;
785 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700786 if (!GenerateOatFile(dex_location, file->Fd(), oat_location)) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800787 LOG(ERROR) << "Failed to generate oat file: " << oat_location;
788 return NULL;
789 }
Brian Carlstromf1d34552013-07-12 20:22:23 -0700790 const OatFile* oat_file = OatFile::Open(oat_location, oat_location, NULL,
791 !Runtime::Current()->IsCompiler());
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800792 if (oat_file == NULL) {
793 LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
794 return NULL;
795 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700796 RegisterOatFileLocked(*oat_file);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800797 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
798 if (oat_dex_file == NULL) {
799 LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
800 return NULL;
801 }
802 return oat_dex_file->OpenDexFile();
803}
804
Brian Carlstromafe25512012-06-27 17:02:58 -0700805bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
806 const std::string& dex_location,
807 uint32_t dex_location_checksum) {
808 Runtime* runtime = Runtime::Current();
809 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700810 uint32_t image_oat_checksum = image_header.GetOatChecksum();
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800811 uint32_t image_oat_data_begin = reinterpret_cast<uint32_t>(image_header.GetOatDataBegin());
Brian Carlstrom28db0122012-10-18 16:20:41 -0700812 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800813 && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700814
Brian Carlstromafe25512012-06-27 17:02:58 -0700815 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
816 if (oat_dex_file == NULL) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700817 LOG(ERROR) << "oat file " << oat_file->GetLocation()
Brian Carlstromafe25512012-06-27 17:02:58 -0700818 << " does not contain contents for " << dex_location;
819 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
820 for (size_t i = 0; i < oat_dex_files.size(); i++) {
821 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700822 LOG(ERROR) << "oat file " << oat_file->GetLocation()
Brian Carlstromafe25512012-06-27 17:02:58 -0700823 << " contains contents for " << oat_dex_file->GetDexFileLocation();
824 }
825 return false;
826 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700827 bool dex_check = dex_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700828
Brian Carlstromafe25512012-06-27 17:02:58 -0700829 if (image_check && dex_check) {
830 return true;
831 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700832
Brian Carlstromafe25512012-06-27 17:02:58 -0700833 if (!image_check) {
834 std::string image_file(image_header.GetImageRoot(
835 ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8());
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700836 LOG(WARNING) << "oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700837 << " mismatch ( " << std::hex << oat_file->GetOatHeader().GetImageFileLocationOatChecksum()
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800838 << ", " << oat_file->GetOatHeader().GetImageFileLocationOatDataBegin()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700839 << ") with " << image_file
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800840 << " (" << image_oat_checksum << ", " << std::hex << image_oat_data_begin << ")";
Brian Carlstromafe25512012-06-27 17:02:58 -0700841 }
842 if (!dex_check) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700843 LOG(WARNING) << "oat file " << oat_file->GetLocation()
Brian Carlstrom28db0122012-10-18 16:20:41 -0700844 << " mismatch ( " << std::hex << oat_dex_file->GetDexFileLocationChecksum()
845 << ") with " << dex_location
Brian Carlstromafe25512012-06-27 17:02:58 -0700846 << " (" << std::hex << dex_location_checksum << ")";
847 }
848 return false;
849}
850
851const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
852 const std::string& dex_location,
853 uint32_t dex_location_checksum) {
854 bool verified = VerifyOatFileChecksums(oat_file, dex_location, dex_location_checksum);
855 if (!verified) {
856 return NULL;
857 }
858 RegisterOatFileLocked(*oat_file);
859 return oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700860}
861
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800862const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700863 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800864
Brian Carlstroma004aa92012-02-08 18:05:09 -0800865 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
Brian Carlstrom866c8622012-01-06 16:35:13 -0800866 if (open_oat_file != NULL) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800867 return open_oat_file->GetOatDexFile(dex_location)->OpenDexFile();
Brian Carlstromae826982011-11-09 01:33:42 -0800868 }
869
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700870 // Look for an existing file next to dex. for example, for
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700871 // /foo/bar/baz.jar, look for /foo/bar/baz.odex.
872 std::string odex_filename(OatFile::DexFilenameToOdexFilename(dex_location));
873 const OatFile* oat_file = FindOatFileFromOatLocationLocked(odex_filename);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800874 if (oat_file != NULL) {
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700875 uint32_t dex_location_checksum;
876 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
877 // If no classes.dex found in dex_location, it has been stripped, assume oat is up-to-date.
878 // This is the common case in user builds for jar's and apk's in the /system directory.
879 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700880 CHECK(oat_dex_file != NULL) << odex_filename << " " << dex_location;
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700881 RegisterOatFileLocked(*oat_file);
882 return oat_dex_file->OpenDexFile();
883 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700884 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
885 dex_location,
886 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700887 if (dex_file != NULL) {
888 return dex_file;
889 }
Brian Carlstroma004aa92012-02-08 18:05:09 -0800890 }
Brian Carlstrom7675e162013-06-10 16:18:04 -0700891 // Look for an existing file in the dalvik-cache, validating the result if found
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700892 // not found in /foo/bar/baz.odex? try /data/dalvik-cache/foo@bar@baz.jar@classes.dex
893 std::string cache_location(GetDalvikCacheFilenameOrDie(dex_location));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700894 oat_file = FindOatFileFromOatLocationLocked(cache_location);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800895 if (oat_file != NULL) {
896 uint32_t dex_location_checksum;
897 if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
898 LOG(WARNING) << "Failed to compute checksum: " << dex_location;
899 return NULL;
900 }
Brian Carlstromafe25512012-06-27 17:02:58 -0700901 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(oat_file,
902 dex_location,
903 dex_location_checksum);
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700904 if (dex_file != NULL) {
905 return dex_file;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700906 }
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800907 if (TEMP_FAILURE_RETRY(unlink(oat_file->GetLocation().c_str())) != 0) {
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700908 PLOG(FATAL) << "Failed to remove obsolete oat file " << oat_file->GetLocation();
Brian Carlstromd601af82012-01-06 10:15:19 -0800909 }
jeffhao262bf462011-10-20 18:36:32 -0700910 }
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700911 LOG(INFO) << "Failed to open oat file from " << odex_filename << " or " << cache_location << ".";
Brian Carlstroma004aa92012-02-08 18:05:09 -0800912
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800913 // Try to generate oat file if it wasn't found or was obsolete.
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700914 std::string oat_cache_filename(GetDalvikCacheFilenameOrDie(dex_location));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700915 return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_cache_filename);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700916}
917
Brian Carlstromae826982011-11-09 01:33:42 -0800918const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700919 for (size_t i = 0; i < oat_files_.size(); i++) {
920 const OatFile* oat_file = oat_files_[i];
921 DCHECK(oat_file != NULL);
Brian Carlstromae826982011-11-09 01:33:42 -0800922 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700923 return oat_file;
924 }
925 }
Brian Carlstromfad71432011-10-16 20:25:10 -0700926 return NULL;
927}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700928
Brian Carlstromae826982011-11-09 01:33:42 -0800929const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700930 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700931 return FindOatFileFromOatLocationLocked(oat_location);
932}
933
934const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string& oat_location) {
jeffhaof6174e82012-01-31 16:14:17 -0800935 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
936 if (oat_file != NULL) {
937 return oat_file;
938 }
939
Brian Carlstromf1d34552013-07-12 20:22:23 -0700940 oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700941 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800942 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700943 }
944 return oat_file;
945}
946
Ian Rogers848871b2013-08-05 10:56:33 -0700947static void InitFromImageCallbackCommon(mirror::Object* obj, ClassLinker* class_linker,
948 bool interpret_only_mode)
949 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
950 DCHECK(obj != NULL);
951 DCHECK(class_linker != NULL);
952
953 if (obj->GetClass()->IsStringClass()) {
954 class_linker->GetInternTable()->RegisterStrong(obj->AsString());
955 } else if (obj->IsClass()) {
956 // Restore class to ClassLinker::classes_ table.
957 mirror::Class* klass = obj->AsClass();
958 ClassHelper kh(klass, class_linker);
959 mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
960 DCHECK(existing == NULL) << kh.GetDescriptor();
961 } else if (interpret_only_mode && obj->IsMethod()) {
962 mirror::AbstractMethod* method = obj->AsMethod();
963 if (!method->IsNative()) {
964 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
965 if (method != Runtime::Current()->GetResolutionMethod()) {
966 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
967 }
968 }
969 }
970}
971
972static void InitFromImageCallback(mirror::Object* obj, void* arg)
973 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
974 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
975 InitFromImageCallbackCommon(obj, class_linker, false);
976}
977
978static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
979 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
980 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
981 InitFromImageCallbackCommon(obj, class_linker, true);
982}
983
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700984void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800985 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700986 CHECK(!init_done_);
987
Ian Rogers1d54e732013-05-02 21:10:01 -0700988 gc::Heap* heap = Runtime::Current()->GetHeap();
989 gc::space::ImageSpace* space = heap->GetImageSpace();
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700990 CHECK(space != NULL);
991 OatFile& oat_file = GetImageOatFile(space);
992 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
993 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
994 CHECK(oat_file.GetOatHeader().GetImageFileLocation().empty());
995 portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
996 quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800997 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
998 mirror::ObjectArray<mirror::DexCache>* dex_caches =
999 dex_caches_object->AsObjectArray<mirror::DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001000
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001001 mirror::ObjectArray<mirror::Class>* class_roots =
1002 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>();
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001003 class_roots_ = class_roots;
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001004
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001005 // Special case of setting up the String class early so that we can test arbitrary objects
1006 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001007 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001008
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001009 CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001010 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers1f539342012-10-03 21:09:42 -07001011 Thread* self = Thread::Current();
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001012 for (int i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001013 SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001014 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001015 const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location);
1016 CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001017 const DexFile* dex_file = oat_dex_file->OpenDexFile();
1018 if (dex_file == NULL) {
1019 LOG(FATAL) << "Failed to open dex file " << dex_file_location
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001020 << " from within oat file " << oat_file.GetLocation();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001021 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001022
1023 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
1024
1025 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001026 }
1027
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001028 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
1029 // bitmap walk.
1030 mirror::AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
1031 GetClassRoot(kJavaLangReflectMethod));
1032
Brian Carlstroma663ea52011-08-19 23:33:41 -07001033 // reinit clases_ table
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001034 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001035 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001036 heap->FlushAllocStack();
Ian Rogers848871b2013-08-05 10:56:33 -07001037 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
1038 heap->GetLiveBitmap()->Walk(InitFromImageInterpretOnlyCallback, this);
1039 } else {
1040 heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
1041 }
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001042 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001043
1044 // reinit class_roots_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001045 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001046 class_roots_ = class_roots;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001047
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001048 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001049 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1050 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001051 // String class root was set above
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001052 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001053 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1054 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1055 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1056 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1057 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1058 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1059 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1060 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1061 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1062 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001063
1064 FinishInit();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001065
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001066 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001067}
1068
Brian Carlstroma663ea52011-08-19 23:33:41 -07001069// Keep in sync with InitCallback. Anything we visit, we need to
1070// reinit references to when reinitializing a ClassLinker from a
1071// mapped image.
Ian Rogers1d54e732013-05-02 21:10:01 -07001072void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001073 visitor(class_roots_, arg);
Ian Rogers50b35e22012-10-04 10:09:15 -07001074 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001075 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001076 ReaderMutexLock mu(self, dex_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001077 for (size_t i = 0; i < dex_caches_.size(); i++) {
1078 visitor(dex_caches_[i], arg);
1079 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001080 }
1081
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001082 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001083 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001084 typedef Table::const_iterator It; // TODO: C++0x auto
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001085 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
Elliott Hughes410c0c82011-09-01 17:58:25 -07001086 visitor(it->second, arg);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001087 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001088
1089 // We deliberately ignore the class roots in the image since we
1090 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001091 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001092
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001093 visitor(array_iftable_, arg);
Ian Rogers1d54e732013-05-02 21:10:01 -07001094 if (clean_dirty) {
1095 is_dirty_ = false;
1096 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001097}
1098
Elliott Hughesa2155262011-11-16 16:26:58 -08001099void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001100 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -08001101 typedef Table::const_iterator It; // TODO: C++0x auto
1102 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
1103 if (!visitor(it->second, arg)) {
1104 return;
1105 }
1106 }
1107 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
1108 if (!visitor(it->second, arg)) {
1109 return;
1110 }
1111 }
1112}
1113
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001114static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1115 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001116 classes->insert(c);
1117 return true;
1118}
1119
1120void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001121 std::set<mirror::Class*> classes;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001122 VisitClasses(GetClassesVisitor, &classes);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001123 typedef std::set<mirror::Class*>::const_iterator It; // TODO: C++0x auto
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001124 for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
1125 if (!visitor(*it, arg)) {
1126 return;
1127 }
1128 }
1129}
1130
1131
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001132ClassLinker::~ClassLinker() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001133 mirror::Class::ResetClass();
1134 mirror::String::ResetClass();
1135 mirror::Field::ResetClass();
1136 mirror::AbstractMethod::ResetClasses();
1137 mirror::BooleanArray::ResetArrayClass();
1138 mirror::ByteArray::ResetArrayClass();
1139 mirror::CharArray::ResetArrayClass();
1140 mirror::DoubleArray::ResetArrayClass();
1141 mirror::FloatArray::ResetArrayClass();
1142 mirror::IntArray::ResetArrayClass();
1143 mirror::LongArray::ResetArrayClass();
1144 mirror::ShortArray::ResetArrayClass();
1145 mirror::Throwable::ResetClass();
1146 mirror::StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001147 STLDeleteElements(&boot_class_path_);
1148 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001149}
1150
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001151mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001152 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001153 mirror::Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
1154 SirtRef<mirror::DexCache> dex_cache(self,
1155 down_cast<mirror::DexCache*>(heap->AllocObject(self, dex_cache_class,
1156 dex_cache_class->GetObjectSize())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001157 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001158 return NULL;
1159 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001160 SirtRef<mirror::String>
1161 location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001162 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001163 return NULL;
1164 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001165 SirtRef<mirror::ObjectArray<mirror::String> >
1166 strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001167 if (strings.get() == NULL) {
1168 return NULL;
1169 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001170 SirtRef<mirror::ObjectArray<mirror::Class> >
1171 types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001172 if (types.get() == NULL) {
1173 return NULL;
1174 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001175 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07001176 methods(self, AllocAbstractMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001177 if (methods.get() == NULL) {
1178 return NULL;
1179 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001180 SirtRef<mirror::ObjectArray<mirror::Field> >
1181 fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001182 if (fields.get() == NULL) {
1183 return NULL;
1184 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001185 SirtRef<mirror::ObjectArray<mirror::StaticStorageBase> >
Ian Rogers50b35e22012-10-04 10:09:15 -07001186 initialized_static_storage(self,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001187 AllocObjectArray<mirror::StaticStorageBase>(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001188 if (initialized_static_storage.get() == NULL) {
1189 return NULL;
1190 }
1191
Mathieu Chartier66f19252012-09-18 08:57:04 -07001192 dex_cache->Init(&dex_file,
1193 location.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001194 strings.get(),
1195 types.get(),
1196 methods.get(),
1197 fields.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001198 initialized_static_storage.get());
1199 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001200}
1201
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001202mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
1203 size_t class_size) {
1204 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07001205 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001206 SirtRef<mirror::Class> klass(self,
Ian Rogers50b35e22012-10-04 10:09:15 -07001207 heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001208 klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001209 klass->SetClassSize(class_size);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001210 return klass.get();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001211}
1212
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001213mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001214 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001215}
1216
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001217mirror::Field* ClassLinker::AllocField(Thread* self) {
1218 return down_cast<mirror::Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001219}
1220
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001221mirror::Method* ClassLinker::AllocMethod(Thread* self) {
1222 return down_cast<mirror::Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001223}
1224
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001225mirror::Constructor* ClassLinker::AllocConstructor(Thread* self) {
1226 return down_cast<mirror::Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001227}
1228
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001229mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
1230 size_t length) {
1231 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(self,
1232 GetClassRoot(kJavaLangStackTraceElementArrayClass),
1233 length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001234}
1235
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001236static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001237 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001238 DCHECK(klass != NULL);
1239 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001240 if (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers1f539342012-10-03 21:09:42 -07001241 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001242 // Check for circular dependencies between classes.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001243 if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001244 ThrowClassCircularityError(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001245 klass->SetStatus(mirror::Class::kStatusError);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001246 return NULL;
1247 }
1248 // Wait for the pending initialization to complete.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001249 while (!klass->IsResolved() && !klass->IsErroneous()) {
Ian Rogers05f30572013-02-20 12:13:11 -08001250 lock.WaitIgnoringInterrupts();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001251 }
1252 }
1253 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001254 ThrowEarlierClassFailure(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001255 return NULL;
1256 }
1257 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001258 CHECK(klass->IsResolved()) << PrettyClass(klass);
Ian Rogers62d6c772013-02-27 08:32:07 -08001259 self->AssertNoPendingException();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001260 return klass;
1261}
1262
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001263mirror::Class* ClassLinker::FindSystemClass(const char* descriptor) {
Elliott Hughesdb7d5e92011-12-16 18:47:37 -08001264 return FindClass(descriptor, NULL);
1265}
1266
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001267mirror::Class* ClassLinker::FindClass(const char* descriptor, mirror::ClassLoader* class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001268 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001269 Thread* self = Thread::Current();
1270 DCHECK(self != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001271 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001272 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001273 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1274 // for primitive classes that aren't backed by dex files.
1275 return FindPrimitiveClass(descriptor[0]);
1276 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001277 // Find the class in the loaded classes table.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001278 mirror::Class* klass = LookupClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001279 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001280 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001281 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001282 // Class is not yet loaded.
1283 if (descriptor[0] == '[') {
1284 return CreateArrayClass(descriptor, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001285
Jesse Wilson47daf872011-11-23 11:42:45 -05001286 } else if (class_loader == NULL) {
1287 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1288 if (pair.second != NULL) {
1289 return DefineClass(descriptor, NULL, *pair.first, *pair.second);
1290 }
1291
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001292 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001293 // first try the boot class path
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001294 mirror::Class* system_class = FindSystemClass(descriptor);
Jesse Wilson47daf872011-11-23 11:42:45 -05001295 if (system_class != NULL) {
1296 return system_class;
1297 }
1298 CHECK(self->IsExceptionPending());
1299 self->ClearException();
1300
1301 // next try the compile time class path
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001302 const std::vector<const DexFile*>* class_path;
1303 {
1304 ScopedObjectAccessUnchecked soa(Thread::Current());
1305 ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
1306 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1307 }
1308
1309 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001310 if (pair.second != NULL) {
1311 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001312 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001313
1314 } else {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001315 ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1316 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
1317 soa.AddLocalReference<jobject>(class_loader));
Elliott Hughes95572412011-12-13 18:14:20 -08001318 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001319 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001320 {
1321 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001322 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1323 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001324 if (class_name_object.get() == NULL) {
1325 return NULL;
1326 }
1327 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001328 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1329 WellKnownClasses::java_lang_ClassLoader_loadClass,
1330 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001331 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001332 if (soa.Self()->IsExceptionPending()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001333 // If the ClassLoader threw, pass that exception up.
1334 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001335 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001336 // broken loader - throw NPE to be compatible with Dalvik
Ian Rogers62d6c772013-02-27 08:32:07 -08001337 ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1338 class_name_string.c_str()).c_str());
Ian Rogerscab01012012-01-10 17:35:46 -08001339 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001340 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001341 // success, return mirror::Class*
1342 return soa.Decode<mirror::Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001343 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001344 }
1345
Elliott Hughes82914b62012-04-09 15:56:29 -07001346 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001347 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001348}
1349
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001350mirror::Class* ClassLinker::DefineClass(const StringPiece& descriptor,
1351 mirror::ClassLoader* class_loader,
1352 const DexFile& dex_file,
1353 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001354 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001355 SirtRef<mirror::Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001356 // Load the class from the dex file.
1357 if (!init_done_) {
1358 // finish up init of hand crafted class_roots_
1359 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001360 klass.reset(GetClassRoot(kJavaLangObject));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001361 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001362 klass.reset(GetClassRoot(kJavaLangClass));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001363 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001364 klass.reset(GetClassRoot(kJavaLangString));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001365 } else if (descriptor == "Ljava/lang/DexCache;") {
1366 klass.reset(GetClassRoot(kJavaLangDexCache));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001367 } else if (descriptor == "Ljava/lang/reflect/Field;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001368 klass.reset(GetClassRoot(kJavaLangReflectField));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001369 } else if (descriptor == "Ljava/lang/reflect/AbstractMethod;") {
1370 klass.reset(GetClassRoot(kJavaLangReflectAbstractMethod));
1371 } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
1372 klass.reset(GetClassRoot(kJavaLangReflectConstructor));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001373 } else if (descriptor == "Ljava/lang/reflect/Method;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001374 klass.reset(GetClassRoot(kJavaLangReflectMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001375 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001376 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001377 }
1378 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001379 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001380 }
1381 klass->SetDexCache(FindDexCache(dex_file));
1382 LoadClass(dex_file, dex_class_def, klass, class_loader);
1383 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001384 if (self->IsExceptionPending()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001385 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001386 return NULL;
1387 }
Ian Rogers1f539342012-10-03 21:09:42 -07001388 ObjectLock lock(self, klass.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001389 klass->SetClinitThreadId(self->GetTid());
1390 // Add the newly loaded class to the loaded classes table.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001391 SirtRef<mirror::Class> existing(self, InsertClass(descriptor, klass.get(), false));
Brian Carlstrom01e076e2012-03-30 11:54:16 -07001392 if (existing.get() != NULL) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08001393 // We failed to insert because we raced with another thread.
Ian Rogers50b35e22012-10-04 10:09:15 -07001394 return EnsureResolved(self, existing.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001395 }
1396 // Finish loading (if necessary) by finding parents
1397 CHECK(!klass->IsLoaded());
1398 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1399 // Loading failed.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001400 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001401 lock.NotifyAll();
1402 return NULL;
1403 }
1404 CHECK(klass->IsLoaded());
1405 // Link the class (if necessary)
1406 CHECK(!klass->IsResolved());
Ian Rogersc2b44472011-12-14 21:17:17 -08001407 if (!LinkClass(klass, NULL)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001408 // Linking failed.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001409 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001410 lock.NotifyAll();
1411 return NULL;
1412 }
1413 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001414
1415 /*
1416 * We send CLASS_PREPARE events to the debugger from here. The
1417 * definition of "preparation" is creating the static fields for a
1418 * class and initializing them to the standard default values, but not
1419 * executing any code (that comes later, during "initialization").
1420 *
1421 * We did the static preparation in LinkClass.
1422 *
1423 * The class has been prepared and resolved but possibly not yet verified
1424 * at this point.
1425 */
1426 Dbg::PostClassPrepare(klass.get());
1427
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001428 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001429}
1430
Brian Carlstrom4873d462011-08-21 15:23:39 -07001431// Precomputes size that will be needed for Class, matching LinkStaticFields
1432size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
1433 const DexFile::ClassDef& dex_class_def) {
1434 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001435 size_t num_ref = 0;
1436 size_t num_32 = 0;
1437 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001438 if (class_data != NULL) {
1439 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1440 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001441 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001442 char c = descriptor[0];
1443 if (c == 'L' || c == '[') {
1444 num_ref++;
1445 } else if (c == 'J' || c == 'D') {
1446 num_64++;
1447 } else {
1448 num_32++;
1449 }
1450 }
1451 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001452 // start with generic class data
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001453 size_t size = sizeof(mirror::Class);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001454 // follow with reference fields which must be contiguous at start
1455 size += (num_ref * sizeof(uint32_t));
1456 // if there are 64-bit fields to add, make sure they are aligned
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001457 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
Brian Carlstrom4873d462011-08-21 15:23:39 -07001458 if (num_32 != 0) {
1459 // use an available 32-bit field for padding
1460 num_32--;
1461 }
1462 size += sizeof(uint32_t); // either way, we are adding a word
1463 DCHECK_EQ(size, RoundUp(size, 8));
1464 }
1465 // tack on any 64-bit fields now that alignment is assured
1466 size += (num_64 * sizeof(uint64_t));
1467 // tack on any remaining 32-bit fields
1468 size += (num_32 * sizeof(uint32_t));
1469 return size;
1470}
1471
Ian Rogers19846512012-02-24 11:42:47 -08001472const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
1473 DCHECK(descriptor != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001474 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
1475 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1476 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
1477 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
1478 uint32_t class_def_index;
1479 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
1480 CHECK(found) << dex_file.GetLocation() << " " << descriptor;
1481 const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
1482 CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
1483 return oat_class;
1484}
1485
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001486static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint32_t method_idx) {
1487 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1488 const DexFile::TypeId& type_id = dex_file.GetTypeId(method_id.class_idx_);
1489 const DexFile::ClassDef* class_def = dex_file.FindClassDef(dex_file.GetTypeDescriptor(type_id));
1490 CHECK(class_def != NULL);
1491 const byte* class_data = dex_file.GetClassData(*class_def);
1492 CHECK(class_data != NULL);
1493 ClassDataItemIterator it(dex_file, class_data);
1494 // Skip fields
1495 while (it.HasNextStaticField()) {
1496 it.Next();
1497 }
1498 while (it.HasNextInstanceField()) {
1499 it.Next();
1500 }
1501 // Process methods
1502 size_t class_def_method_index = 0;
1503 while (it.HasNextDirectMethod()) {
1504 if (it.GetMemberIndex() == method_idx) {
1505 return class_def_method_index;
1506 }
1507 class_def_method_index++;
1508 it.Next();
1509 }
1510 while (it.HasNextVirtualMethod()) {
1511 if (it.GetMemberIndex() == method_idx) {
1512 return class_def_method_index;
1513 }
1514 class_def_method_index++;
1515 it.Next();
1516 }
1517 DCHECK(!it.HasNext());
1518 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1519 return 0;
1520}
1521
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001522const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::AbstractMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001523 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001524 // method for direct methods (or virtual methods made direct).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001525 mirror::Class* declaring_class = method->GetDeclaringClass();
Ian Rogersfb6adba2012-03-04 21:51:51 -08001526 size_t oat_method_index;
1527 if (method->IsStatic() || method->IsDirect()) {
1528 // Simple case where the oat method index was stashed at load time.
1529 oat_method_index = method->GetMethodIndex();
1530 } else {
1531 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1532 // by search for its position in the declared virtual methods.
1533 oat_method_index = declaring_class->NumDirectMethods();
1534 size_t end = declaring_class->NumVirtualMethods();
1535 bool found = false;
1536 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001537 if (declaring_class->GetVirtualMethod(i) == method) {
1538 found = true;
1539 break;
1540 }
Ian Rogersf320b632012-03-13 18:47:47 -07001541 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001542 }
1543 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1544 }
1545 ClassHelper kh(declaring_class);
Ian Rogers19846512012-02-24 11:42:47 -08001546 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
Brian Carlstromf5822582012-03-19 22:34:31 -07001547 CHECK(oat_class.get() != NULL);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001548 DCHECK_EQ(oat_method_index,
1549 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
1550 method->GetDexMethodIndex()));
1551
TDYa12785321912012-04-01 15:24:56 -07001552 return oat_class->GetOatMethod(oat_method_index);
1553}
1554
1555// Special case to get oat code without overwriting a trampoline.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001556const void* ClassLinker::GetOatCodeFor(const mirror::AbstractMethod* method) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001557 CHECK(!method->IsAbstract()) << PrettyMethod(method);
Jeff Hao8df6cea2013-07-29 13:54:48 -07001558 if (method->IsProxyMethod()) {
1559#if !defined(ART_USE_PORTABLE_COMPILER)
1560 return reinterpret_cast<void*>(art_quick_proxy_invoke_handler);
1561#else
1562 return reinterpret_cast<void*>(art_portable_proxy_invoke_handler);
1563#endif
1564 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001565 const void* result = GetOatMethodFor(method).GetCode();
1566 if (result == NULL) {
1567 // No code? You must mean to go into the interpreter.
Ian Rogers848871b2013-08-05 10:56:33 -07001568 result = GetCompiledCodeToInterpreterBridge();
Ian Rogersf3e98552013-03-20 15:49:49 -07001569 }
1570 return result;
TDYa12785321912012-04-01 15:24:56 -07001571}
1572
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001573const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx) {
1574 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
1575 const char* descriptor = dex_file.GetTypeDescriptor(dex_file.GetTypeId(method_id.class_idx_));
1576 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, method_idx);
1577 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, descriptor));
1578 CHECK(oat_class.get() != NULL);
1579 return oat_class->GetOatMethod(oat_method_idx).GetCode();
1580}
1581
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001582// Returns true if the method must run with interpreter, false otherwise.
1583static bool NeedsInterpreter(const mirror::AbstractMethod* method, const void* code) {
1584 if (code == NULL) {
1585 // No code: need interpreter.
1586 return true;
1587 }
1588 // If interpreter mode is enabled, every method (except native and proxy) must
1589 // be run with interpreter.
1590 return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
1591 !method->IsNative() && !method->IsProxyMethod();
1592}
1593
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001594void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001595 ClassHelper kh(klass);
1596 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1597 CHECK(dex_class_def != NULL);
1598 const DexFile& dex_file = kh.GetDexFile();
1599 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1600 if (class_data == NULL) {
1601 return; // no fields or methods - for example a marker interface
1602 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001603 Runtime* runtime = Runtime::Current();
1604 if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
Ian Rogers19846512012-02-24 11:42:47 -08001605 // OAT file unavailable
1606 return;
1607 }
Brian Carlstromf5822582012-03-19 22:34:31 -07001608 UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
1609 CHECK(oat_class.get() != NULL);
Ian Rogers19846512012-02-24 11:42:47 -08001610 ClassDataItemIterator it(dex_file, class_data);
1611 // Skip fields
1612 while (it.HasNextStaticField()) {
1613 it.Next();
1614 }
1615 while (it.HasNextInstanceField()) {
1616 it.Next();
1617 }
Ian Rogers19846512012-02-24 11:42:47 -08001618 // Link the code of methods skipped by LinkCode
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001619 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
1620 mirror::AbstractMethod* method = klass->GetDirectMethod(method_index);
1621 if (!method->IsStatic()) {
1622 // Only update static methods.
1623 continue;
Ian Rogers19846512012-02-24 11:42:47 -08001624 }
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001625 const void* code = oat_class->GetOatMethod(method_index).GetCode();
1626 const bool enter_interpreter = NeedsInterpreter(method, code);
1627 if (enter_interpreter) {
1628 // Use interpreter entry point.
Ian Rogers848871b2013-08-05 10:56:33 -07001629 code = GetCompiledCodeToInterpreterBridge();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001630 }
1631 runtime->GetInstrumentation()->UpdateMethodsCode(method, code);
Ian Rogers19846512012-02-24 11:42:47 -08001632 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001633 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08001634}
1635
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001636static void LinkCode(SirtRef<mirror::AbstractMethod>& method, const OatFile::OatClass* oat_class,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001637 uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001638 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001639 // Method shouldn't have already been linked.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001640 DCHECK(method->GetEntryPointFromCompiledCode() == NULL);
Brian Carlstrom92827a52011-10-10 15:50:01 -07001641 // Every kind of method should at least get an invoke stub from the oat_method.
1642 // non-abstract methods also get their code pointers.
1643 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstrom265091e2013-01-30 14:08:26 -08001644 oat_method.LinkMethod(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001645
Jeff Hao16743632013-05-08 10:59:04 -07001646 // Install entry point from interpreter.
Jeff Hao790ad902013-05-22 15:02:08 -07001647 Runtime* runtime = Runtime::Current();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001648 bool enter_interpreter = NeedsInterpreter(method.get(), method->GetEntryPointFromCompiledCode());
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001649 if (enter_interpreter) {
Ian Rogers848871b2013-08-05 10:56:33 -07001650 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001651 } else {
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07001652 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001653 }
1654
Brian Carlstrom92827a52011-10-10 15:50:01 -07001655 if (method->IsAbstract()) {
Ian Rogers848871b2013-08-05 10:56:33 -07001656 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001657 return;
1658 }
Ian Rogers19846512012-02-24 11:42:47 -08001659
1660 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001661 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001662 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
1663 // after initializing class (see ClassLinker::InitializeClass method).
Jeff Hao0aba0ba2013-06-03 14:49:28 -07001664 method->SetEntryPointFromCompiledCode(GetResolutionTrampoline(runtime->GetClassLinker()));
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001665 } else if (enter_interpreter) {
1666 // Set entry point from compiled code if there's no code or in interpreter only mode.
Ian Rogers848871b2013-08-05 10:56:33 -07001667 method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08001668 }
jeffhao26c0a1a2012-01-17 16:28:33 -08001669
Ian Rogers62d6c772013-02-27 08:32:07 -08001670 if (method->IsNative()) {
1671 // Unregistering restores the dlsym lookup stub.
1672 method->UnregisterNative(Thread::Current());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001673 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001674
Ian Rogers62d6c772013-02-27 08:32:07 -08001675 // Allow instrumentation its chance to hijack code.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001676 runtime->GetInstrumentation()->UpdateMethodsCode(method.get(),
1677 method->GetEntryPointFromCompiledCode());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001678}
1679
Brian Carlstromf615a612011-07-23 12:50:34 -07001680void ClassLinker::LoadClass(const DexFile& dex_file,
1681 const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001682 SirtRef<mirror::Class>& klass,
1683 mirror::ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001684 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001685 CHECK(klass->GetDexCache() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001686 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001687 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001688 CHECK(descriptor != NULL);
1689
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001690 klass->SetClass(GetClassRoot(kJavaLangClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001691 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001692 // Make sure that none of our runtime-only flags are set.
mikaelpeltier6ffd0962012-10-25 15:37:45 +02001693 // TODO: JACK CLASS ACCESS (HACK TO BE REMOVED)
1694 CHECK_EQ(access_flags & ~(kAccJavaFlagsMask | kAccClassJack), 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001695 klass->SetAccessFlags(access_flags);
1696 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001697 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001698 klass->SetStatus(mirror::Class::kStatusIdx);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001699
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001700 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001701
Ian Rogers0571d352011-11-03 19:51:38 -07001702 // Load fields fields.
1703 const byte* class_data = dex_file.GetClassData(dex_class_def);
1704 if (class_data == NULL) {
1705 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001706 }
Ian Rogers0571d352011-11-03 19:51:38 -07001707 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001708 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001709 if (it.NumStaticFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001710 klass->SetSFields(AllocFieldArray(self, it.NumStaticFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001711 }
1712 if (it.NumInstanceFields() != 0) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07001713 klass->SetIFields(AllocFieldArray(self, it.NumInstanceFields()));
Ian Rogers0571d352011-11-03 19:51:38 -07001714 }
1715 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001716 SirtRef<mirror::Field> sfield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001717 klass->SetStaticField(i, sfield.get());
1718 LoadField(dex_file, it, klass, sfield);
1719 }
1720 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001721 SirtRef<mirror::Field> ifield(self, AllocField(self));
Ian Rogers0571d352011-11-03 19:51:38 -07001722 klass->SetInstanceField(i, ifield.get());
1723 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001724 }
1725
Brian Carlstromf5822582012-03-19 22:34:31 -07001726 UniquePtr<const OatFile::OatClass> oat_class;
1727 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1728 oat_class.reset(GetOatClass(dex_file, descriptor));
1729 }
Ian Rogers19846512012-02-24 11:42:47 -08001730
Ian Rogers0571d352011-11-03 19:51:38 -07001731 // Load methods.
1732 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001733 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001734 klass->SetDirectMethods(AllocAbstractMethodArray(self, it.NumDirectMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001735 }
Ian Rogers0571d352011-11-03 19:51:38 -07001736 if (it.NumVirtualMethods() != 0) {
1737 // TODO: append direct methods to class object
Ian Rogers4445a7e2012-10-05 17:19:13 -07001738 klass->SetVirtualMethods(AllocMethodArray(self, it.NumVirtualMethods()));
Brian Carlstrom934486c2011-07-12 23:42:50 -07001739 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001740 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001741 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001742 SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001743 klass->SetDirectMethod(i, method.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001744 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001745 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001746 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001747 method->SetMethodIndex(class_def_method_index);
1748 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001749 }
1750 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001751 SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogers0571d352011-11-03 19:51:38 -07001752 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001753 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Ian Rogers0571d352011-11-03 19:51:38 -07001754 if (oat_class.get() != NULL) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001755 LinkCode(method, oat_class.get(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001756 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001757 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001758 }
1759 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001760}
1761
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001762void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001763 SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001764 uint32_t field_idx = it.GetMemberIndex();
1765 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001766 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001767 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001768}
1769
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001770mirror::AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
1771 const ClassDataItemIterator& it,
1772 SirtRef<mirror::Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001773 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001774 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001775 StringPiece method_name(dex_file.GetMethodName(method_id));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001776
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001777 mirror::AbstractMethod* dst = NULL;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001778 if (method_name == "<init>") {
Ian Rogers50b35e22012-10-04 10:09:15 -07001779 dst = AllocConstructor(self);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001780 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001781 dst = AllocMethod(self);
Elliott Hughes80609252011-09-23 17:24:51 -07001782 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07001783 DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
1784
Ian Rogers50b35e22012-10-04 10:09:15 -07001785 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07001786 dst->SetDexMethodIndex(dex_method_idx);
1787 dst->SetDeclaringClass(klass.get());
Elliott Hughes20cde902011-10-04 17:37:27 -07001788
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001789 if (method_name == "finalize") {
1790 // Create the prototype for a signature of "()V"
1791 const DexFile::StringId* void_string_id = dex_file.FindStringId("V");
1792 if (void_string_id != NULL) {
1793 const DexFile::TypeId* void_type_id =
1794 dex_file.FindTypeId(dex_file.GetIndexForStringId(*void_string_id));
1795 if (void_type_id != NULL) {
1796 std::vector<uint16_t> no_args;
1797 const DexFile::ProtoId* finalizer_proto =
1798 dex_file.FindProtoId(dex_file.GetIndexForTypeId(*void_type_id), no_args);
1799 if (finalizer_proto != NULL) {
1800 // We have the prototype in the dex file
1801 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
1802 klass->SetFinalizable();
1803 } else {
1804 StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
1805 // The Enum class declares a "final" finalize() method to prevent subclasses from
1806 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
1807 // subclasses, so we exclude it here.
1808 // We also want to avoid setting the flag on Object, where we know that finalize() is
1809 // empty.
1810 if (klass_descriptor != "Ljava/lang/Object;" &&
1811 klass_descriptor != "Ljava/lang/Enum;") {
1812 klass->SetFinalizable();
1813 }
1814 }
1815 }
1816 }
Elliott Hughes20cde902011-10-04 17:37:27 -07001817 }
Carl Shapiro419ec7b2011-08-03 14:48:33 -07001818 }
Ian Rogers0571d352011-11-03 19:51:38 -07001819 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Ian Rogers0571d352011-11-03 19:51:38 -07001820 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001821
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001822 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08001823 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001824 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001825 dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001826
1827 CHECK(dst->IsMethod());
1828
Ian Rogers50b35e22012-10-04 10:09:15 -07001829 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001830 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07001831}
1832
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001833void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001834 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001835 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001836 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001837}
1838
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001839void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001840 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001841 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07001842 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001843}
1844
Brian Carlstromaded5f72011-10-07 17:15:04 -07001845bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001846 dex_lock_.AssertSharedHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001847 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1848 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08001849 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001850 }
1851 }
1852 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001853}
1854
Brian Carlstromaded5f72011-10-07 17:15:04 -07001855bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001856 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07001857 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001858}
1859
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001860void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001861 dex_lock_.AssertExclusiveHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001862 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07001863 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001864 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07001865 dex_cache->SetDexFile(&dex_file);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001866 Dirty();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001867}
1868
Brian Carlstromaded5f72011-10-07 17:15:04 -07001869void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07001870 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001871 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001872 ReaderMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001873 if (IsDexFileRegisteredLocked(dex_file)) {
1874 return;
1875 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001876 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001877 // Don't alloc while holding the lock, since allocation may need to
1878 // suspend all threads and another thread may need the dex_lock_ to
1879 // get to a suspend point.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001880 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001881 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001882 WriterMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07001883 if (IsDexFileRegisteredLocked(dex_file)) {
1884 return;
1885 }
1886 RegisterDexFileLocked(dex_file, dex_cache);
1887 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001888}
1889
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001890void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001891 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001892 RegisterDexFileLocked(dex_file, dex_cache);
1893}
1894
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001895mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001896 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001897 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07001898 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001899 mirror::DexCache* dex_cache = dex_caches_[i];
Mathieu Chartier66f19252012-09-18 08:57:04 -07001900 if (dex_cache->GetDexFile() == &dex_file) {
1901 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001902 }
1903 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001904 // Search matching by location name.
1905 std::string location(dex_file.GetLocation());
1906 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001907 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001908 if (dex_cache->GetDexFile()->GetLocation() == location) {
1909 return dex_cache;
1910 }
1911 }
1912 // Failure, dump diagnostic and abort.
1913 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001914 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001915 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
1916 }
1917 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001918 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001919}
1920
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001921void ClassLinker::FixupDexCaches(mirror::AbstractMethod* resolution_method) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001922 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08001923 for (size_t i = 0; i != dex_caches_.size(); ++i) {
1924 dex_caches_[i]->Fixup(resolution_method);
1925 }
1926}
1927
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001928mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
1929 return InitializePrimitiveClass(AllocClass(self, sizeof(mirror::Class)), type);
1930}
1931
1932mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001933 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07001934 // Must hold lock on object when initializing.
1935 ObjectLock lock(Thread::Current(), primitive_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001936 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001937 primitive_class->SetPrimitiveType(type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001938 primitive_class->SetStatus(mirror::Class::kStatusInitialized);
1939 mirror::Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
Ian Rogersc8982582012-09-07 16:53:25 -07001940 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001941 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07001942}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001943
Brian Carlstrombe977852011-07-19 14:54:54 -07001944// Create an array class (i.e. the class object for the array, not the
1945// array itself). "descriptor" looks like "[C" or "[[[[B" or
1946// "[Ljava/lang/String;".
1947//
1948// If "descriptor" refers to an array of primitives, look up the
1949// primitive type's internally-generated class object.
1950//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001951// "class_loader" is the class loader of the class that's referring to
1952// us. It's used to ensure that we're looking for the element type in
1953// the right context. It does NOT become the class loader for the
1954// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07001955//
1956// Returns NULL with an exception raised on failure.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001957mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
1958 mirror::ClassLoader* class_loader) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001959 CHECK_EQ('[', descriptor[0]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001960
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001961 // Identify the underlying component type
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001962 mirror::Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001963 if (component_type == NULL) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001964 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001965 return NULL;
1966 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001967
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001968 // See if the component type is already loaded. Array classes are
1969 // always associated with the class loader of their underlying
1970 // element type -- an array of Strings goes with the loader for
1971 // java/lang/String -- so we need to look for it there. (The
1972 // caller should have checked for the existence of the class
1973 // before calling here, but they did so with *their* class loader,
1974 // not the component type's loader.)
1975 //
1976 // If we find it, the caller adds "loader" to the class' initiating
1977 // loader list, which should prevent us from going through this again.
1978 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001979 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001980 // are the same, because our caller (FindClass) just did the
1981 // lookup. (Even if we get this wrong we still have correct behavior,
1982 // because we effectively do this lookup again when we add the new
1983 // class to the hash table --- necessary because of possible races with
1984 // other threads.)
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001985 if (class_loader != component_type->GetClassLoader()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001986 mirror::Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001987 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001988 return new_class;
1989 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001990 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001991
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001992 // Fill out the fields in the Class.
1993 //
1994 // It is possible to execute some methods against arrays, because
1995 // all arrays are subclasses of java_lang_Object_, so we need to set
1996 // up a vtable. We can just point at the one in java_lang_Object_.
1997 //
1998 // Array classes are simple enough that we don't need to do a full
1999 // link step.
Ian Rogers1f539342012-10-03 21:09:42 -07002000 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002001 SirtRef<mirror::Class> new_class(self, NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002002 if (!init_done_) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002003 // Classes that were hand created, ie not by FindSystemClass
Elliott Hughes418d20f2011-09-22 14:00:39 -07002004 if (descriptor == "[Ljava/lang/Class;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002005 new_class.reset(GetClassRoot(kClassArrayClass));
Elliott Hughes418d20f2011-09-22 14:00:39 -07002006 } else if (descriptor == "[Ljava/lang/Object;") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002007 new_class.reset(GetClassRoot(kObjectArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07002008 } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
2009 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Mathieu Chartier66f19252012-09-18 08:57:04 -07002010 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]) {
2011 new_class.reset(GetClassRoot(kJavaLangReflectAbstractMethodArrayClass));
Ian Rogers4445a7e2012-10-05 17:19:13 -07002012 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectFieldArrayClass]) {
2013 new_class.reset(GetClassRoot(kJavaLangReflectFieldArrayClass));
2014 } else if (descriptor == class_roots_descriptors_[kJavaLangReflectMethodArrayClass]) {
2015 new_class.reset(GetClassRoot(kJavaLangReflectMethodArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002016 } else if (descriptor == "[C") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002017 new_class.reset(GetClassRoot(kCharArrayClass));
Elliott Hughesc1674ed2011-08-25 18:09:09 -07002018 } else if (descriptor == "[I") {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002019 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002020 }
2021 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002022 if (new_class.get() == NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002023 new_class.reset(AllocClass(self, sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002024 if (new_class.get() == NULL) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002025 return NULL;
2026 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002027 new_class->SetComponentType(component_type);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002028 }
Ian Rogers1f539342012-10-03 21:09:42 -07002029 ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002030 DCHECK(new_class->GetComponentType() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002031 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002032 new_class->SetSuperClass(java_lang_Object);
2033 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002034 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002035 new_class->SetClassLoader(component_type->GetClassLoader());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002036 new_class->SetStatus(mirror::Class::kStatusInitialized);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002037 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002038 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002039
2040
2041 // All arrays have java/lang/Cloneable and java/io/Serializable as
2042 // interfaces. We need to set that up here, so that stuff like
2043 // "instanceof" works right.
2044 //
2045 // Note: The GC could run during the call to FindSystemClass,
2046 // so we need to make sure the class object is GC-valid while we're in
2047 // there. Do this by clearing the interface list so the GC will just
2048 // think that the entries are null.
2049
2050
2051 // Use the single, global copies of "interfaces" and "iftable"
2052 // (remember not to free them for arrays).
Elliott Hughes92f14b22011-10-06 12:29:54 -07002053 CHECK(array_iftable_ != NULL);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002054 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002055
Elliott Hughes00626c22013-06-14 15:04:14 -07002056 // Inherit access flags from the component type.
2057 int access_flags = new_class->GetComponentType()->GetAccessFlags();
2058 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2059 access_flags &= kAccJavaFlagsMask;
2060 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002061 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07002062 access_flags |= kAccAbstract | kAccFinal;
2063 access_flags &= ~kAccInterface;
2064
2065 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002066
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002067 mirror::Class* existing = InsertClass(descriptor, new_class.get(), false);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002068 if (existing == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002069 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002070 }
2071 // Another thread must have loaded the class after we
2072 // started but before we finished. Abandon what we've
2073 // done.
2074 //
2075 // (Yes, this happens.)
2076
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002077 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002078}
2079
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002080mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002081 switch (Primitive::GetType(type)) {
2082 case Primitive::kPrimByte:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002083 return GetClassRoot(kPrimitiveByte);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002084 case Primitive::kPrimChar:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002085 return GetClassRoot(kPrimitiveChar);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002086 case Primitive::kPrimDouble:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002087 return GetClassRoot(kPrimitiveDouble);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002088 case Primitive::kPrimFloat:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002089 return GetClassRoot(kPrimitiveFloat);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002090 case Primitive::kPrimInt:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002091 return GetClassRoot(kPrimitiveInt);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002092 case Primitive::kPrimLong:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002093 return GetClassRoot(kPrimitiveLong);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002094 case Primitive::kPrimShort:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002095 return GetClassRoot(kPrimitiveShort);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002096 case Primitive::kPrimBoolean:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002097 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002098 case Primitive::kPrimVoid:
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002099 return GetClassRoot(kPrimitiveVoid);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002100 case Primitive::kPrimNot:
2101 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002102 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002103 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002104 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002105 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002106}
2107
Ian Rogers1d54e732013-05-02 21:10:01 -07002108mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::Class* klass,
2109 bool image_class) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002110 if (VLOG_IS_ON(class_linker)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002111 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08002112 std::string source;
2113 if (dex_cache != NULL) {
2114 source += " from ";
2115 source += dex_cache->GetLocation()->ToModifiedUtf8();
2116 }
2117 LOG(INFO) << "Loaded class " << descriptor << source;
2118 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002119 size_t hash = StringPieceHash()(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002120 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002121 Table& classes = image_class ? image_classes_ : classes_;
Ian Rogers1d54e732013-05-02 21:10:01 -07002122 mirror::Class* existing =
2123 LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002124#ifndef NDEBUG
2125 // Check we don't have the class in the other table in error
2126 Table& other_classes = image_class ? classes_ : image_classes_;
Elliott Hughesf8349362012-06-18 15:00:06 -07002127 CHECK(LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002128#endif
2129 if (existing != NULL) {
2130 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002131 }
Ian Rogers1d54e732013-05-02 21:10:01 -07002132 Runtime::Current()->GetHeap()->VerifyObject(klass);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002133 classes.insert(std::make_pair(hash, klass));
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07002134 Dirty();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002135 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002136}
2137
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002138bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002139 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002140 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughese5448b52012-01-18 16:44:06 -08002141 typedef Table::iterator It; // TODO: C++0x auto
Brian Carlstromae826982011-11-09 01:33:42 -08002142 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002143 ClassHelper kh;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002144 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
2145 ++it) {
2146 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002147 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002148 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002149 classes_.erase(it);
2150 return true;
2151 }
2152 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002153 for (It it = image_classes_.lower_bound(hash), end = classes_.end();
2154 it != end && it->first == hash; ++it) {
2155 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002156 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002157 if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstromae826982011-11-09 01:33:42 -08002158 image_classes_.erase(it);
2159 return true;
2160 }
2161 }
2162 return false;
2163}
2164
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002165mirror::Class* ClassLinker::LookupClass(const char* descriptor,
2166 const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002167 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002168 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07002169 // TODO: determine if its better to search classes_ or image_classes_ first
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002170 mirror::Class* klass = NULL;
2171 // Use image class only if the class_loader is null.
2172 if (class_loader == NULL) {
2173 klass = LookupClassLocked(descriptor, class_loader, hash, image_classes_);
2174 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002175 if (klass != NULL) {
2176 return klass;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002177 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002178 return LookupClassLocked(descriptor, class_loader, hash, classes_);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002179}
2180
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002181mirror::Class* ClassLinker::LookupClassLocked(const char* descriptor,
2182 const mirror::ClassLoader* class_loader,
2183 size_t hash, const Table& classes) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002184 ClassHelper kh(NULL, this);
2185 typedef Table::const_iterator It; // TODO: C++0x auto
2186 for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002187 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002188 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002189 if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002190#ifndef NDEBUG
2191 for (++it; it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002192 mirror::Class* klass2 = it->second;
Ian Rogersd85016c2012-02-03 18:27:34 -08002193 kh.ChangeClass(klass2);
2194 CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002195 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
Ian Rogersd85016c2012-02-03 18:27:34 -08002196 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002197 }
2198#endif
Ian Rogers5d76c432011-10-31 21:42:49 -07002199 return klass;
2200 }
2201 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002202 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002203}
2204
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002205void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002206 classes.clear();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002207 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002208 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002209 typedef Table::const_iterator It; // TODO: C++0x auto
2210 // TODO: determine if its better to search classes_ or image_classes_ first
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002211 ClassHelper kh(NULL, this);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002212 for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002213 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002214 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002215 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002216 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002217 }
2218 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002219 for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002220 mirror::Class* klass = it->second;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002221 kh.ChangeClass(klass);
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002222 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002223 classes.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002224 }
2225 }
2226}
2227
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002228void ClassLinker::VerifyClass(mirror::Class* klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002229 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002230 Thread* self = Thread::Current();
2231 ObjectLock lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002232
Ian Rogers9ffb0392012-09-10 11:56:50 -07002233 // Don't attempt to re-verify if already sufficiently verified.
2234 if (klass->IsVerified() ||
2235 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002236 return;
2237 }
2238
Ian Rogers9ffb0392012-09-10 11:56:50 -07002239 // The class might already be erroneous, for example at compile time if we attempted to verify
2240 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002241 if (klass->IsErroneous()) {
2242 ThrowEarlierClassFailure(klass);
2243 return;
2244 }
2245
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002246 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
2247 klass->SetStatus(mirror::Class::kStatusVerifying);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002248 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002249 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
2250 << PrettyClass(klass);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002251 CHECK(!Runtime::Current()->IsCompiler());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002252 klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002253 }
jeffhao98eacac2011-09-14 16:11:53 -07002254
Ian Rogers9ffb0392012-09-10 11:56:50 -07002255 // Verify super class.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002256 mirror::Class* super = klass->GetSuperClass();
Ian Rogers1c5eb702012-02-01 09:18:34 -08002257 if (super != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002258 // Acquire lock to prevent races on verifying the super class.
Ian Rogers1f539342012-10-03 21:09:42 -07002259 ObjectLock lock(self, super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002260
2261 if (!super->IsVerified() && !super->IsErroneous()) {
2262 Runtime::Current()->GetClassLinker()->VerifyClass(super);
2263 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002264 if (!super->IsCompileTimeVerified()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002265 std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
2266 PrettyDescriptor(klass).c_str(),
2267 PrettyDescriptor(super).c_str()));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002268 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002269 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002270 if (cause.get() != NULL) {
2271 self->ClearException();
2272 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002273 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002274 if (cause.get() != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002275 self->GetException(NULL)->SetCause(cause.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002276 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002277 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002278 return;
2279 }
2280 }
2281
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002282 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002283 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002284 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002285 bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002286 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhaoec014232012-09-05 10:42:25 -07002287 LOG(WARNING) << "Skipping runtime verification of erroneous class " << PrettyDescriptor(klass)
2288 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002289 ThrowVerifyError(klass, "Rejecting class %s because it failed compile-time verification",
2290 PrettyDescriptor(klass).c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002291 klass->SetStatus(mirror::Class::kStatusError);
jeffhaoec014232012-09-05 10:42:25 -07002292 return;
2293 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002294 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
Ian Rogers62d6c772013-02-27 08:32:07 -08002295 std::string error_msg;
jeffhaof1e6b7c2012-06-05 18:33:30 -07002296 if (!preverified) {
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002297 verifier_failure = verifier::MethodVerifier::VerifyClass(klass, error_msg,
2298 Runtime::Current()->IsCompiler());
jeffhaof1e6b7c2012-06-05 18:33:30 -07002299 }
2300 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002301 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
2302 LOG(WARNING) << "Soft verification failure in class " << PrettyDescriptor(klass)
2303 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2304 << " because: " << error_msg;
2305 }
Ian Rogers1f539342012-10-03 21:09:42 -07002306 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002307 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002308 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002309 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002310 klass->SetStatus(mirror::Class::kStatusVerified);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002311 } else {
2312 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2313 // Soft failures at compile time should be retried at runtime. Soft
2314 // failures at runtime will be handled by slow paths in the generated
2315 // code. Set status accordingly.
2316 if (Runtime::Current()->IsCompiler()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002317 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002318 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002319 klass->SetStatus(mirror::Class::kStatusVerified);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002320 }
2321 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002322 } else {
Ian Rogers09f6b562012-01-31 21:58:52 -08002323 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass)
Ian Rogers1c5eb702012-02-01 09:18:34 -08002324 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2325 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002326 self->AssertNoPendingException();
Ian Rogers62d6c772013-02-27 08:32:07 -08002327 ThrowVerifyError(klass, "%s", error_msg.c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002328 klass->SetStatus(mirror::Class::kStatusError);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002329 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002330 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
2331 // Class is verified so we don't need to do any access check in its methods.
2332 // Let the interpreter know it by setting the kAccPreverified flag onto each
2333 // method.
2334 // Note: we're going here during compilation and at runtime. When we set the
2335 // kAccPreverified flag when compiling image classes, the flag is recorded
2336 // in the image and is set when loading the image.
2337 klass->SetPreverifiedFlagOnAllMethods();
2338 }
jeffhao98eacac2011-09-14 16:11:53 -07002339}
2340
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002341bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
2342 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002343 // If we're compiling, we can only verify the class using the oat file if
2344 // we are not compiling the image or if the class we're verifying is not part of
2345 // the app. In other words, we will only check for preverification of bootclasspath
2346 // classes.
2347 if (Runtime::Current()->IsCompiler()) {
2348 // Are we compiling the bootclasspath?
2349 if (!Runtime::Current()->UseCompileTimeClassPath()) {
2350 return false;
2351 }
2352 // We are compiling an app (not the image).
2353
2354 // Is this an app class? (I.e. not a bootclasspath class)
2355 if (klass->GetClassLoader() != NULL) {
2356 return false;
2357 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002358 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002359
2360
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002361 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07002362 // Make this work with gtests, which do not set up the image properly.
2363 // TODO: we should clean up gtests to set up the image path properly.
2364 if (Runtime::Current()->IsCompiler() && (oat_file == NULL)) {
2365 return false;
2366 }
2367
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002368 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002369 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002370 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002371 const char* descriptor = ClassHelper(klass).GetDescriptor();
2372 uint32_t class_def_index;
2373 bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002374 CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002375 UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002376 CHECK(oat_class.get() != NULL)
2377 << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002378 oat_file_class_status = oat_class->GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002379 if (oat_file_class_status == mirror::Class::kStatusVerified ||
2380 oat_file_class_status == mirror::Class::kStatusInitialized) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002381 return true;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002382 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002383 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002384 // Compile time verification failed with a soft error. Compile time verification can fail
2385 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002386 // class ... {
2387 // Foo x;
2388 // .... () {
2389 // if (...) {
2390 // v1 gets assigned a type of resolved class Foo
2391 // } else {
2392 // v1 gets assigned a type of unresolved class Bar
2393 // }
2394 // iput x = v1
2395 // } }
2396 // when we merge v1 following the if-the-else it results in Conflict
2397 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2398 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2399 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2400 // at compile time).
2401 return false;
2402 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002403 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07002404 // Compile time verification failed with a hard error. This is caused by invalid instructions
2405 // in the class. These errors are unrecoverable.
2406 return false;
2407 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002408 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002409 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2410 // not loading the class.
2411 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2412 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002413 return false;
2414 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002415 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002416 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
2417
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002418 return false;
2419}
2420
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002421void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002422 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2423 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2424 }
2425 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2426 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2427 }
2428}
2429
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002430void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
2431 mirror::AbstractMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002432 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2433 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2434 if (code_item == NULL) {
2435 return; // native or abstract method
2436 }
2437 if (code_item->tries_size_ == 0) {
2438 return; // nothing to process
2439 }
2440 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2441 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2442 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2443 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2444 CatchHandlerIterator iterator(handlers_ptr);
2445 for (; iterator.HasNext(); iterator.Next()) {
2446 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2447 // unresolved exception types will be ignored by exception delivery
2448 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002449 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002450 if (exception_type == NULL) {
2451 DCHECK(Thread::Current()->IsExceptionPending());
2452 Thread::Current()->ClearException();
2453 }
2454 }
2455 }
2456 handlers_ptr = iterator.EndDataPointer();
2457 }
2458}
2459
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002460static void CheckProxyConstructor(mirror::AbstractMethod* constructor);
2461static void CheckProxyMethod(mirror::AbstractMethod* method,
2462 SirtRef<mirror::AbstractMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002463
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002464mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
2465 mirror::ObjectArray<mirror::Class>* interfaces,
2466 mirror::ClassLoader* loader,
2467 mirror::ObjectArray<mirror::AbstractMethod>* methods,
2468 mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws) {
Ian Rogers1f539342012-10-03 21:09:42 -07002469 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002470 SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2471 sizeof(mirror::SynthesizedProxyClass)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002472 CHECK(klass.get() != NULL);
Ian Rogersc2b44472011-12-14 21:17:17 -08002473 DCHECK(klass->GetClass() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002474 klass->SetObjectSize(sizeof(mirror::Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002475 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002476 klass->SetClassLoader(loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002477 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002478 klass->SetName(name);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002479 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002480 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogersc2b44472011-12-14 21:17:17 -08002481
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002482 klass->SetStatus(mirror::Class::kStatusIdx);
Ian Rogersc2b44472011-12-14 21:17:17 -08002483
2484 klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
2485
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002486 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogers4445a7e2012-10-05 17:19:13 -07002487 klass->SetSFields(AllocFieldArray(self, 2));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002488 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2489 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002490 SirtRef<mirror::Field> interfaces_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002491 klass->SetStaticField(0, interfaces_sfield.get());
2492 interfaces_sfield->SetDexFieldIndex(0);
2493 interfaces_sfield->SetDeclaringClass(klass.get());
2494 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2495 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002496 SirtRef<mirror::Field> throws_sfield(self, AllocField(self));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002497 klass->SetStaticField(1, throws_sfield.get());
2498 throws_sfield->SetDexFieldIndex(1);
2499 throws_sfield->SetDeclaringClass(klass.get());
2500 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002501
Ian Rogers466bb252011-10-14 03:29:56 -07002502 // Proxies have 1 direct method, the constructor
Ian Rogers4445a7e2012-10-05 17:19:13 -07002503 klass->SetDirectMethods(AllocAbstractMethodArray(self, 1));
Ian Rogers50b35e22012-10-04 10:09:15 -07002504 klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
Jesse Wilson95caa792011-10-12 18:14:17 -04002505
Ian Rogers466bb252011-10-14 03:29:56 -07002506 // Create virtual method using specified prototypes
Jesse Wilson95caa792011-10-12 18:14:17 -04002507 size_t num_virtual_methods = methods->GetLength();
Ian Rogers4445a7e2012-10-05 17:19:13 -07002508 klass->SetVirtualMethods(AllocMethodArray(self, num_virtual_methods));
Jesse Wilson95caa792011-10-12 18:14:17 -04002509 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002510 SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
Ian Rogers50b35e22012-10-04 10:09:15 -07002511 klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
Jesse Wilson95caa792011-10-12 18:14:17 -04002512 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002513
2514 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002515 klass->SetStatus(mirror::Class::kStatusLoaded); // Class is now effectively in the loaded state
Ian Rogers62d6c772013-02-27 08:32:07 -08002516 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08002517
2518 // Link the fields and virtual methods, creating vtable and iftables
2519 if (!LinkClass(klass, interfaces)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002520 klass->SetStatus(mirror::Class::kStatusError);
Jesse Wilson95caa792011-10-12 18:14:17 -04002521 return NULL;
2522 }
Ian Rogersc8982582012-09-07 16:53:25 -07002523 {
Ian Rogers1f539342012-10-03 21:09:42 -07002524 ObjectLock lock(self, klass.get()); // Must hold lock on object when initializing.
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002525 interfaces_sfield->SetObject(klass.get(), interfaces);
2526 throws_sfield->SetObject(klass.get(), throws);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002527 klass->SetStatus(mirror::Class::kStatusInitialized);
Ian Rogersc8982582012-09-07 16:53:25 -07002528 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002529
2530 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002531 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002532 CHECK(klass->GetIFields() == NULL);
2533 CheckProxyConstructor(klass->GetDirectMethod(0));
2534 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002535 SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002536 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2537 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002538
2539 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
2540 name->ToModifiedUtf8().c_str()));
2541 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2542
2543 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
2544 name->ToModifiedUtf8().c_str()));
2545 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002546
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002547 mirror::SynthesizedProxyClass* synth_proxy_class =
2548 down_cast<mirror::SynthesizedProxyClass*>(klass.get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002549 CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
Ian Rogersc2b44472011-12-14 21:17:17 -08002550 CHECK_EQ(synth_proxy_class->GetThrows(), throws);
2551 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002552 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002553}
2554
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002555std::string ClassLinker::GetDescriptorForProxy(const mirror::Class* proxy_class) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002556 DCHECK(proxy_class->IsProxyClass());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002557 mirror::String* name = proxy_class->GetName();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002558 DCHECK(name != NULL);
2559 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2560}
2561
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002562mirror::AbstractMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
2563 const mirror::AbstractMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002564 DCHECK(proxy_class->IsProxyClass());
2565 DCHECK(proxy_method->IsProxyMethod());
2566 // Locate the dex cache of the original interface/Object
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002567 mirror::DexCache* dex_cache = NULL;
Ian Rogers16f93672012-02-14 12:29:06 -08002568 {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002569 mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002570 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002571 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2572 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2573 dex_cache = dex_caches_[i];
2574 break;
2575 }
2576 }
2577 }
2578 CHECK(dex_cache != NULL);
2579 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002580 mirror::AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002581 CHECK(resolved_method != NULL);
2582 return resolved_method;
2583}
2584
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002585
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002586mirror::AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self,
2587 SirtRef<mirror::Class>& klass,
2588 mirror::Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002589 // Create constructor for Proxy that must initialize h
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002590 mirror::ObjectArray<mirror::AbstractMethod>* proxy_direct_methods =
2591 proxy_class->GetDirectMethods();
Jesse Wilsonecbce8f2011-10-21 19:57:36 -04002592 CHECK_EQ(proxy_direct_methods->GetLength(), 15);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002593 mirror::AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002594 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2595 // code_ too)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002596 mirror::AbstractMethod* constructor =
2597 down_cast<mirror::AbstractMethod*>(proxy_constructor->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002598 // Make this constructor public and fix the class to be our Proxy version
2599 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002600 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002601 return constructor;
2602}
2603
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002604static void CheckProxyConstructor(mirror::AbstractMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002605 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002606 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002607 MethodHelper mh(constructor);
2608 CHECK_STREQ(mh.GetName(), "<init>");
Elliott Hughesba8eee12012-01-24 20:25:24 -08002609 CHECK_EQ(mh.GetSignature(), std::string("(Ljava/lang/reflect/InvocationHandler;)V"));
Ian Rogers466bb252011-10-14 03:29:56 -07002610 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002611}
2612
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002613mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
2614 SirtRef<mirror::AbstractMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002615 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2616 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002617 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2618 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002619 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07002620 // as necessary
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002621 mirror::AbstractMethod* method = down_cast<mirror::AbstractMethod*>(prototype->Clone(self));
Ian Rogers466bb252011-10-14 03:29:56 -07002622
2623 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
2624 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002625 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07002626 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002627
Ian Rogers466bb252011-10-14 03:29:56 -07002628 // At runtime the method looks like a reference and argument saving method, clone the code
2629 // related parameters from this method.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002630 mirror::AbstractMethod* refs_and_args =
2631 Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07002632 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
2633 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
2634 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
Ian Rogers848871b2013-08-05 10:56:33 -07002635 method->SetEntryPointFromCompiledCode(GetProxyInvokeHandler());
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07002636 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Ian Rogers16f93672012-02-14 12:29:06 -08002637
Ian Rogersc2b44472011-12-14 21:17:17 -08002638 return method;
2639}
Jesse Wilson95caa792011-10-12 18:14:17 -04002640
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002641static void CheckProxyMethod(mirror::AbstractMethod* method,
2642 SirtRef<mirror::AbstractMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002643 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002644 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002645 CHECK(!prototype->IsFinal());
2646 CHECK(method->IsFinal());
2647 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08002648
2649 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
2650 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
2651 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
2652 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
2653 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
2654 CHECK_EQ(prototype->GetDexCacheInitializedStaticStorage(),
2655 method->GetDexCacheInitializedStaticStorage());
2656 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
2657
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002658 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08002659 MethodHelper mh2(prototype.get());
2660 CHECK_STREQ(mh.GetName(), mh2.GetName());
2661 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07002662 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08002663 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04002664}
2665
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002666bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002667 CHECK(klass->IsResolved() || klass->IsErroneous())
Ian Rogers9ffb0392012-09-10 11:56:50 -07002668 << PrettyClass(klass) << ": state=" << klass->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002669
Carl Shapirob5573532011-07-12 18:22:59 -07002670 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002671
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002672 mirror::AbstractMethod* clinit = NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002673 {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002674 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
Ian Rogers1f539342012-10-03 21:09:42 -07002675 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002676
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002677 if (klass->GetStatus() == mirror::Class::kStatusInitialized) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002678 return true;
2679 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002680
Brian Carlstromd1422f82011-09-28 11:37:09 -07002681 if (klass->IsErroneous()) {
2682 ThrowEarlierClassFailure(klass);
2683 return false;
2684 }
2685
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002686 if (klass->GetStatus() == mirror::Class::kStatusResolved ||
2687 klass->GetStatus() == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao98eacac2011-09-14 16:11:53 -07002688 VerifyClass(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002689 if (klass->GetStatus() != mirror::Class::kStatusVerified) {
2690 if (klass->GetStatus() == mirror::Class::kStatusError) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07002691 CHECK(self->IsExceptionPending());
2692 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002693 return false;
2694 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002695 }
2696
Brian Carlstrom25c33252011-09-18 15:58:35 -07002697 clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
2698 if (clinit != NULL && !can_run_clinit) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002699 // if the class has a <clinit> but we can't run it during compilation,
Ian Rogers1bddec32012-02-04 12:27:34 -08002700 // don't bother going to kStatusInitializing. We return false so that
2701 // sub-classes don't believe this class is initialized.
Ian Rogers19846512012-02-24 11:42:47 -08002702 // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
2703 // in second pass.
Ian Rogers1bddec32012-02-04 12:27:34 -08002704 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002705 }
2706
Brian Carlstromd1422f82011-09-28 11:37:09 -07002707 // If the class is kStatusInitializing, either this thread is
2708 // initializing higher up the stack or another thread has beat us
2709 // to initializing and we need to wait. Either way, this
2710 // invocation of InitializeClass will not be responsible for
2711 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002712 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07002713 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07002714 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002715 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002716 return true;
2717 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002718 // No. That's fine. Wait for another thread to finish initializing.
2719 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002720 }
2721
2722 if (!ValidateSuperClassDescriptors(klass)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002723 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002724 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002725 return false;
2726 }
2727
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002728 DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002729
Elliott Hughesdcc24742011-09-07 14:02:44 -07002730 klass->SetClinitThreadId(self->GetTid());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002731 klass->SetStatus(mirror::Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002732 }
2733
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002734 uint64_t t0 = NanoTime();
2735
Ian Rogers0045a292012-03-31 21:08:41 -07002736 if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002737 // Super class initialization failed, this can be because we can't run
2738 // super-class class initializers in which case we'll be verified.
2739 // Otherwise this class is erroneous.
2740 if (!can_run_clinit) {
2741 CHECK(klass->IsVerified());
2742 } else {
2743 CHECK(klass->IsErroneous());
2744 }
Ian Rogers3d1548d2012-09-24 14:08:03 -07002745 // Signal to any waiting threads that saw this class as initializing.
Ian Rogers1f539342012-10-03 21:09:42 -07002746 ObjectLock lock(self, klass);
Ian Rogers3d1548d2012-09-24 14:08:03 -07002747 lock.NotifyAll();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002748 return false;
2749 }
2750
Ian Rogers0045a292012-03-31 21:08:41 -07002751 bool has_static_field_initializers = InitializeStaticFields(klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002752
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002753 if (clinit != NULL) {
Ian Rogers64b6d142012-10-29 16:34:15 -07002754 if (Runtime::Current()->IsStarted()) {
Jeff Hao5d917302013-02-27 17:57:33 -08002755 JValue result;
Jeff Hao6474d192013-03-26 14:08:09 -07002756 clinit->Invoke(self, NULL, 0, &result, 'V');
Ian Rogers64b6d142012-10-29 16:34:15 -07002757 } else {
Jeff Hao6474d192013-03-26 14:08:09 -07002758 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
Ian Rogers64b6d142012-10-29 16:34:15 -07002759 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002760 }
2761
Ian Rogers19846512012-02-24 11:42:47 -08002762 FixupStaticTrampolines(klass);
2763
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002764 uint64_t t1 = NanoTime();
2765
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002766 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002767 {
Ian Rogers1f539342012-10-03 21:09:42 -07002768 ObjectLock lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002769
2770 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002771 WrapExceptionInInitializer();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002772 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002773 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002774 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07002775 RuntimeStats* global_stats = Runtime::Current()->GetStats();
2776 RuntimeStats* thread_stats = self->GetStats();
2777 ++global_stats->class_init_count;
2778 ++thread_stats->class_init_count;
2779 global_stats->class_init_time_ns += (t1 - t0);
2780 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogers0045a292012-03-31 21:08:41 -07002781 // Set the class as initialized except if we can't initialize static fields and static field
2782 // initialization is necessary.
2783 if (!can_init_statics && has_static_field_initializers) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002784 klass->SetStatus(mirror::Class::kStatusVerified); // Don't leave class in initializing state.
Ian Rogers0045a292012-03-31 21:08:41 -07002785 success = false;
2786 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002787 klass->SetStatus(mirror::Class::kStatusInitialized);
Ian Rogers0045a292012-03-31 21:08:41 -07002788 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002789 if (VLOG_IS_ON(class_linker)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002790 ClassHelper kh(klass);
2791 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08002792 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002793 }
2794 lock.NotifyAll();
2795 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08002796 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002797}
2798
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002799bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002800 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002801 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002802 self->AssertNoPendingException();
Ian Rogers05f30572013-02-20 12:13:11 -08002803 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07002804
2805 // When we wake up, repeat the test for init-in-progress. If
2806 // there's an exception pending (only possible if
2807 // "interruptShouldThrow" was set), bail out.
2808 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07002809 WrapExceptionInInitializer();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002810 klass->SetStatus(mirror::Class::kStatusError);
Brian Carlstromd1422f82011-09-28 11:37:09 -07002811 return false;
2812 }
2813 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002814 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07002815 continue;
2816 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002817 if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07002818 // Compile time initialization failed.
2819 return false;
2820 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07002821 if (klass->IsErroneous()) {
2822 // The caller wants an exception, but it was thrown in a
2823 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07002824 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002825 PrettyDescriptor(klass).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07002826 return false;
2827 }
2828 if (klass->IsInitialized()) {
2829 return true;
2830 }
2831 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass) << " is " << klass->GetStatus();
2832 }
2833 LOG(FATAL) << "Not Reached" << PrettyClass(klass);
2834}
2835
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002836bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002837 if (klass->IsInterface()) {
2838 return true;
2839 }
2840 // begin with the methods local to the superclass
2841 if (klass->HasSuperClass() &&
2842 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002843 const mirror::Class* super = klass->GetSuperClass();
Ian Rogers595799e2012-01-11 17:32:51 -08002844 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002845 const mirror::AbstractMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08002846 if (method != super->GetVTable()->Get(i) &&
2847 !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002848 ThrowLinkageError(klass, "Class %s method %s resolves differently in superclass %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002849 PrettyDescriptor(klass).c_str(), PrettyMethod(method).c_str(),
2850 PrettyDescriptor(super).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002851 return false;
2852 }
2853 }
2854 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002855 mirror::IfTable* iftable = klass->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002856 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002857 mirror::Class* interface = iftable->GetInterface(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002858 if (klass->GetClassLoader() != interface->GetClassLoader()) {
2859 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002860 const mirror::AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
Ian Rogers595799e2012-01-11 17:32:51 -08002861 if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
2862 method->GetDeclaringClass())) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002863 ThrowLinkageError(klass, "Class %s method %s resolves differently in interface %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002864 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
2865 PrettyMethod(method).c_str(),
2866 PrettyDescriptor(interface).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002867 return false;
2868 }
2869 }
2870 }
2871 }
2872 return true;
2873}
2874
Ian Rogers595799e2012-01-11 17:32:51 -08002875// Returns true if classes referenced by the signature of the method are the
2876// same classes in klass1 as they are in klass2.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002877bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
2878 const mirror::Class* klass1,
2879 const mirror::Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07002880 if (klass1 == klass2) {
2881 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07002882 }
Ian Rogers4445a7e2012-10-05 17:19:13 -07002883 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002884 const DexFile::ProtoId& proto_id =
2885 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07002886 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
2887 const char* descriptor = it.GetDescriptor();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002888 if (descriptor == NULL) {
2889 break;
2890 }
2891 if (descriptor[0] == 'L' || descriptor[0] == '[') {
2892 // Found a non-primitive type.
Ian Rogers595799e2012-01-11 17:32:51 -08002893 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002894 return false;
2895 }
2896 }
2897 }
2898 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002899 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002900 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers595799e2012-01-11 17:32:51 -08002901 if (!IsSameDescriptorInDifferentClassContexts(descriptor, klass1, klass2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002902 return false;
2903 }
2904 }
2905 return true;
2906}
2907
Ian Rogers595799e2012-01-11 17:32:51 -08002908// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
2909bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002910 const mirror::Class* klass1,
2911 const mirror::Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002912 CHECK(descriptor != NULL);
2913 CHECK(klass1 != NULL);
2914 CHECK(klass2 != NULL);
Ian Rogers9074b992011-10-26 17:41:55 -07002915 if (klass1 == klass2) {
2916 return true;
2917 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002918 mirror::Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002919 if (found1 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -07002920 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002921 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002922 mirror::Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
Ian Rogers595799e2012-01-11 17:32:51 -08002923 if (found2 == NULL) {
2924 Thread::Current()->ClearException();
2925 }
2926 return found1 == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002927}
2928
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002929bool ClassLinker::InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002930 CHECK(klass != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002931 if (!klass->IsInterface() && klass->HasSuperClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002932 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers9ffb0392012-09-10 11:56:50 -07002933 if (!super_class->IsInitialized()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002934 CHECK(!super_class->IsInterface());
Ian Rogers1f539342012-10-03 21:09:42 -07002935 // Must hold lock on object when initializing and setting status.
Ian Rogers05f30572013-02-20 12:13:11 -08002936 Thread* self = Thread::Current();
2937 ObjectLock lock(self, klass);
Ian Rogers0045a292012-03-31 21:08:41 -07002938 bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002939 // TODO: check for a pending exception
2940 if (!super_initialized) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002941 if (!can_run_clinit) {
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002942 // Don't set status to error when we can't run <clinit>.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002943 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusInitializing) << PrettyClass(klass);
2944 klass->SetStatus(mirror::Class::kStatusVerified);
Brian Carlstrom4d9716c2012-01-30 01:49:33 -08002945 return false;
Brian Carlstrom25c33252011-09-18 15:58:35 -07002946 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002947 klass->SetStatus(mirror::Class::kStatusError);
Ian Rogers05f30572013-02-20 12:13:11 -08002948 klass->NotifyAll(self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002949 return false;
2950 }
2951 }
2952 }
2953 return true;
2954}
2955
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002956bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields) {
Mathieu Chartier155dfe92012-10-09 14:24:49 -07002957 DCHECK(c != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002958 if (c->IsInitialized()) {
2959 return true;
2960 }
2961
Elliott Hughes5f791332011-09-15 17:45:30 -07002962 Thread* self = Thread::Current();
Elliott Hughes34e06962012-04-09 13:55:55 -07002963 ScopedThreadStateChange tsc(self, kRunnable);
Ian Rogers0045a292012-03-31 21:08:41 -07002964 bool success = InitializeClass(c, can_run_clinit, can_init_fields);
Ian Rogers595799e2012-01-11 17:32:51 -08002965 if (!success) {
Ian Rogers1bddec32012-02-04 12:27:34 -08002966 CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
Ian Rogers595799e2012-01-11 17:32:51 -08002967 }
2968 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07002969}
2970
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002971void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002972 mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map) {
2973 mirror::ClassLoader* cl = c->GetClassLoader();
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002974 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07002975 ClassDataItemIterator it(dex_file, class_data);
2976 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002977 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), c->GetDexCache(), cl, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002978 }
2979}
2980
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002981bool ClassLinker::InitializeStaticFields(mirror::Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002982 size_t num_static_fields = klass->NumStaticFields();
2983 if (num_static_fields == 0) {
Ian Rogers0045a292012-03-31 21:08:41 -07002984 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002985 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002986 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002987 // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
Brian Carlstromf615a612011-07-23 12:50:34 -07002988 if (dex_cache == NULL) {
Ian Rogers0045a292012-03-31 21:08:41 -07002989 return false;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07002990 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002991 ClassHelper kh(klass);
2992 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
Brian Carlstromf615a612011-07-23 12:50:34 -07002993 CHECK(dex_class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002994 const DexFile& dex_file = kh.GetDexFile();
Brian Carlstrom88f36542012-10-16 23:24:21 -07002995 EncodedStaticFieldValueIterator it(dex_file, dex_cache, klass->GetClassLoader(),
2996 this, *dex_class_def);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07002997
Ian Rogers0571d352011-11-03 19:51:38 -07002998 if (it.HasNext()) {
2999 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003000 SafeMap<uint32_t, mirror::Field*> field_map;
Ian Rogers0571d352011-11-03 19:51:38 -07003001 ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
3002 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07003003 it.ReadValueToField(field_map.Get(i));
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003004 }
Ian Rogers0045a292012-03-31 21:08:41 -07003005 return true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003006 }
Ian Rogers0045a292012-03-31 21:08:41 -07003007 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003008}
3009
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003010bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
3011 mirror::ObjectArray<mirror::Class>* interfaces) {
3012 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003013 if (!LinkSuperClass(klass)) {
3014 return false;
3015 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003016 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003017 return false;
3018 }
3019 if (!LinkInstanceFields(klass)) {
3020 return false;
3021 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07003022 if (!LinkStaticFields(klass)) {
3023 return false;
3024 }
3025 CreateReferenceInstanceOffsets(klass);
3026 CreateReferenceStaticOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003027 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
3028 klass->SetStatus(mirror::Class::kStatusResolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003029 return true;
3030}
3031
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003032bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file) {
3033 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003034 StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
3035 const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
Ian Rogerscab01012012-01-10 17:35:46 -08003036 CHECK(class_def != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003037 uint16_t super_class_idx = class_def->superclass_idx_;
3038 if (super_class_idx != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003039 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003040 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003041 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003042 return false;
3043 }
Ian Rogersbe125a92012-01-11 15:19:49 -08003044 // Verify
3045 if (!klass->CanAccess(super_class)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003046 ThrowIllegalAccessError(klass.get(), "Class %s extended by class %s is inaccessible",
3047 PrettyDescriptor(super_class).c_str(),
3048 PrettyDescriptor(klass.get()).c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08003049 return false;
3050 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003051 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003052 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003053 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
3054 if (interfaces != NULL) {
3055 for (size_t i = 0; i < interfaces->Size(); i++) {
3056 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003057 mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003058 if (interface == NULL) {
3059 DCHECK(Thread::Current()->IsExceptionPending());
3060 return false;
3061 }
3062 // Verify
3063 if (!klass->CanAccess(interface)) {
3064 // TODO: the RI seemed to ignore this in my testing.
Ian Rogers62d6c772013-02-27 08:32:07 -08003065 ThrowIllegalAccessError(klass.get(), "Interface %s implemented by class %s is inaccessible",
3066 PrettyDescriptor(interface).c_str(),
3067 PrettyDescriptor(klass.get()).c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003068 return false;
3069 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003070 }
3071 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003072 // Mark the class as loaded.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003073 klass->SetStatus(mirror::Class::kStatusLoaded);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003074 return true;
3075}
3076
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003077bool ClassLinker::LinkSuperClass(SirtRef<mirror::Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003078 CHECK(!klass->IsPrimitive());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003079 mirror::Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003080 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003081 if (super != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003082 ThrowClassFormatError(klass.get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003083 return false;
3084 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003085 return true;
3086 }
3087 if (super == NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003088 ThrowLinkageError(klass.get(), "No superclass defined for class %s",
3089 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003090 return false;
3091 }
3092 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003093 if (super->IsFinal() || super->IsInterface()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003094 ThrowIncompatibleClassChangeError(klass.get(), "Superclass %s of %s is %s",
3095 PrettyDescriptor(super).c_str(),
3096 PrettyDescriptor(klass.get()).c_str(),
3097 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003098 return false;
3099 }
3100 if (!klass->CanAccess(super)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003101 ThrowIllegalAccessError(klass.get(), "Superclass %s is inaccessible to class %s",
3102 PrettyDescriptor(super).c_str(),
3103 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003104 return false;
3105 }
Elliott Hughes20cde902011-10-04 17:37:27 -07003106
3107 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3108 if (super->IsFinalizable()) {
3109 klass->SetFinalizable();
3110 }
3111
Elliott Hughes2da50362011-10-10 16:57:08 -07003112 // Inherit reference flags (if any) from the superclass.
3113 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3114 if (reference_flags != 0) {
3115 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3116 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003117 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07003118 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003119 ThrowLinkageError(klass.get(),
3120 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
3121 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003122 return false;
3123 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003124
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003125#ifndef NDEBUG
3126 // Ensure super classes are fully resolved prior to resolving fields..
3127 while (super != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003128 CHECK(super->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003129 super = super->GetSuperClass();
3130 }
3131#endif
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003132 return true;
3133}
3134
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003135// Populate the class vtable and itable. Compute return type indices.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003136bool ClassLinker::LinkMethods(SirtRef<mirror::Class>& klass,
3137 mirror::ObjectArray<mirror::Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003138 if (klass->IsInterface()) {
3139 // No vtable.
3140 size_t count = klass->NumVirtualMethods();
3141 if (!IsUint(16, count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003142 ThrowClassFormatError(klass.get(), "Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003143 return false;
3144 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003145 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003146 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003147 }
jeffhaobdb76512011-09-07 11:43:16 -07003148 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003149 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003150 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003151 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003152 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003153 }
3154 return true;
3155}
3156
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003157bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003158 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003159 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003160 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3161 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003162 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003163 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003164 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003165 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003166 // See if any of our virtual methods override the superclass.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003167 MethodHelper local_mh(NULL, this);
3168 MethodHelper super_mh(NULL, this);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003169 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003170 mirror::AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003171 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003172 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003173 for (; j < actual_count; ++j) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003174 mirror::AbstractMethod* super_method = vtable->Get(j);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003175 super_mh.ChangeMethod(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003176 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3177 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3178 if (super_method->IsFinal()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003179 ThrowLinkageError(klass.get(), "Method %s overrides final method in class %s",
Elliott Hughes39717372012-07-13 16:21:23 -07003180 PrettyMethod(local_method).c_str(),
3181 super_mh.GetDeclaringClassDescriptor());
3182 return false;
3183 }
3184 vtable->Set(j, local_method);
3185 local_method->SetMethodIndex(j);
3186 break;
3187 } else {
3188 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3189 << " would have incorrectly overridden the package-private method in "
3190 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003191 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003192 }
3193 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003194 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003195 // Not overriding, append.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003196 vtable->Set(actual_count, local_method);
3197 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003198 actual_count += 1;
3199 }
3200 }
3201 if (!IsUint(16, actual_count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003202 ThrowClassFormatError(klass.get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003203 return false;
3204 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003205 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003206 CHECK_LE(actual_count, max_count);
3207 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003208 vtable.reset(vtable->CopyOf(self, actual_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003209 }
Ian Rogers30fab402012-01-23 15:43:46 -08003210 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003211 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003212 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003213 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003214 if (!IsUint(16, num_virtual_methods)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003215 ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003216 return false;
3217 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003218 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
Ian Rogers4445a7e2012-10-05 17:19:13 -07003219 vtable(self, AllocMethodArray(self, num_virtual_methods));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003220 for (size_t i = 0; i < num_virtual_methods; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003221 mirror::AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003222 vtable->Set(i, virtual_method);
3223 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003224 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003225 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003226 }
3227 return true;
3228}
3229
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003230bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
3231 mirror::ObjectArray<mirror::Class>* interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003232 size_t super_ifcount;
3233 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003234 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003235 } else {
3236 super_ifcount = 0;
3237 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003238 size_t ifcount = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003239 ClassHelper kh(klass.get(), this);
Ian Rogersd24e2642012-06-06 21:21:43 -07003240 uint32_t num_interfaces = interfaces == NULL ? kh.NumDirectInterfaces() : interfaces->GetLength();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003241 ifcount += num_interfaces;
3242 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003243 mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003244 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003245 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003246 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003247 // Class implements no interfaces.
3248 DCHECK_EQ(klass->GetIfTableCount(), 0);
3249 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003250 return true;
3251 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003252 if (ifcount == super_ifcount) {
3253 // Class implements same interfaces as parent, are any of these not marker interfaces?
3254 bool has_non_marker_interface = false;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003255 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Ian Rogers9bc81912012-10-11 21:43:36 -07003256 for (size_t i = 0; i < ifcount; ++i) {
3257 if (super_iftable->GetMethodArrayCount(i) > 0) {
3258 has_non_marker_interface = true;
3259 break;
3260 }
3261 }
3262 if (!has_non_marker_interface) {
3263 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3264 klass->SetIfTable(super_iftable);
3265 return true;
3266 }
3267 }
Ian Rogers1f539342012-10-03 21:09:42 -07003268 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003269 SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003270 if (super_ifcount != 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003271 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003272 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003273 mirror::Class* super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003274 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003275 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003276 }
3277 // Flatten the interface inheritance hierarchy.
3278 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003279 for (size_t i = 0; i < num_interfaces; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003280 mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003281 DCHECK(interface != NULL);
3282 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003283 ClassHelper ih(interface);
Ian Rogers62d6c772013-02-27 08:32:07 -08003284 ThrowIncompatibleClassChangeError(klass.get(), "Class %s implements non-interface class %s",
3285 PrettyDescriptor(klass.get()).c_str(),
3286 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003287 return false;
3288 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003289 // Check if interface is already in iftable
3290 bool duplicate = false;
3291 for (size_t j = 0; j < idx; j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003292 mirror::Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003293 if (existing_interface == interface) {
3294 duplicate = true;
3295 break;
3296 }
3297 }
3298 if (!duplicate) {
3299 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003300 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003301 // Add this interface's non-duplicate super-interfaces.
3302 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003303 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003304 bool super_duplicate = false;
3305 for (size_t k = 0; k < idx; k++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003306 mirror::Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003307 if (existing_interface == super_interface) {
3308 super_duplicate = true;
3309 break;
3310 }
3311 }
3312 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003313 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003314 }
3315 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003316 }
3317 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003318 // Shrink iftable in case duplicates were found
3319 if (idx < ifcount) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003320 iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
Ian Rogersb52b01a2012-01-12 17:01:38 -08003321 ifcount = idx;
3322 } else {
3323 CHECK_EQ(idx, ifcount);
3324 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003325 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003326
3327 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003328 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003329 return true;
3330 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003331 std::vector<mirror::AbstractMethod*> miranda_list;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003332 MethodHelper vtable_mh(NULL, this);
3333 MethodHelper interface_mh(NULL, this);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003334 for (size_t i = 0; i < ifcount; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003335 mirror::Class* interface = iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003336 size_t num_methods = interface->NumVirtualMethods();
3337 if (num_methods > 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003338 mirror::ObjectArray<mirror::AbstractMethod>* method_array =
3339 AllocMethodArray(self, num_methods);
Ian Rogers9bc81912012-10-11 21:43:36 -07003340 iftable->SetMethodArray(i, method_array);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003341 mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
Ian Rogers62d6c772013-02-27 08:32:07 -08003342 for (size_t j = 0; j < num_methods; ++j) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003343 mirror::AbstractMethod* interface_method = interface->GetVirtualMethod(j);
Ian Rogers9bc81912012-10-11 21:43:36 -07003344 interface_mh.ChangeMethod(interface_method);
3345 int32_t k;
3346 // For each method listed in the interface's method list, find the
3347 // matching method in our class's method list. We want to favor the
3348 // subclass over the superclass, which just requires walking
3349 // back from the end of the vtable. (This only matters if the
3350 // superclass defines a private method and this class redefines
3351 // it -- otherwise it would use the same vtable slot. In .dex files
3352 // those don't end up in the virtual method table, so it shouldn't
3353 // matter which direction we go. We walk it backward anyway.)
3354 for (k = vtable->GetLength() - 1; k >= 0; --k) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003355 mirror::AbstractMethod* vtable_method = vtable->Get(k);
Ian Rogers9bc81912012-10-11 21:43:36 -07003356 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003357 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Elliott Hughes68243612013-02-22 17:16:07 -08003358 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003359 ThrowIllegalAccessError(klass.get(),
3360 "Method '%s' implementing interface method '%s' is not public",
3361 PrettyMethod(vtable_method).c_str(),
3362 PrettyMethod(interface_method).c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07003363 return false;
3364 }
3365 method_array->Set(j, vtable_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003366 break;
3367 }
3368 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003369 if (k < 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003370 SirtRef<mirror::AbstractMethod> miranda_method(self, NULL);
Ian Rogers9bc81912012-10-11 21:43:36 -07003371 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003372 mirror::AbstractMethod* mir_method = miranda_list[mir];
Ian Rogers9bc81912012-10-11 21:43:36 -07003373 vtable_mh.ChangeMethod(mir_method);
3374 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3375 miranda_method.reset(miranda_list[mir]);
3376 break;
3377 }
3378 }
3379 if (miranda_method.get() == NULL) {
3380 // point the interface table at a phantom slot
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003381 miranda_method.reset(down_cast<mirror::AbstractMethod*>(interface_method->Clone(self)));
Ian Rogers9bc81912012-10-11 21:43:36 -07003382 miranda_list.push_back(miranda_method.get());
3383 }
3384 method_array->Set(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003385 }
3386 }
3387 }
3388 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003389 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003390 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003391 int new_method_count = old_method_count + miranda_list.size();
Brian Carlstrom27ec9612011-09-19 20:20:38 -07003392 klass->SetVirtualMethods((old_method_count == 0)
Ian Rogers4445a7e2012-10-05 17:19:13 -07003393 ? AllocMethodArray(self, new_method_count)
Ian Rogers50b35e22012-10-04 10:09:15 -07003394 : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003395
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003396 SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
3397 vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003398 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003399 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003400 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003401 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Elliott Hughes4681c802011-09-25 18:04:37 -07003402 for (size_t i = 0; i < miranda_list.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003403 mirror::AbstractMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003404 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003405 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3406 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3407 klass->SetVirtualMethod(old_method_count + i, method);
3408 vtable->Set(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003409 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003410 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003411 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003412 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003413
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003414 mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003415 for (int i = 0; i < vtable->GetLength(); ++i) {
3416 CHECK(vtable->Get(i) != NULL);
3417 }
3418
3419// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3420
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003421 return true;
3422}
3423
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003424bool ClassLinker::LinkInstanceFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003425 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003426 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003427}
3428
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003429bool ClassLinker::LinkStaticFields(SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003430 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003431 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003432 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003433 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003434 return success;
3435}
3436
Brian Carlstromdbc05252011-09-09 01:59:59 -07003437struct LinkFieldsComparator {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003438 explicit LinkFieldsComparator(FieldHelper* fh)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003439 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003440 : fh_(fh) {}
3441 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003442 bool operator()(const mirror::Field* field1, const mirror::Field* field2)
3443 NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003444 // First come reference fields, then 64-bit, and finally 32-bit
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003445 fh_->ChangeField(field1);
3446 Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
3447 fh_->ChangeField(field2);
3448 Primitive::Type type2 = fh_->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003449 bool isPrimitive1 = type1 != Primitive::kPrimNot;
3450 bool isPrimitive2 = type2 != Primitive::kPrimNot;
3451 bool is64bit1 = isPrimitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3452 bool is64bit2 = isPrimitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003453 int order1 = (!isPrimitive1 ? 0 : (is64bit1 ? 1 : 2));
3454 int order2 = (!isPrimitive2 ? 0 : (is64bit2 ? 1 : 2));
3455 if (order1 != order2) {
3456 return order1 < order2;
3457 }
3458
3459 // same basic group? then sort by string.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003460 fh_->ChangeField(field1);
3461 StringPiece name1(fh_->GetName());
3462 fh_->ChangeField(field2);
3463 StringPiece name2(fh_->GetName());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003464 return name1 < name2;
3465 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003466
3467 FieldHelper* fh_;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003468};
3469
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003470bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003471 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003472 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003473
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003474 mirror::ObjectArray<mirror::Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003475 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003476
3477 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003478 size_t size;
3479 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003480 if (is_static) {
3481 size = klass->GetClassSize();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003482 field_offset = mirror::Class::FieldsOffset();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003483 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003484 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003485 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003486 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003487 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003488 }
3489 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003490 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003491
Brian Carlstromdbc05252011-09-09 01:59:59 -07003492 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003493
Brian Carlstromdbc05252011-09-09 01:59:59 -07003494 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003495 // minimizes disruption of C++ version such as Class and Method.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003496 std::deque<mirror::Field*> grouped_and_sorted_fields;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003497 for (size_t i = 0; i < num_fields; i++) {
3498 grouped_and_sorted_fields.push_back(fields->Get(i));
3499 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003500 FieldHelper fh(NULL, this);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003501 std::sort(grouped_and_sorted_fields.begin(),
3502 grouped_and_sorted_fields.end(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003503 LinkFieldsComparator(&fh));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003504
3505 // References should be at the front.
3506 size_t current_field = 0;
3507 size_t num_reference_fields = 0;
3508 for (; current_field < num_fields; current_field++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003509 mirror::Field* field = grouped_and_sorted_fields.front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003510 fh.ChangeField(field);
3511 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003512 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003513 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003514 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003515 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003516 grouped_and_sorted_fields.pop_front();
3517 num_reference_fields++;
3518 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003519 field->SetOffset(field_offset);
3520 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003521 }
3522
3523 // Now we want to pack all of the double-wide fields together. If
3524 // we're not aligned, though, we want to shuffle one 32-bit field
3525 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003526 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003527 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003528 mirror::Field* field = grouped_and_sorted_fields[i];
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003529 fh.ChangeField(field);
3530 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003531 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
3532 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003533 continue;
3534 }
3535 fields->Set(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003536 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003537 // drop the consumed field
3538 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
3539 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003540 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003541 // whether we found a 32-bit field for padding or not, we advance
3542 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003543 }
3544
3545 // Alignment is good, shuffle any double-wide fields forward, and
3546 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07003547 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07003548 while (!grouped_and_sorted_fields.empty()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003549 mirror::Field* field = grouped_and_sorted_fields.front();
Brian Carlstromdbc05252011-09-09 01:59:59 -07003550 grouped_and_sorted_fields.pop_front();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003551 fh.ChangeField(field);
3552 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003553 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Brian Carlstromdbc05252011-09-09 01:59:59 -07003554 fields->Set(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003555 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003556 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003557 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07003558 ? sizeof(uint64_t)
3559 : sizeof(uint32_t)));
3560 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003561 }
3562
Elliott Hughesadb460d2011-10-05 17:02:34 -07003563 // 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 -07003564 if (!is_static &&
3565 StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;") {
Elliott Hughesadb460d2011-10-05 17:02:34 -07003566 // We know there are no non-reference fields in the Reference classes, and we know
3567 // that 'referent' is alphabetically last, so this is easy...
3568 CHECK_EQ(num_reference_fields, num_fields);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003569 fh.ChangeField(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08003570 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07003571 --num_reference_fields;
3572 }
3573
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003574#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07003575 // Make sure that all reference fields appear before
3576 // non-reference fields, and all double-wide fields are aligned.
3577 bool seen_non_ref = false;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003578 for (size_t i = 0; i < num_fields; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003579 mirror::Field* field = fields->Get(i);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003580 if (false) { // enable to debug field layout
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003581 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003582 << " class=" << PrettyClass(klass.get())
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003583 << " field=" << PrettyField(field)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003584 << " offset=" << field->GetField32(MemberOffset(mirror::Field::OffsetOffset()),
3585 false);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003586 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003587 fh.ChangeField(field);
3588 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003589 bool is_primitive = type != Primitive::kPrimNot;
Ian Rogers64b6d142012-10-29 16:34:15 -07003590 if (StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;" &&
3591 StringPiece(fh.GetName()) == "referent") {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003592 is_primitive = true; // We lied above, so we have to expect a lie here.
Elliott Hughesadb460d2011-10-05 17:02:34 -07003593 }
3594 if (is_primitive) {
Brian Carlstrombe977852011-07-19 14:54:54 -07003595 if (!seen_non_ref) {
3596 seen_non_ref = true;
Brian Carlstrom4873d462011-08-21 15:23:39 -07003597 DCHECK_EQ(num_reference_fields, i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003598 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003599 } else {
3600 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003601 }
3602 }
Brian Carlstrombe977852011-07-19 14:54:54 -07003603 if (!seen_non_ref) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07003604 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003605 }
3606#endif
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003607 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003608 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003609 if (is_static) {
3610 klass->SetNumReferenceStaticFields(num_reference_fields);
3611 klass->SetClassSize(size);
3612 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003613 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003614 if (!klass->IsVariableSize()) {
Brian Carlstrom62cd0982013-06-03 11:30:25 -07003615 DCHECK_GE(size, sizeof(mirror::Object)) << ClassHelper(klass.get(), this).GetDescriptor();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003616 klass->SetObjectSize(size);
3617 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003618 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003619 return true;
3620}
3621
3622// Set the bitmap of reference offsets, refOffsets, from the ifields
3623// list.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003624void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003625 uint32_t reference_offsets = 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003626 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003627 if (super_class != NULL) {
3628 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003629 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003630 if (reference_offsets == CLASS_WALK_SUPER) {
3631 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003632 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003633 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003634 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003635 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003636}
3637
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003638void ClassLinker::CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003639 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003640}
3641
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003642void ClassLinker::CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003643 uint32_t reference_offsets) {
3644 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003645 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
3646 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003647 const mirror::ObjectArray<mirror::Field>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003648 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07003649 // All of the fields that contain object references are guaranteed
3650 // to be at the beginning of the fields list.
3651 for (size_t i = 0; i < num_reference_fields; ++i) {
3652 // Note that byte_offset is the offset from the beginning of
3653 // object, not the offset into instance data
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003654 const mirror::Field* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003655 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003656 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
3657 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
3658 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003659 CHECK_NE(new_bit, 0U);
3660 reference_offsets |= new_bit;
3661 } else {
3662 reference_offsets = CLASS_WALK_SUPER;
3663 break;
3664 }
3665 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003666 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003667 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003668 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003669 } else {
3670 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003671 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003672}
3673
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003674mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
3675 uint32_t string_idx, mirror::DexCache* dex_cache) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003676 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003677 mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003678 if (resolved != NULL) {
3679 return resolved;
3680 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003681 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
3682 int32_t utf16_length = dex_file.GetStringLength(string_id);
3683 const char* utf8_data = dex_file.GetStringData(string_id);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003684 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003685 dex_cache->SetResolvedString(string_idx, string);
3686 return string;
3687}
3688
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003689mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
3690 uint16_t type_idx,
3691 mirror::DexCache* dex_cache,
3692 mirror::ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003693 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003694 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003695 if (resolved == NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07003696 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003697 resolved = FindClass(descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003698 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05003699 // TODO: we used to throw here if resolved's class loader was not the
3700 // boot class loader. This was to permit different classes with the
3701 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003702 dex_cache->SetResolvedType(type_idx, resolved);
3703 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003704 Thread* self = Thread::Current();
3705 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08003706 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08003707 // Convert a ClassNotFoundException to a NoClassDefFoundError.
3708 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
3709 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
jeffhao8cd6dda2012-02-22 10:15:34 -08003710 Thread::Current()->ClearException();
3711 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Ian Rogers62d6c772013-02-27 08:32:07 -08003712 self->GetException(NULL)->SetCause(cause.get());
jeffhao8cd6dda2012-02-22 10:15:34 -08003713 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003714 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003715 }
3716 return resolved;
3717}
3718
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003719mirror::AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
3720 uint32_t method_idx,
3721 mirror::DexCache* dex_cache,
3722 mirror::ClassLoader* class_loader,
3723 const mirror::AbstractMethod* referrer,
3724 InvokeType type) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003725 DCHECK(dex_cache != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07003726 // Check for hit in the dex cache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003727 mirror::AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003728 if (resolved != NULL) {
3729 return resolved;
3730 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003731 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003732 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003733 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003734 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07003735 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003736 return NULL;
3737 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003738 // Scan using method_idx, this saves string compares but will only hit for matching dex
3739 // caches/files.
3740 switch (type) {
3741 case kDirect: // Fall-through.
3742 case kStatic:
3743 resolved = klass->FindDirectMethod(dex_cache, method_idx);
3744 break;
3745 case kInterface:
3746 resolved = klass->FindInterfaceMethod(dex_cache, method_idx);
Ian Rogers4c5b2652012-12-15 21:36:16 -08003747 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07003748 break;
3749 case kSuper: // Fall-through.
3750 case kVirtual:
3751 resolved = klass->FindVirtualMethod(dex_cache, method_idx);
3752 break;
3753 default:
3754 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003755 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003756 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07003757 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003758 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3759 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
Ian Rogers08f753d2012-08-24 14:35:25 -07003760 switch (type) {
3761 case kDirect: // Fall-through.
3762 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08003763 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003764 break;
3765 case kInterface:
3766 resolved = klass->FindInterfaceMethod(name, signature);
Ian Rogers4c5b2652012-12-15 21:36:16 -08003767 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07003768 break;
3769 case kSuper: // Fall-through.
3770 case kVirtual:
3771 resolved = klass->FindVirtualMethod(name, signature);
3772 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003773 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003774 }
Ian Rogers08f753d2012-08-24 14:35:25 -07003775 if (resolved != NULL) {
3776 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07003777 if (resolved->CheckIncompatibleClassChange(type)) {
3778 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07003779 }
3780 }
3781 if (resolved != NULL) {
3782 // Be a good citizen and update the dex cache to speed subsequent calls.
3783 dex_cache->SetResolvedMethod(method_idx, resolved);
3784 return resolved;
3785 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07003786 // We failed to find the method which means either an access error, an incompatible class
3787 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07003788 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
3789 std::string signature(dex_file.CreateMethodSignature(method_id.proto_idx_, NULL));
3790 switch (type) {
3791 case kDirect:
3792 case kStatic:
3793 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07003794 break;
3795 case kInterface:
3796 case kVirtual:
3797 case kSuper:
3798 resolved = klass->FindDirectMethod(name, signature);
3799 break;
3800 }
3801
3802 // If we found something, check that it can be accessed by the referrer.
3803 if (resolved != NULL && referrer != NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003804 mirror::Class* methods_class = resolved->GetDeclaringClass();
3805 mirror::Class* referring_class = referrer->GetDeclaringClass();
jeffhaoc0228b82012-08-29 18:15:05 -07003806 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003807 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
3808 referrer, resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07003809 return NULL;
3810 } else if (!referring_class->CanAccessMember(methods_class,
3811 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07003812 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07003813 return NULL;
3814 }
3815 }
3816
3817 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
3818 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
3819 switch (type) {
3820 case kDirect:
3821 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07003822 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003823 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003824 } else {
3825 resolved = klass->FindInterfaceMethod(name, signature);
3826 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003827 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003828 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003829 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003830 }
3831 }
3832 break;
3833 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07003834 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003835 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003836 } else {
3837 resolved = klass->FindVirtualMethod(name, signature);
3838 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003839 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003840 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003841 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003842 }
3843 }
3844 break;
3845 case kSuper:
Ian Rogers62d6c772013-02-27 08:32:07 -08003846 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003847 break;
3848 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07003849 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003850 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003851 } else {
3852 resolved = klass->FindInterfaceMethod(name, signature);
3853 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003854 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07003855 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08003856 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07003857 }
3858 }
3859 break;
3860 }
3861 DCHECK(Thread::Current()->IsExceptionPending());
3862 return NULL;
3863 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003864}
3865
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003866mirror::Field* ClassLinker::ResolveField(const DexFile& dex_file,
3867 uint32_t field_idx,
3868 mirror::DexCache* dex_cache,
3869 mirror::ClassLoader* class_loader,
3870 bool is_static) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003871 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003872 mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003873 if (resolved != NULL) {
3874 return resolved;
3875 }
3876 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003877 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003878 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08003879 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003880 return NULL;
3881 }
3882
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003883 if (is_static) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003884 resolved = klass->FindStaticField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003885 } else {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003886 resolved = klass->FindInstanceField(dex_cache, field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07003887 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003888
3889 if (resolved == NULL) {
3890 const char* name = dex_file.GetFieldName(field_id);
3891 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3892 if (is_static) {
3893 resolved = klass->FindStaticField(name, type);
3894 } else {
3895 resolved = klass->FindInstanceField(name, type);
3896 }
3897 if (resolved == NULL) {
3898 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
3899 return NULL;
3900 }
Ian Rogersb067ac22011-12-13 18:05:09 -08003901 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08003902 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08003903 return resolved;
3904}
3905
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003906mirror::Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
3907 uint32_t field_idx,
3908 mirror::DexCache* dex_cache,
3909 mirror::ClassLoader* class_loader) {
Brian Carlstrom7d776242012-03-06 23:05:49 -08003910 DCHECK(dex_cache != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003911 mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
Ian Rogersb067ac22011-12-13 18:05:09 -08003912 if (resolved != NULL) {
3913 return resolved;
3914 }
3915 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003916 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Ian Rogersb067ac22011-12-13 18:05:09 -08003917 if (klass == NULL) {
3918 DCHECK(Thread::Current()->IsExceptionPending());
3919 return NULL;
3920 }
3921
3922 const char* name = dex_file.GetFieldName(field_id);
3923 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
3924 resolved = klass->FindField(name, type);
3925 if (resolved != NULL) {
3926 dex_cache->SetResolvedField(field_idx, resolved);
3927 } else {
3928 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003929 }
3930 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07003931}
3932
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003933const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer,
3934 uint32_t* length) {
3935 mirror::Class* declaring_class = referrer->GetDeclaringClass();
3936 mirror::DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07003937 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07003938 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08003939 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07003940}
3941
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003942void ClassLinker::DumpAllClasses(int flags) const {
3943 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
3944 // lock held, because it might need to resolve a field's type, which would try to take the lock.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003945 std::vector<mirror::Class*> all_classes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003946 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003947 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003948 typedef Table::const_iterator It; // TODO: C++0x auto
3949 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
3950 all_classes.push_back(it->second);
3951 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003952 for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
3953 all_classes.push_back(it->second);
3954 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07003955 }
3956
3957 for (size_t i = 0; i < all_classes.size(); ++i) {
3958 all_classes[i]->DumpClass(std::cerr, flags);
3959 }
3960}
3961
Elliott Hughescac6cc72011-11-03 20:31:21 -07003962void ClassLinker::DumpForSigQuit(std::ostream& os) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003963 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Elliott Hughescac6cc72011-11-03 20:31:21 -07003964 os << "Loaded classes: " << image_classes_.size() << " image classes; "
3965 << classes_.size() << " allocated classes\n";
3966}
3967
Elliott Hughese27955c2011-08-26 15:21:24 -07003968size_t ClassLinker::NumLoadedClasses() const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003969 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07003970 return classes_.size() + image_classes_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07003971}
3972
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003973pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07003974 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003975}
3976
3977pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003978 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07003979}
3980
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003981void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003982 DCHECK(!init_done_);
3983
3984 DCHECK(klass != NULL);
3985 DCHECK(klass->GetClassLoader() == NULL);
3986
3987 DCHECK(class_roots_ != NULL);
3988 DCHECK(class_roots_->Get(class_root) == NULL);
3989 class_roots_->Set(class_root, klass);
3990}
3991
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003992} // namespace art