blob: 703229c44b36339ca64e2e72ab583dfb4b70f94e [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
Brian Carlstromdbc05252011-09-09 01:59:59 -070023#include <deque>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070024#include <string>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070025#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070026#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070027
Elliott Hughes1aa246d2012-12-13 09:29:36 -080028#include "base/casts.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080029#include "base/logging.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080030#include "base/stl_util.h"
Elliott Hughes76160052012-12-12 16:31:20 -080031#include "base/unix_file/fd_file.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080032#include "class_linker-inl.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000033#include "compiler_callbacks.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080034#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070035#include "dex_file-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070036#include "gc/accounting/card_table-inl.h"
37#include "gc/accounting/heap_bitmap.h"
38#include "gc/heap.h"
39#include "gc/space/image_space.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070040#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070041#include "interpreter/interpreter.h"
Ian Rogers0571d352011-11-03 19:51:38 -070042#include "leb128.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080043#include "oat.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070044#include "oat_file.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070045#include "mirror/art_field-inl.h"
46#include "mirror/art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080047#include "mirror/class.h"
48#include "mirror/class-inl.h"
49#include "mirror/class_loader.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070050#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080051#include "mirror/iftable-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080052#include "mirror/object-inl.h"
53#include "mirror/object_array-inl.h"
54#include "mirror/proxy.h"
55#include "mirror/stack_trace_element.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080056#include "object_utils.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080057#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070058#include "runtime.h"
Ian Rogers7655f292013-07-29 11:07:13 -070059#include "entrypoints/entrypoint_utils.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -070060#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070061#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070062#include "sirt_ref.h"
Brian Carlstrom40381fb2011-10-19 14:13:40 -070063#include "stack_indirect_reference_table.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070064#include "thread.h"
Elliott Hughes54e7df12011-09-16 11:47:04 -070065#include "UniquePtr.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070066#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080067#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070068#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070069
70namespace art {
71
Ian Rogers00f7d0e2012-07-19 15:28:27 -070072static void ThrowNoClassDefFoundError(const char* fmt, ...)
73 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070074 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070075static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070076 va_list args;
77 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -080078 Thread* self = Thread::Current();
79 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
80 self->ThrowNewExceptionV(throw_location, "Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -080081 va_end(args);
82}
83
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080084static void ThrowEarlierClassFailure(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -070085 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -070086 // The class failed to initialize on a previous attempt, so we want to throw
87 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
88 // failed in verification, in which case v2 5.4.1 says we need to re-throw
89 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -070090 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
91 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
92 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -070093
Elliott Hughes5c599942012-06-13 16:45:05 -070094 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -080095 Thread* self = Thread::Current();
96 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
Elliott Hughes4a2b4172011-09-20 17:08:25 -070097 if (c->GetVerifyErrorClass() != NULL) {
98 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080099 ClassHelper ve_ch(c->GetVerifyErrorClass());
Ian Rogers62d6c772013-02-27 08:32:07 -0800100 self->ThrowNewException(throw_location, ve_ch.GetDescriptor(), PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700101 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -0800102 self->ThrowNewException(throw_location, "Ljava/lang/NoClassDefFoundError;",
103 PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700104 }
105}
106
Ian Rogers62d6c772013-02-27 08:32:07 -0800107static void WrapExceptionInInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700108 Thread* self = Thread::Current();
109 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700110
111 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
112 CHECK(cause.get() != NULL);
113
114 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700115 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
116 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700117
Elliott Hughesa4f94742012-05-29 16:28:38 -0700118 // We only wrap non-Error exceptions; an Error can just be used as-is.
119 if (!is_error) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800120 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
121 self->ThrowNewWrappedException(throw_location, "Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700122 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700123}
124
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800125static size_t Hash(const char* s) {
126 // This is the java.lang.String hashcode for convenience, not interoperability.
127 size_t hash = 0;
128 for (; *s != '\0'; ++s) {
129 hash = hash * 31 + *s;
130 }
131 return hash;
132}
133
Elliott Hughes418d20f2011-09-22 14:00:39 -0700134const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700135 "Ljava/lang/Class;",
136 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700137 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700138 "[Ljava/lang/Object;",
139 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700140 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700141 "Ljava/lang/ref/Reference;",
Brian Carlstromea46f952013-07-30 01:26:50 -0700142 "Ljava/lang/reflect/ArtField;",
143 "Ljava/lang/reflect/ArtMethod;",
Ian Rogers466bb252011-10-14 03:29:56 -0700144 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700145 "[Ljava/lang/String;",
Brian Carlstromea46f952013-07-30 01:26:50 -0700146 "[Ljava/lang/reflect/ArtField;",
147 "[Ljava/lang/reflect/ArtMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700148 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800149 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800150 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700151 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700152 "Z",
153 "B",
154 "C",
155 "D",
156 "F",
157 "I",
158 "J",
159 "S",
160 "V",
161 "[Z",
162 "[B",
163 "[C",
164 "[D",
165 "[F",
166 "[I",
167 "[J",
168 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700169 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700170};
171
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800172ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700173 // dex_lock_ is recursive as it may be used in stack dumping.
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700174 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700175 dex_cache_image_class_lookup_required_(false),
176 failed_dex_cache_class_lookups_(0),
Ian Rogers98379392014-02-24 16:53:16 -0800177 class_roots_(nullptr),
178 array_iftable_(nullptr),
179 find_array_class_cache_next_victim_(0),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700180 init_done_(false),
Mathieu Chartier893263b2014-03-04 11:07:42 -0800181 log_new_dex_caches_roots_(false),
182 log_new_class_table_roots_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700183 intern_table_(intern_table),
Ian Rogers98379392014-02-24 16:53:16 -0800184 portable_resolution_trampoline_(nullptr),
185 quick_resolution_trampoline_(nullptr),
186 portable_imt_conflict_trampoline_(nullptr),
Andreas Gampe2da88232014-02-27 12:26:20 -0800187 quick_imt_conflict_trampoline_(nullptr),
Vladimir Marko8a630572014-04-09 18:45:35 +0100188 quick_generic_jni_trampoline_(nullptr),
189 quick_to_interpreter_bridge_trampoline_(nullptr) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700190 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Ian Rogers98379392014-02-24 16:53:16 -0800191 memset(find_array_class_cache_, 0, kFindArrayCacheSize * sizeof(mirror::Class*));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700192}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700193
Brian Carlstroma004aa92012-02-08 18:05:09 -0800194void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class_path) {
195 VLOG(startup) << "ClassLinker::Init";
196 CHECK(Runtime::Current()->IsCompiler());
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700197
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700198 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700199
Elliott Hughes30646832011-10-13 16:59:46 -0700200 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700201 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700202 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700203 // The GC can't handle an object with a null class since we can't get the size of this object.
Mathieu Chartier1d27b342014-01-28 12:51:09 -0800204 heap->IncrementDisableMovingGC(self);
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800205 SirtRef<mirror::Class> java_lang_Class(self, down_cast<mirror::Class*>(
Hiroshi Yamauchi4cd662e2014-04-03 16:28:10 -0700206 heap->AllocNonMovableObject<true>(self, nullptr, sizeof(mirror::ClassClass), VoidFunctor())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700207 CHECK(java_lang_Class.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800208 mirror::Class::SetClassClass(java_lang_Class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700209 java_lang_Class->SetClass(java_lang_Class.get());
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -0700210 if (kUseBakerOrBrooksReadBarrier) {
211 java_lang_Class->AssertReadBarrierPointer();
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800212 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800213 java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
Mathieu Chartier1d27b342014-01-28 12:51:09 -0800214 heap->DecrementDisableMovingGC(self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800215 // AllocClass(mirror::Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700216
Elliott Hughes418d20f2011-09-22 14:00:39 -0700217 // Class[] is used for reflection support.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800218 SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700219 class_array_class->SetComponentType(java_lang_Class.get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700220
Ian Rogers23435d02012-09-24 11:23:12 -0700221 // java_lang_Object comes next so that object_array_class can be created.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800222 SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700223 CHECK(java_lang_Object.get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700224 // backfill Object as the super class of Class.
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700225 java_lang_Class->SetSuperClass(java_lang_Object.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700226 java_lang_Object->SetStatus(mirror::Class::kStatusLoaded, self);
Brian Carlstroma0808032011-07-18 00:39:23 -0700227
Ian Rogers23435d02012-09-24 11:23:12 -0700228 // Object[] next to hold class roots.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800229 SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700230 object_array_class->SetComponentType(java_lang_Object.get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700231
Ian Rogers23435d02012-09-24 11:23:12 -0700232 // Setup the char class to be used for char[].
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800233 SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700234
Ian Rogers23435d02012-09-24 11:23:12 -0700235 // Setup the char[] class to be used for String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800236 SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700237 char_array_class->SetComponentType(char_class.get());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800238 mirror::CharArray::SetArrayClass(char_array_class.get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700239
Ian Rogers23435d02012-09-24 11:23:12 -0700240 // Setup String.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800241 SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
242 mirror::String::SetClass(java_lang_String.get());
243 java_lang_String->SetObjectSize(sizeof(mirror::String));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700244 java_lang_String->SetStatus(mirror::Class::kStatusResolved, self);
Jesse Wilson14150742011-07-29 19:04:44 -0400245
Ian Rogers23435d02012-09-24 11:23:12 -0700246 // Create storage for root classes, save away our work so far (requires descriptors).
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800247 class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(),
248 kClassRootsMax);
Elliott Hughes30646832011-10-13 16:59:46 -0700249 CHECK(class_roots_ != NULL);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700250 SetClassRoot(kJavaLangClass, java_lang_Class.get());
251 SetClassRoot(kJavaLangObject, java_lang_Object.get());
252 SetClassRoot(kClassArrayClass, class_array_class.get());
253 SetClassRoot(kObjectArrayClass, object_array_class.get());
254 SetClassRoot(kCharArrayClass, char_array_class.get());
255 SetClassRoot(kJavaLangString, java_lang_String.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700256
257 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700258 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
259 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
260 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
261 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
262 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
263 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
264 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
265 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700266
Ian Rogers23435d02012-09-24 11:23:12 -0700267 // Create array interface entries to populate once we can load system classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700268 array_iftable_ = AllocIfTable(self, 2);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700269
Ian Rogers23435d02012-09-24 11:23:12 -0700270 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800271 SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700272 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800273 mirror::IntArray::SetArrayClass(int_array_class.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700274 SetClassRoot(kIntArrayClass, int_array_class.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700275
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700276 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700277
Ian Rogers52813c92012-10-11 11:50:38 -0700278 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800279 SirtRef<mirror::Class>
280 java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700281 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
Mathieu Chartier79b4f382013-10-23 15:21:37 -0700282 java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCache));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700283 java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700284
Mathieu Chartier66f19252012-09-18 08:57:04 -0700285 // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
Brian Carlstromea46f952013-07-30 01:26:50 -0700286 SirtRef<mirror::Class> java_lang_reflect_ArtField(self, AllocClass(self, java_lang_Class.get(),
287 sizeof(mirror::ArtFieldClass)));
288 CHECK(java_lang_reflect_ArtField.get() != NULL);
289 java_lang_reflect_ArtField->SetObjectSize(sizeof(mirror::ArtField));
290 SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700291 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved, self);
Brian Carlstromea46f952013-07-30 01:26:50 -0700292 mirror::ArtField::SetClass(java_lang_reflect_ArtField.get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700293
Brian Carlstromea46f952013-07-30 01:26:50 -0700294 SirtRef<mirror::Class> java_lang_reflect_ArtMethod(self, AllocClass(self, java_lang_Class.get(),
295 sizeof(mirror::ArtMethodClass)));
296 CHECK(java_lang_reflect_ArtMethod.get() != NULL);
297 java_lang_reflect_ArtMethod->SetObjectSize(sizeof(mirror::ArtMethod));
298 SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700299 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700300
Brian Carlstromea46f952013-07-30 01:26:50 -0700301 mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700302
303 // Set up array classes for string, field, method
Brian Carlstromea46f952013-07-30 01:26:50 -0700304 SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(),
305 sizeof(mirror::Class)));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700306 object_array_string->SetComponentType(java_lang_String.get());
307 SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
308
Brian Carlstromea46f952013-07-30 01:26:50 -0700309 SirtRef<mirror::Class> object_array_art_method(self, AllocClass(self, java_lang_Class.get(),
310 sizeof(mirror::Class)));
311 object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.get());
312 SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.get());
Ian Rogers4445a7e2012-10-05 17:19:13 -0700313
Brian Carlstromea46f952013-07-30 01:26:50 -0700314 SirtRef<mirror::Class> object_array_art_field(self, AllocClass(self, java_lang_Class.get(),
315 sizeof(mirror::Class)));
316 object_array_art_field->SetComponentType(java_lang_reflect_ArtField.get());
317 SetClassRoot(kJavaLangReflectArtFieldArrayClass, object_array_art_field.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700318
Ian Rogers23435d02012-09-24 11:23:12 -0700319 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
320 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
321 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700322 CHECK_NE(0U, boot_class_path.size());
323 for (size_t i = 0; i != boot_class_path.size(); ++i) {
324 const DexFile* dex_file = boot_class_path[i];
325 CHECK(dex_file != NULL);
326 AppendToBootClassPath(*dex_file);
327 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700328
329 // now we can use FindSystemClass
330
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700331 // run char class through InitializePrimitiveClass to finish init
Ian Rogersc8982582012-09-07 16:53:25 -0700332 InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700333 SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700334
Jeff Hao88474b42013-10-23 16:24:40 -0700335 // Create runtime resolution and imt conflict methods. Also setup the default imt.
336 Runtime* runtime = Runtime::Current();
337 runtime->SetResolutionMethod(runtime->CreateResolutionMethod());
338 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod());
339 runtime->SetDefaultImt(runtime->CreateDefaultImt(this));
340
Mathieu Chartier66f19252012-09-18 08:57:04 -0700341 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700342 java_lang_Object->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800343 mirror::Class* Object_class = FindSystemClass(self, "Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700344 CHECK_EQ(java_lang_Object.get(), Object_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800345 CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700346 java_lang_String->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800347 mirror::Class* String_class = FindSystemClass(self, "Ljava/lang/String;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700348 CHECK_EQ(java_lang_String.get(), String_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800349 CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700350 java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800351 mirror::Class* DexCache_class = FindSystemClass(self, "Ljava/lang/DexCache;");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700352 CHECK_EQ(java_lang_String.get(), String_class);
353 CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800354 CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700355
Ian Rogers23435d02012-09-24 11:23:12 -0700356 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers98379392014-02-24 16:53:16 -0800357 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800358 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700359
Ian Rogers98379392014-02-24 16:53:16 -0800360 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800361 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700362
Ian Rogers98379392014-02-24 16:53:16 -0800363 mirror::Class* found_char_array_class = FindSystemClass(self, "[C");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700364 CHECK_EQ(char_array_class.get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700365
Ian Rogers98379392014-02-24 16:53:16 -0800366 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800367 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700368
Ian Rogers98379392014-02-24 16:53:16 -0800369 mirror::Class* found_int_array_class = FindSystemClass(self, "[I");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700370 CHECK_EQ(int_array_class.get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700371
Ian Rogers98379392014-02-24 16:53:16 -0800372 SetClassRoot(kLongArrayClass, FindSystemClass(self, "[J"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800373 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700374
Ian Rogers98379392014-02-24 16:53:16 -0800375 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800376 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700377
Ian Rogers98379392014-02-24 16:53:16 -0800378 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800379 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700380
Ian Rogers98379392014-02-24 16:53:16 -0800381 mirror::Class* found_class_array_class = FindSystemClass(self, "[Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700382 CHECK_EQ(class_array_class.get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700383
Ian Rogers98379392014-02-24 16:53:16 -0800384 mirror::Class* found_object_array_class = FindSystemClass(self, "[Ljava/lang/Object;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700385 CHECK_EQ(object_array_class.get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700386
Ian Rogers23435d02012-09-24 11:23:12 -0700387 // Setup the single, global copy of "iftable".
Ian Rogers98379392014-02-24 16:53:16 -0800388 mirror::Class* java_lang_Cloneable = FindSystemClass(self, "Ljava/lang/Cloneable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700389 CHECK(java_lang_Cloneable != NULL);
Ian Rogers98379392014-02-24 16:53:16 -0800390 mirror::Class* java_io_Serializable = FindSystemClass(self, "Ljava/io/Serializable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700391 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700392 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
393 // crawl up and explicitly list all of the supers as well.
Ian Rogers9bc81912012-10-11 21:43:36 -0700394 array_iftable_->SetInterface(0, java_lang_Cloneable);
395 array_iftable_->SetInterface(1, java_io_Serializable);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700396
Ian Rogers23435d02012-09-24 11:23:12 -0700397 // Sanity check Class[] and Object[]'s interfaces.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700398 ClassHelper kh(class_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700399 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
400 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800401 kh.ChangeClass(object_array_class.get());
Ian Rogersd24e2642012-06-06 21:21:43 -0700402 CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
403 CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
Brian Carlstromea46f952013-07-30 01:26:50 -0700404 // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700405 // dex_cache_ fields and register them in class_table_.
Ian Rogers98379392014-02-24 16:53:16 -0800406 mirror::Class* Class_class = FindSystemClass(self, "Ljava/lang/Class;");
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700407 CHECK_EQ(java_lang_Class.get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700408
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700409 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800410 mirror::Class* Art_method_class = FindSystemClass(self, "Ljava/lang/reflect/ArtMethod;");
Brian Carlstromea46f952013-07-30 01:26:50 -0700411 CHECK_EQ(java_lang_reflect_ArtMethod.get(), Art_method_class);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700412
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700413 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800414 mirror::Class* Art_field_class = FindSystemClass(self, "Ljava/lang/reflect/ArtField;");
Brian Carlstromea46f952013-07-30 01:26:50 -0700415 CHECK_EQ(java_lang_reflect_ArtField.get(), Art_field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700416
Ian Rogers98379392014-02-24 16:53:16 -0800417 mirror::Class* String_array_class = FindSystemClass(self, class_roots_descriptors_[kJavaLangStringArrayClass]);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700418 CHECK_EQ(object_array_string.get(), String_array_class);
419
Brian Carlstromea46f952013-07-30 01:26:50 -0700420 mirror::Class* Art_method_array_class =
Ian Rogers98379392014-02-24 16:53:16 -0800421 FindSystemClass(self, class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]);
Brian Carlstromea46f952013-07-30 01:26:50 -0700422 CHECK_EQ(object_array_art_method.get(), Art_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700423
Brian Carlstromea46f952013-07-30 01:26:50 -0700424 mirror::Class* Art_field_array_class =
Ian Rogers98379392014-02-24 16:53:16 -0800425 FindSystemClass(self, class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]);
Brian Carlstromea46f952013-07-30 01:26:50 -0700426 CHECK_EQ(object_array_art_field.get(), Art_field_array_class);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700427
Ian Rogers23435d02012-09-24 11:23:12 -0700428 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700429
Ian Rogers23435d02012-09-24 11:23:12 -0700430 // Create java.lang.reflect.Proxy root.
Ian Rogers98379392014-02-24 16:53:16 -0800431 mirror::Class* java_lang_reflect_Proxy = FindSystemClass(self, "Ljava/lang/reflect/Proxy;");
Ian Rogers466bb252011-10-14 03:29:56 -0700432 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
433
Brian Carlstrom1f870082011-08-23 16:02:11 -0700434 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Ian Rogers98379392014-02-24 16:53:16 -0800435 mirror::Class* java_lang_ref_Reference = FindSystemClass(self, "Ljava/lang/ref/Reference;");
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700436 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
Ian Rogers98379392014-02-24 16:53:16 -0800437 mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700438 java_lang_ref_FinalizerReference->SetAccessFlags(
439 java_lang_ref_FinalizerReference->GetAccessFlags() |
440 kAccClassIsReference | kAccClassIsFinalizerReference);
Ian Rogers98379392014-02-24 16:53:16 -0800441 mirror::Class* java_lang_ref_PhantomReference = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700442 java_lang_ref_PhantomReference->SetAccessFlags(
443 java_lang_ref_PhantomReference->GetAccessFlags() |
444 kAccClassIsReference | kAccClassIsPhantomReference);
Ian Rogers98379392014-02-24 16:53:16 -0800445 mirror::Class* java_lang_ref_SoftReference = FindSystemClass(self, "Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700446 java_lang_ref_SoftReference->SetAccessFlags(
447 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Ian Rogers98379392014-02-24 16:53:16 -0800448 mirror::Class* java_lang_ref_WeakReference = FindSystemClass(self, "Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700449 java_lang_ref_WeakReference->SetAccessFlags(
450 java_lang_ref_WeakReference->GetAccessFlags() |
451 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700452
Ian Rogers23435d02012-09-24 11:23:12 -0700453 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers98379392014-02-24 16:53:16 -0800454 mirror::Class* java_lang_ClassLoader = FindSystemClass(self, "Ljava/lang/ClassLoader;");
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800455 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700456 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
457
jeffhao8cd6dda2012-02-22 10:15:34 -0800458 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700459 // java.lang.StackTraceElement as a convenience.
Ian Rogers98379392014-02-24 16:53:16 -0800460 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800461 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Ian Rogers98379392014-02-24 16:53:16 -0800462 SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass(self, "Ljava/lang/ClassNotFoundException;"));
463 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;"));
464 SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass(self, "[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800465 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700466
Ian Rogers98379392014-02-24 16:53:16 -0800467 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700468
Brian Carlstroma004aa92012-02-08 18:05:09 -0800469 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700470}
471
Ian Rogers98379392014-02-24 16:53:16 -0800472void ClassLinker::FinishInit(Thread* self) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800473 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700474
475 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700476 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700477 // as the types of the field can't be resolved prior to the runtime being
478 // fully initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800479 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700480 mirror::Class* java_lang_ref_FinalizerReference =
Ian Rogers98379392014-02-24 16:53:16 -0800481 FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800482
Brian Carlstromea46f952013-07-30 01:26:50 -0700483 mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700484 FieldHelper fh(pendingNext);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800485 CHECK_STREQ(fh.GetName(), "pendingNext");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700486 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700487
Brian Carlstromea46f952013-07-30 01:26:50 -0700488 mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800489 fh.ChangeField(queue);
490 CHECK_STREQ(fh.GetName(), "queue");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700491 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700492
Brian Carlstromea46f952013-07-30 01:26:50 -0700493 mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800494 fh.ChangeField(queueNext);
495 CHECK_STREQ(fh.GetName(), "queueNext");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700496 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700497
Brian Carlstromea46f952013-07-30 01:26:50 -0700498 mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800499 fh.ChangeField(referent);
500 CHECK_STREQ(fh.GetName(), "referent");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700501 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700502
Brian Carlstromea46f952013-07-30 01:26:50 -0700503 mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800504 fh.ChangeField(zombie);
505 CHECK_STREQ(fh.GetName(), "zombie");
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700506 CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700507
Brian Carlstroma663ea52011-08-19 23:33:41 -0700508 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700509 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700510 ClassRoot class_root = static_cast<ClassRoot>(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800511 mirror::Class* klass = GetClassRoot(class_root);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700512 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700513 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700514 // note SetClassRoot does additional validation.
515 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700516 }
517
Elliott Hughes92f14b22011-10-06 12:29:54 -0700518 CHECK(array_iftable_ != NULL);
Elliott Hughes92f14b22011-10-06 12:29:54 -0700519
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700520 // disable the slow paths in FindClass and CreatePrimitiveClass now
521 // that Object, Class, and Object[] are setup
522 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700523
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800524 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700525}
526
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700527void ClassLinker::RunRootClinits() {
528 Thread* self = Thread::Current();
529 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800530 mirror::Class* c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700531 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800532 SirtRef<mirror::Class> sirt_class(self, GetClassRoot(ClassRoot(i)));
533 EnsureInitialized(sirt_class, true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700534 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700535 }
536 }
537}
538
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700539bool ClassLinker::GenerateOatFile(const char* dex_filename,
Brian Carlstromd601af82012-01-06 10:15:19 -0800540 int oat_fd,
Vladimir Marko60836d52014-01-16 15:53:38 +0000541 const char* oat_cache_filename,
542 std::string* error_msg) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700543 Locks::mutator_lock_->AssertNotHeld(Thread::Current()); // Avoid starving GC.
Brian Carlstrom35d8b8e2014-02-25 10:51:11 -0800544 std::string dex2oat(GetAndroidRoot());
545 dex2oat += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800546
Ian Rogers1d54e732013-05-02 21:10:01 -0700547 gc::Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom6449c622014-02-10 23:48:36 -0800548 std::string boot_image_option("--boot-image=");
549 boot_image_option += heap->GetImageSpace()->GetImageFilename();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800550
Brian Carlstrom6449c622014-02-10 23:48:36 -0800551 std::string dex_file_option("--dex-file=");
552 dex_file_option += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800553
Brian Carlstrom6449c622014-02-10 23:48:36 -0800554 std::string oat_fd_option("--oat-fd=");
555 StringAppendF(&oat_fd_option, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800556
Brian Carlstrom6449c622014-02-10 23:48:36 -0800557 std::string oat_location_option("--oat-location=");
558 oat_location_option += oat_cache_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800559
Brian Carlstrom6449c622014-02-10 23:48:36 -0800560 std::vector<std::string> argv;
561 argv.push_back(dex2oat);
562 argv.push_back("--runtime-arg");
563 argv.push_back("-Xms64m");
564 argv.push_back("--runtime-arg");
565 argv.push_back("-Xmx64m");
566 argv.push_back("--runtime-arg");
567 argv.push_back("-classpath");
568 argv.push_back("--runtime-arg");
Brian Carlstrom35d8b8e2014-02-25 10:51:11 -0800569 argv.push_back(Runtime::Current()->GetClassPathString());
Dave Allisonb373e092014-02-20 16:06:36 -0800570
Ian Rogers8afeb852014-04-02 14:55:49 -0700571 Runtime::Current()->AddCurrentRuntimeFeaturesAsDex2OatArguments(&argv);
Dave Allisonb373e092014-02-20 16:06:36 -0800572
Jeff Hao4a200f52014-04-01 14:58:49 -0700573 if (!Runtime::Current()->IsVerificationEnabled()) {
574 argv.push_back("--compiler-filter=verify-none");
575 }
576
Brian Carlstrom6449c622014-02-10 23:48:36 -0800577 if (!kIsTargetBuild) {
578 argv.push_back("--host");
buzbeea024a062013-07-31 10:47:37 -0700579 }
Ian Rogers8afeb852014-04-02 14:55:49 -0700580
Brian Carlstrom6449c622014-02-10 23:48:36 -0800581 argv.push_back(boot_image_option);
582 argv.push_back(dex_file_option);
583 argv.push_back(oat_fd_option);
584 argv.push_back(oat_location_option);
585 const std::vector<std::string>& compiler_options = Runtime::Current()->GetCompilerOptions();
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800586 for (size_t i = 0; i < compiler_options.size(); ++i) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800587 argv.push_back(compiler_options[i].c_str());
jeffhao262bf462011-10-20 18:36:32 -0700588 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800589
590 return Exec(argv, error_msg);
jeffhao262bf462011-10-20 18:36:32 -0700591}
592
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700593const OatFile* ClassLinker::RegisterOatFile(const OatFile* oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700594 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800595 if (kIsDebugBuild) {
596 for (size_t i = 0; i < oat_files_.size(); ++i) {
597 CHECK_NE(oat_file, oat_files_[i]) << oat_file->GetLocation();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700598 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800599 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700600 VLOG(class_linker) << "Registering " << oat_file->GetLocation();
601 oat_files_.push_back(oat_file);
602 return oat_file;
Brian Carlstrom866c8622012-01-06 16:35:13 -0800603}
604
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700605OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
606 VLOG(startup) << "ClassLinker::GetImageOatFile entering";
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700607 OatFile* oat_file = space->ReleaseOatFile();
608 CHECK_EQ(RegisterOatFile(oat_file), oat_file);
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700609 VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700610 return *oat_file;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700611}
612
Brian Carlstromae826982011-11-09 01:33:42 -0800613const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800614 const char* dex_location = dex_file.GetLocation().c_str();
615 uint32_t dex_location_checksum = dex_file.GetLocationChecksum();
616 return FindOpenedOatFileFromDexLocation(dex_location, &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800617}
618
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700619const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const char* dex_location,
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800620 const uint32_t* const dex_location_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700621 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -0800622 for (size_t i = 0; i < oat_files_.size(); i++) {
623 const OatFile* oat_file = oat_files_[i];
624 DCHECK(oat_file != NULL);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700625 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800626 dex_location_checksum,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700627 false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800628 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800629 return oat_file;
630 }
631 }
632 return NULL;
633}
634
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700635const DexFile* ClassLinker::FindDexFileInOatLocation(const char* dex_location,
Ian Rogerse3359f72013-06-11 15:14:11 -0700636 uint32_t dex_location_checksum,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700637 const char* oat_location,
638 std::string* error_msg) {
Brian Carlstromf1d34552013-07-12 20:22:23 -0700639 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700640 !Runtime::Current()->IsCompiler(),
641 error_msg));
642 if (oat_file.get() == nullptr) {
643 *error_msg = StringPrintf("Failed to find existing oat file at %s: %s", oat_location,
644 error_msg->c_str());
645 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800646 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700647 Runtime* runtime = Runtime::Current();
648 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700649 uint32_t expected_image_oat_checksum = image_header.GetOatChecksum();
650 uint32_t actual_image_oat_checksum = oat_file->GetOatHeader().GetImageFileLocationOatChecksum();
651 if (expected_image_oat_checksum != actual_image_oat_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700652 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat checksum of "
653 "0x%x, found 0x%x", oat_location, expected_image_oat_checksum,
654 actual_image_oat_checksum);
655 return nullptr;
Brian Carlstrom28db0122012-10-18 16:20:41 -0700656 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700657
Ian Rogersef7d42f2014-01-06 12:55:46 -0800658 uintptr_t expected_image_oat_offset = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700659 uint32_t actual_image_oat_offset = oat_file->GetOatHeader().GetImageFileLocationOatDataBegin();
660 if (expected_image_oat_offset != actual_image_oat_offset) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800661 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat offset %"
662 PRIuPTR ", found %ud", oat_location, expected_image_oat_offset,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700663 actual_image_oat_offset);
664 return nullptr;
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700665 }
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100666 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
667 &dex_location_checksum);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700668 if (oat_dex_file == nullptr) {
669 *error_msg = StringPrintf("Failed to find oat file at '%s' containing '%s'", oat_location,
670 dex_location);
671 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800672 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700673 uint32_t expected_dex_checksum = dex_location_checksum;
674 uint32_t actual_dex_checksum = oat_dex_file->GetDexFileLocationChecksum();
675 if (expected_dex_checksum != actual_dex_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700676 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected dex checksum of 0x%x, "
677 "found 0x%x", oat_location, expected_dex_checksum,
678 actual_dex_checksum);
679 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800680 }
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100681 const DexFile* dex_file = oat_dex_file->OpenDexFile(error_msg);
682 if (dex_file != nullptr) {
683 RegisterOatFile(oat_file.release());
684 }
685 return dex_file;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700686}
687
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700688class ScopedFlock {
689 public:
690 ScopedFlock() {}
691
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700692 bool Init(const char* filename, std::string* error_msg) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700693 while (true) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700694 file_.reset(OS::OpenFileWithFlags(filename, O_CREAT | O_RDWR));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700695 if (file_.get() == NULL) {
Andreas Gampe329d1882014-04-08 10:32:19 -0700696 *error_msg = StringPrintf("Failed to open file '%s': %s", filename, strerror(errno));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700697 return false;
698 }
699 int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_EX));
700 if (flock_result != 0) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700701 *error_msg = StringPrintf("Failed to lock file '%s': %s", filename, strerror(errno));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700702 return false;
703 }
704 struct stat fstat_stat;
705 int fstat_result = TEMP_FAILURE_RETRY(fstat(file_->Fd(), &fstat_stat));
706 if (fstat_result != 0) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700707 *error_msg = StringPrintf("Failed to fstat file '%s': %s", filename, strerror(errno));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700708 return false;
709 }
710 struct stat stat_stat;
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700711 int stat_result = TEMP_FAILURE_RETRY(stat(filename, &stat_stat));
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700712 if (stat_result != 0) {
713 PLOG(WARNING) << "Failed to stat, will retry: " << filename;
714 // ENOENT can happen if someone racing with us unlinks the file we created so just retry.
715 continue;
716 }
717 if (fstat_stat.st_dev != stat_stat.st_dev || fstat_stat.st_ino != stat_stat.st_ino) {
718 LOG(WARNING) << "File changed while locking, will retry: " << filename;
719 continue;
720 }
721 return true;
722 }
723 }
724
725 File& GetFile() {
726 return *file_;
727 }
728
729 ~ScopedFlock() {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -0700730 if (file_.get() != NULL) {
731 int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_UN));
732 CHECK_EQ(0, flock_result);
733 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700734 }
735
736 private:
737 UniquePtr<File> file_;
738
739 DISALLOW_COPY_AND_ASSIGN(ScopedFlock);
740};
741
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700742const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const char* dex_location,
743 uint32_t dex_location_checksum,
744 const char* oat_location,
Andreas Gampe329d1882014-04-08 10:32:19 -0700745 std::vector<std::string>* error_msgs) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700746 // We play a locking game here so that if two different processes
747 // race to generate (or worse, one tries to open a partial generated
748 // file) we will be okay. This is actually common with apps that use
749 // DexClassLoader to work around the dex method reference limit and
750 // that have a background service running in a separate process.
751 ScopedFlock scoped_flock;
Andreas Gampe329d1882014-04-08 10:32:19 -0700752 std::string error_msg;
753 if (!scoped_flock.Init(oat_location, &error_msg)) {
754 error_msgs->push_back(error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700755 return nullptr;
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700756 }
757
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800758 // Check if we already have an up-to-date output file
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700759 const DexFile* dex_file = FindDexFileInOatLocation(dex_location, dex_location_checksum,
Andreas Gampe329d1882014-04-08 10:32:19 -0700760 oat_location, &error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700761 if (dex_file != nullptr) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800762 return dex_file;
763 }
Andreas Gampe329d1882014-04-08 10:32:19 -0700764 std::string compound_msg = StringPrintf("Failed to find dex file '%s' in oat location '%s': %s",
765 dex_location, oat_location, error_msg.c_str());
766 VLOG(class_linker) << compound_msg;
767 error_msgs->push_back(compound_msg);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800768
769 // Generate the output oat file for the dex file
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700770 VLOG(class_linker) << "Generating oat file " << oat_location << " for " << dex_location;
Andreas Gampe329d1882014-04-08 10:32:19 -0700771 if (!GenerateOatFile(dex_location, scoped_flock.GetFile().Fd(), oat_location, &error_msg)) {
772 CHECK(!error_msg.empty());
773 error_msgs->push_back(error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700774 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800775 }
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100776 UniquePtr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
777 !Runtime::Current()->IsCompiler(),
778 &error_msg));
779 if (oat_file.get() == nullptr) {
Andreas Gampe329d1882014-04-08 10:32:19 -0700780 compound_msg = StringPrintf("\nFailed to open generated oat file '%s': %s",
781 oat_location, error_msg.c_str());
782 error_msgs->push_back(compound_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700783 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800784 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700785 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
786 &dex_location_checksum);
787 if (oat_dex_file == nullptr) {
Andreas Gampe329d1882014-04-08 10:32:19 -0700788 error_msg = StringPrintf("\nFailed to find dex file '%s' (checksum 0x%x) in generated out file "
789 "'%s'", dex_location, dex_location_checksum, oat_location);
790 error_msgs->push_back(error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700791 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800792 }
Andreas Gampe329d1882014-04-08 10:32:19 -0700793 const DexFile* result = oat_dex_file->OpenDexFile(&error_msg);
794 CHECK(result != nullptr) << error_msgs << ", " << error_msg;
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700795 CHECK_EQ(dex_location_checksum, result->GetLocationChecksum())
796 << "dex_location=" << dex_location << " oat_location=" << oat_location << std::hex
797 << " dex_location_checksum=" << dex_location_checksum
Brian Carlstromb00309f2013-09-30 14:23:30 -0700798 << " DexFile::GetLocationChecksum()=" << result->GetLocationChecksum();
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100799 RegisterOatFile(oat_file.release());
Brian Carlstromb00309f2013-09-30 14:23:30 -0700800 return result;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800801}
802
Brian Carlstromafe25512012-06-27 17:02:58 -0700803bool ClassLinker::VerifyOatFileChecksums(const OatFile* oat_file,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700804 const char* dex_location,
805 uint32_t dex_location_checksum,
806 std::string* error_msg) {
Brian Carlstromafe25512012-06-27 17:02:58 -0700807 Runtime* runtime = Runtime::Current();
808 const ImageHeader& image_header = runtime->GetHeap()->GetImageSpace()->GetImageHeader();
Brian Carlstrom28db0122012-10-18 16:20:41 -0700809 uint32_t image_oat_checksum = image_header.GetOatChecksum();
Ian Rogersef7d42f2014-01-06 12:55:46 -0800810 uintptr_t image_oat_data_begin = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
Brian Carlstrom28db0122012-10-18 16:20:41 -0700811 bool image_check = ((oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum)
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800812 && (oat_file->GetOatHeader().GetImageFileLocationOatDataBegin() == image_oat_data_begin));
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700813
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700814 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, &dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700815 if (oat_dex_file == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700816 *error_msg = StringPrintf("oat file '%s' does not contain contents for '%s' with checksum 0x%x",
817 oat_file->GetLocation().c_str(), dex_location, dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700818 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
819 for (size_t i = 0; i < oat_dex_files.size(); i++) {
820 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700821 *error_msg += StringPrintf("\noat file '%s' contains contents for '%s'",
822 oat_file->GetLocation().c_str(),
823 oat_dex_file->GetDexFileLocation().c_str());
Brian Carlstromafe25512012-06-27 17:02:58 -0700824 }
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) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700834 ScopedObjectAccess soa(Thread::Current());
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000835 *error_msg = StringPrintf("oat file '%s' mismatch (0x%x, %d) with (0x%x, %" PRIdPTR ")",
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700836 oat_file->GetLocation().c_str(),
837 oat_file->GetOatHeader().GetImageFileLocationOatChecksum(),
838 oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(),
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000839 image_oat_checksum, image_oat_data_begin);
Brian Carlstromafe25512012-06-27 17:02:58 -0700840 }
841 if (!dex_check) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700842 *error_msg = StringPrintf("oat file '%s' mismatch (0x%x) with '%s' (0x%x)",
843 oat_file->GetLocation().c_str(),
844 oat_dex_file->GetDexFileLocationChecksum(),
845 dex_location, dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -0700846 }
847 return false;
848}
849
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700850const DexFile* ClassLinker::VerifyAndOpenDexFileFromOatFile(const std::string& oat_file_location,
851 const char* dex_location,
852 std::string* error_msg,
853 bool* open_failed) {
854 UniquePtr<const OatFile> oat_file(FindOatFileFromOatLocation(oat_file_location, error_msg));
855 if (oat_file.get() == nullptr) {
856 *open_failed = true;
857 return nullptr;
Brian Carlstromafe25512012-06-27 17:02:58 -0700858 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700859 *open_failed = false;
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100860 const DexFile* dex_file = nullptr;
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700861 uint32_t dex_location_checksum;
862 if (!DexFile::GetChecksum(dex_location, &dex_location_checksum, error_msg)) {
863 // If no classes.dex found in dex_location, it has been stripped or is corrupt, assume oat is
864 // up-to-date. This is the common case in user builds for jar's and apk's in the /system
865 // directory.
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100866 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, NULL);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700867 if (oat_dex_file == nullptr) {
868 *error_msg = StringPrintf("Dex checksum mismatch for location '%s' and failed to find oat "
869 "dex file '%s': %s", oat_file_location.c_str(), dex_location,
870 error_msg->c_str());
871 return nullptr;
872 }
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100873 dex_file = oat_dex_file->OpenDexFile(error_msg);
874 } else {
875 bool verified = VerifyOatFileChecksums(oat_file.get(), dex_location, dex_location_checksum,
876 error_msg);
877 if (!verified) {
878 return nullptr;
879 }
880 dex_file = oat_file->GetOatDexFile(dex_location,
881 &dex_location_checksum)->OpenDexFile(error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700882 }
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100883 if (dex_file != nullptr) {
884 RegisterOatFile(oat_file.release());
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700885 }
Vladimir Marko64e7ac02014-05-01 15:43:47 +0100886 return dex_file;
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700887}
888
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700889const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const char* dex_location,
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800890 const uint32_t* const dex_location_checksum,
Andreas Gampe329d1882014-04-08 10:32:19 -0700891 std::vector<std::string>* error_msgs) {
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700892 const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location,
893 dex_location_checksum);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700894 if (open_oat_file != nullptr) {
895 const OatFile::OatDexFile* oat_dex_file = open_oat_file->GetOatDexFile(dex_location,
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800896 dex_location_checksum);
Andreas Gampe329d1882014-04-08 10:32:19 -0700897 std::string error_msg;
898 const DexFile* ret = oat_dex_file->OpenDexFile(&error_msg);
899 if (ret == nullptr) {
900 error_msgs->push_back(error_msg);
901 }
902 return ret;
Brian Carlstromae826982011-11-09 01:33:42 -0800903 }
904
Brian Carlstrom46b8a622012-06-19 23:13:22 -0700905 // Look for an existing file next to dex. for example, for
Brian Carlstrom30e2ea42013-06-19 23:25:37 -0700906 // /foo/bar/baz.jar, look for /foo/bar/baz.odex.
907 std::string odex_filename(OatFile::DexFilenameToOdexFilename(dex_location));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700908 bool open_failed;
Andreas Gampe329d1882014-04-08 10:32:19 -0700909 std::string error_msg;
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700910 const DexFile* dex_file = VerifyAndOpenDexFileFromOatFile(odex_filename, dex_location,
Andreas Gampe329d1882014-04-08 10:32:19 -0700911 &error_msg, &open_failed);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700912 if (dex_file != nullptr) {
913 return dex_file;
Brian Carlstroma004aa92012-02-08 18:05:09 -0800914 }
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800915 if (dex_location_checksum == nullptr) {
Andreas Gampe329d1882014-04-08 10:32:19 -0700916 error_msgs->push_back(StringPrintf("Failed to open oat file from %s and no classes.dex found in"
917 "%s: %s", odex_filename.c_str(), dex_location,
918 error_msg.c_str()));
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800919 return nullptr;
920 }
921
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700922 std::string cache_error_msg;
Narayan Kamath11d9f062014-04-23 20:24:57 +0100923 const std::string dalvik_cache(GetDalvikCacheOrDie(GetInstructionSetString(kRuntimeISA)));
924 std::string cache_location(GetDalvikCacheFilenameOrDie(dex_location,
925 dalvik_cache.c_str()));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700926 dex_file = VerifyAndOpenDexFileFromOatFile(cache_location, dex_location, &cache_error_msg,
927 &open_failed);
928 if (dex_file != nullptr) {
929 return dex_file;
jeffhao262bf462011-10-20 18:36:32 -0700930 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700931 if (!open_failed && TEMP_FAILURE_RETRY(unlink(cache_location.c_str())) != 0) {
932 PLOG(FATAL) << "Failed to remove obsolete oat file from " << cache_location;
933 }
Andreas Gampe329d1882014-04-08 10:32:19 -0700934 std::string compound_msg = StringPrintf("Failed to open oat file from %s (error '%s') or %s "
935 "(error '%s').", odex_filename.c_str(), error_msg.c_str(),
936 cache_location.c_str(), cache_error_msg.c_str());
937 VLOG(class_linker) << compound_msg;
938 error_msgs->push_back(compound_msg);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800939
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800940 // Try to generate oat file if it wasn't found or was obsolete.
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800941 return FindOrCreateOatFileForDexLocation(dex_location, *dex_location_checksum,
Andreas Gampe329d1882014-04-08 10:32:19 -0700942 cache_location.c_str(), error_msgs);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700943}
944
Brian Carlstromae826982011-11-09 01:33:42 -0800945const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700946 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700947 for (size_t i = 0; i < oat_files_.size(); i++) {
948 const OatFile* oat_file = oat_files_[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700949 DCHECK(oat_file != nullptr);
Brian Carlstromae826982011-11-09 01:33:42 -0800950 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700951 return oat_file;
952 }
953 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700954 return nullptr;
Brian Carlstromfad71432011-10-16 20:25:10 -0700955}
Brian Carlstromaded5f72011-10-07 17:15:04 -0700956
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700957const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location,
958 std::string* error_msg) {
jeffhaof6174e82012-01-31 16:14:17 -0800959 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700960 if (oat_file != nullptr) {
jeffhaof6174e82012-01-31 16:14:17 -0800961 return oat_file;
962 }
963
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700964 oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler(),
965 error_msg);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700966 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800967 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700968 }
969 return oat_file;
970}
971
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700972static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
Ian Rogers848871b2013-08-05 10:56:33 -0700973 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700974 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
975
Ian Rogers848871b2013-08-05 10:56:33 -0700976 DCHECK(obj != NULL);
977 DCHECK(class_linker != NULL);
978
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700979 if (obj->IsArtMethod()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700980 mirror::ArtMethod* method = obj->AsArtMethod();
Ian Rogers848871b2013-08-05 10:56:33 -0700981 if (!method->IsNative()) {
982 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
983 if (method != Runtime::Current()->GetResolutionMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800984 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
985 method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
Ian Rogers848871b2013-08-05 10:56:33 -0700986 }
987 }
988 }
989}
990
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700991void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800992 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700993 CHECK(!init_done_);
994
Mathieu Chartier590fee92013-09-13 13:46:47 -0700995 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700996 gc::Heap* heap = Runtime::Current()->GetHeap();
997 gc::space::ImageSpace* space = heap->GetImageSpace();
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700998 dex_cache_image_class_lookup_required_ = true;
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700999 CHECK(space != NULL);
1000 OatFile& oat_file = GetImageOatFile(space);
1001 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
1002 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
1003 CHECK(oat_file.GetOatHeader().GetImageFileLocation().empty());
1004 portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
1005 quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
Jeff Hao88474b42013-10-23 16:24:40 -07001006 portable_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetPortableImtConflictTrampoline();
1007 quick_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetQuickImtConflictTrampoline();
Andreas Gampe2da88232014-02-27 12:26:20 -08001008 quick_generic_jni_trampoline_ = oat_file.GetOatHeader().GetQuickGenericJniTrampoline();
Vladimir Marko8a630572014-04-09 18:45:35 +01001009 quick_to_interpreter_bridge_trampoline_ = oat_file.GetOatHeader().GetQuickToInterpreterBridge();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001010 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
1011 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1012 dex_caches_object->AsObjectArray<mirror::DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001013
Mathieu Chartier590fee92013-09-13 13:46:47 -07001014 SirtRef<mirror::ObjectArray<mirror::Class> > class_roots(
1015 self,
1016 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>());
1017 class_roots_ = class_roots.get();
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001018
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001019 // Special case of setting up the String class early so that we can test arbitrary objects
1020 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001021 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001022
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001023 CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001024 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001025 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001026 SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001027 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001028 const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location.c_str(),
1029 nullptr);
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001030 CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001031 std::string error_msg;
1032 const DexFile* dex_file = oat_dex_file->OpenDexFile(&error_msg);
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001033 if (dex_file == NULL) {
1034 LOG(FATAL) << "Failed to open dex file " << dex_file_location
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001035 << " from within oat file " << oat_file.GetLocation()
1036 << " error '" << error_msg << "'";
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001037 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001038
1039 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
1040
1041 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001042 }
1043
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001044 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
1045 // bitmap walk.
Brian Carlstromea46f952013-07-30 01:26:50 -07001046 mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001047
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001048 // Set entry point to interpreter if in InterpretOnly mode.
1049 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001050 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001051 heap->VisitObjects(InitFromImageInterpretOnlyCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001052 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001053
1054 // reinit class_roots_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001055 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
Mathieu Chartier590fee92013-09-13 13:46:47 -07001056 class_roots_ = class_roots.get();
Brian Carlstroma663ea52011-08-19 23:33:41 -07001057
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001058 // reinit array_iftable_ from any array class instance, they should be ==
Elliott Hughes92f14b22011-10-06 12:29:54 -07001059 array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
1060 DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001061 // String class root was set above
Brian Carlstromea46f952013-07-30 01:26:50 -07001062 mirror::ArtField::SetClass(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001063 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1064 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1065 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1066 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1067 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1068 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1069 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1070 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1071 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1072 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001073
Ian Rogers98379392014-02-24 16:53:16 -08001074 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001075
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001076 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001077}
1078
Brian Carlstroma663ea52011-08-19 23:33:41 -07001079// Keep in sync with InitCallback. Anything we visit, we need to
1080// reinit references to when reinitializing a ClassLinker from a
1081// mapped image.
Mathieu Chartier893263b2014-03-04 11:07:42 -08001082void ClassLinker::VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags) {
Mathieu Chartier815873e2014-02-13 18:02:13 -08001083 callback(reinterpret_cast<mirror::Object**>(&class_roots_), arg, 0, kRootVMInternal);
Ian Rogers50b35e22012-10-04 10:09:15 -07001084 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001085 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001086 ReaderMutexLock mu(self, dex_lock_);
Mathieu Chartier893263b2014-03-04 11:07:42 -08001087 if ((flags & kVisitRootFlagAllRoots) != 0) {
Mathieu Chartierb3070522013-09-17 14:18:21 -07001088 for (mirror::DexCache*& dex_cache : dex_caches_) {
Mathieu Chartier815873e2014-02-13 18:02:13 -08001089 callback(reinterpret_cast<mirror::Object**>(&dex_cache), arg, 0, kRootVMInternal);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001090 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001091 } else if ((flags & kVisitRootFlagNewRoots) != 0) {
1092 for (size_t index : new_dex_cache_roots_) {
1093 callback(reinterpret_cast<mirror::Object**>(&dex_caches_[index]), arg, 0, kRootVMInternal);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001094 }
Elliott Hughesf8349362012-06-18 15:00:06 -07001095 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001096 if ((flags & kVisitRootFlagClearRootLog) != 0) {
1097 new_dex_cache_roots_.clear();
1098 }
1099 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
1100 log_new_dex_caches_roots_ = true;
1101 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
1102 log_new_dex_caches_roots_ = false;
1103 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001104 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001105 {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001106 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier893263b2014-03-04 11:07:42 -08001107 if ((flags & kVisitRootFlagAllRoots) != 0) {
Mathieu Chartierb3070522013-09-17 14:18:21 -07001108 for (std::pair<const size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier815873e2014-02-13 18:02:13 -08001109 callback(reinterpret_cast<mirror::Object**>(&it.second), arg, 0, kRootStickyClass);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001110 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001111 } else if ((flags & kVisitRootFlagNewRoots) != 0) {
1112 for (auto& pair : new_class_roots_) {
1113 mirror::Object* old_ref = pair.second;
1114 callback(reinterpret_cast<mirror::Object**>(&pair.second), arg, 0, kRootStickyClass);
1115 if (UNLIKELY(pair.second != old_ref)) {
1116 // Uh ohes, GC moved a root in the log. Need to search the class_table and update the
1117 // corresponding object. This is slow, but luckily for us, this may only happen with a
1118 // concurrent moving GC.
1119 for (auto it = class_table_.lower_bound(pair.first), end = class_table_.end();
1120 it != end && it->first == pair.first; ++it) {
1121 // If the class stored matches the old class, update it to the new value.
1122 if (old_ref == it->second) {
1123 it->second = pair.second;
1124 }
1125 }
1126 }
Mathieu Chartierc4621982013-09-16 19:43:47 -07001127 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001128 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001129 if ((flags & kVisitRootFlagClearRootLog) != 0) {
1130 new_class_roots_.clear();
1131 }
1132 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
1133 log_new_class_table_roots_ = true;
1134 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
1135 log_new_class_table_roots_ = false;
1136 }
Mathieu Chartier262e5ff2012-06-01 17:35:38 -07001137 // We deliberately ignore the class roots in the image since we
1138 // handle image roots by using the MS/CMS rescanning of dirty cards.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001139 }
Mathieu Chartier815873e2014-02-13 18:02:13 -08001140 callback(reinterpret_cast<mirror::Object**>(&array_iftable_), arg, 0, kRootVMInternal);
Mathieu Chartier423d2a32013-09-12 17:33:56 -07001141 DCHECK(array_iftable_ != nullptr);
Ian Rogers98379392014-02-24 16:53:16 -08001142 for (size_t i = 0; i < kFindArrayCacheSize; ++i) {
1143 if (find_array_class_cache_[i] != nullptr) {
1144 callback(reinterpret_cast<mirror::Object**>(&find_array_class_cache_[i]), arg, 0,
1145 kRootVMInternal);
Ian Rogers98379392014-02-24 16:53:16 -08001146 }
1147 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001148}
1149
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001150void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) {
1151 if (dex_cache_image_class_lookup_required_) {
1152 MoveImageClassesToClassTable();
Elliott Hughesa2155262011-11-16 16:26:58 -08001153 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001154 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001155 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001156 if (!visitor(it.second, arg)) {
Elliott Hughesa2155262011-11-16 16:26:58 -08001157 return;
1158 }
1159 }
1160}
1161
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001162static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1163 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001164 classes->insert(c);
1165 return true;
1166}
1167
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001168void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001169 std::set<mirror::Class*> classes;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001170 VisitClasses(GetClassesVisitor, &classes);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001171 for (mirror::Class* klass : classes) {
1172 if (!visitor(klass, arg)) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001173 return;
1174 }
1175 }
1176}
1177
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001178ClassLinker::~ClassLinker() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001179 mirror::Class::ResetClass();
1180 mirror::String::ResetClass();
Brian Carlstromea46f952013-07-30 01:26:50 -07001181 mirror::ArtField::ResetClass();
1182 mirror::ArtMethod::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001183 mirror::BooleanArray::ResetArrayClass();
1184 mirror::ByteArray::ResetArrayClass();
1185 mirror::CharArray::ResetArrayClass();
1186 mirror::DoubleArray::ResetArrayClass();
1187 mirror::FloatArray::ResetArrayClass();
1188 mirror::IntArray::ResetArrayClass();
1189 mirror::LongArray::ResetArrayClass();
1190 mirror::ShortArray::ResetArrayClass();
1191 mirror::Throwable::ResetClass();
1192 mirror::StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001193 STLDeleteElements(&boot_class_path_);
1194 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001195}
1196
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001197mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001198 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001199 SirtRef<mirror::Class> dex_cache_class(self, GetClassRoot(kJavaLangDexCache));
1200 SirtRef<mirror::DexCache> dex_cache(
1201 self, down_cast<mirror::DexCache*>(
Hiroshi Yamauchi4cd662e2014-04-03 16:28:10 -07001202 heap->AllocObject<true>(self, dex_cache_class.get(), dex_cache_class->GetObjectSize(),
1203 VoidFunctor())));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001204 if (dex_cache.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001205 return NULL;
1206 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001207 SirtRef<mirror::String>
1208 location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001209 if (location.get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001210 return NULL;
1211 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001212 SirtRef<mirror::ObjectArray<mirror::String> >
1213 strings(self, AllocStringArray(self, dex_file.NumStringIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001214 if (strings.get() == NULL) {
1215 return NULL;
1216 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001217 SirtRef<mirror::ObjectArray<mirror::Class> >
1218 types(self, AllocClassArray(self, dex_file.NumTypeIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001219 if (types.get() == NULL) {
1220 return NULL;
1221 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001222 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
1223 methods(self, AllocArtMethodArray(self, dex_file.NumMethodIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001224 if (methods.get() == NULL) {
1225 return NULL;
1226 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001227 SirtRef<mirror::ObjectArray<mirror::ArtField> >
1228 fields(self, AllocArtFieldArray(self, dex_file.NumFieldIds()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001229 if (fields.get() == NULL) {
1230 return NULL;
1231 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07001232 dex_cache->Init(&dex_file, location.get(), strings.get(), types.get(), methods.get(),
Ian Rogers5ddb4102014-01-07 08:58:46 -08001233 fields.get());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001234 return dex_cache.get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001235}
1236
Ian Rogers6fac4472014-02-25 17:01:10 -08001237// Used to initialize a class in the allocation code path to ensure it is guarded by a StoreStore
1238// fence.
1239class InitializeClassVisitor {
1240 public:
1241 explicit InitializeClassVisitor(uint32_t class_size) : class_size_(class_size) {
1242 }
1243
1244 void operator()(mirror::Object* obj, size_t usable_size) const
1245 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1246 DCHECK_LE(class_size_, usable_size);
1247 // Avoid AsClass as object is not yet in live bitmap or allocation stack.
1248 mirror::Class* klass = down_cast<mirror::Class*>(obj);
1249 // DCHECK(klass->IsClass());
1250 klass->SetClassSize(class_size_);
1251 klass->SetPrimitiveType(Primitive::kPrimNot); // Default to not being primitive.
1252 klass->SetDexClassDefIndex(DexFile::kDexNoIndex16); // Default to no valid class def index.
1253 klass->SetDexTypeIndex(DexFile::kDexNoIndex16); // Default to no valid type index.
1254 }
1255
1256 private:
1257 const uint32_t class_size_;
1258
1259 DISALLOW_COPY_AND_ASSIGN(InitializeClassVisitor);
1260};
1261
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001262mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
Ian Rogers6fac4472014-02-25 17:01:10 -08001263 uint32_t class_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001264 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07001265 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers6fac4472014-02-25 17:01:10 -08001266 InitializeClassVisitor visitor(class_size);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001267 mirror::Object* k =
Ian Rogers6fac4472014-02-25 17:01:10 -08001268 kMovingClasses ? heap->AllocObject<true>(self, java_lang_Class, class_size, visitor)
1269 : heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
1270 if (UNLIKELY(k == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001271 CHECK(self->IsExceptionPending()); // OOME.
Ian Rogers6fac4472014-02-25 17:01:10 -08001272 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07001273 }
Ian Rogers6fac4472014-02-25 17:01:10 -08001274 return k->AsClass();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001275}
1276
Ian Rogers6fac4472014-02-25 17:01:10 -08001277mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001278 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001279}
1280
Brian Carlstromea46f952013-07-30 01:26:50 -07001281mirror::ArtField* ClassLinker::AllocArtField(Thread* self) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001282 return down_cast<mirror::ArtField*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001283 GetClassRoot(kJavaLangReflectArtField)->AllocNonMovableObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001284}
1285
Brian Carlstromea46f952013-07-30 01:26:50 -07001286mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001287 return down_cast<mirror::ArtMethod*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001288 GetClassRoot(kJavaLangReflectArtMethod)->AllocNonMovableObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001289}
1290
Mathieu Chartier590fee92013-09-13 13:46:47 -07001291mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
1292 Thread* self, size_t length) {
1293 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
1294 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001295}
1296
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001297static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001298 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001299 DCHECK(klass != NULL);
1300 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001301 if (!klass->IsResolved() && !klass->IsErroneous()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001302 SirtRef<mirror::Class> sirt_class(self, klass);
1303 ObjectLock<mirror::Class> lock(self, &sirt_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001304 // Check for circular dependencies between classes.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001305 if (!sirt_class->IsResolved() && sirt_class->GetClinitThreadId() == self->GetTid()) {
1306 ThrowClassCircularityError(sirt_class.get());
1307 sirt_class->SetStatus(mirror::Class::kStatusError, self);
1308 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001309 }
1310 // Wait for the pending initialization to complete.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001311 while (!sirt_class->IsResolved() && !sirt_class->IsErroneous()) {
Ian Rogers05f30572013-02-20 12:13:11 -08001312 lock.WaitIgnoringInterrupts();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001313 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001314 klass = sirt_class.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001315 }
1316 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001317 ThrowEarlierClassFailure(klass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001318 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001319 }
1320 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001321 CHECK(klass->IsResolved()) << PrettyClass(klass);
Ian Rogers62d6c772013-02-27 08:32:07 -08001322 self->AssertNoPendingException();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001323 return klass;
1324}
1325
Ian Rogers98379392014-02-24 16:53:16 -08001326mirror::Class* ClassLinker::FindClass(Thread* self, const char* descriptor,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001327 const SirtRef<mirror::ClassLoader>& class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001328 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Ian Rogers98379392014-02-24 16:53:16 -08001329 DCHECK(self != nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001330 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001331 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001332 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1333 // for primitive classes that aren't backed by dex files.
1334 return FindPrimitiveClass(descriptor[0]);
1335 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001336 // Find the class in the loaded classes table.
Mathieu Chartier590fee92013-09-13 13:46:47 -07001337 mirror::Class* klass = LookupClass(descriptor, class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001338 if (klass != NULL) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001339 return EnsureResolved(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001340 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001341 // Class is not yet loaded.
1342 if (descriptor[0] == '[') {
Ian Rogers98379392014-02-24 16:53:16 -08001343 return CreateArrayClass(self, descriptor, class_loader);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001344 } else if (class_loader.get() == nullptr) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001345 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1346 if (pair.second != NULL) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001347 SirtRef<mirror::ClassLoader> class_loader(self, nullptr);
1348 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Jesse Wilson47daf872011-11-23 11:42:45 -05001349 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001350 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001351 // First try the boot class path, we check the descriptor first to avoid an unnecessary
1352 // throw of a NoClassDefFoundError.
1353 if (IsInBootClassPath(descriptor)) {
Ian Rogers98379392014-02-24 16:53:16 -08001354 mirror::Class* system_class = FindSystemClass(self, descriptor);
Ian Rogersbe7149f2013-08-20 09:29:39 -07001355 CHECK(system_class != NULL);
Jesse Wilson47daf872011-11-23 11:42:45 -05001356 return system_class;
1357 }
Ian Rogersbe7149f2013-08-20 09:29:39 -07001358 // Next try the compile time class path.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001359 const std::vector<const DexFile*>* class_path;
1360 {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001361 ScopedObjectAccessUnchecked soa(self);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001362 ScopedLocalRef<jobject> jclass_loader(soa.Env(),
1363 soa.AddLocalReference<jobject>(class_loader.get()));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001364 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1365 }
1366
1367 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001368 if (pair.second != NULL) {
1369 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001370 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001371
1372 } else {
Ian Rogers98379392014-02-24 16:53:16 -08001373 ScopedObjectAccessUnchecked soa(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001374 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
Mathieu Chartier590fee92013-09-13 13:46:47 -07001375 soa.AddLocalReference<jobject>(class_loader.get()));
Elliott Hughes95572412011-12-13 18:14:20 -08001376 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001377 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001378 {
1379 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001380 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1381 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001382 if (class_name_object.get() == NULL) {
1383 return NULL;
1384 }
1385 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001386 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1387 WellKnownClasses::java_lang_ClassLoader_loadClass,
1388 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001389 }
Ian Rogers98379392014-02-24 16:53:16 -08001390 if (self->IsExceptionPending()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001391 // If the ClassLoader threw, pass that exception up.
1392 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001393 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001394 // broken loader - throw NPE to be compatible with Dalvik
Ian Rogers62d6c772013-02-27 08:32:07 -08001395 ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1396 class_name_string.c_str()).c_str());
Ian Rogerscab01012012-01-10 17:35:46 -08001397 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001398 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001399 // success, return mirror::Class*
1400 return soa.Decode<mirror::Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08001401 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001402 }
1403
Elliott Hughes82914b62012-04-09 15:56:29 -07001404 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05001405 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001406}
1407
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001408mirror::Class* ClassLinker::DefineClass(const char* descriptor,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001409 const SirtRef<mirror::ClassLoader>& class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001410 const DexFile& dex_file,
1411 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07001412 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001413 SirtRef<mirror::Class> klass(self, NULL);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001414 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001415 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001416 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001417 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001418 klass.reset(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001419 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001420 klass.reset(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001421 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001422 klass.reset(GetClassRoot(kJavaLangString));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001423 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001424 klass.reset(GetClassRoot(kJavaLangDexCache));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001425 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001426 klass.reset(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001427 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001428 klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001429 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001430 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001431 }
1432 } else {
Ian Rogers50b35e22012-10-04 10:09:15 -07001433 klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001434 }
Ian Rogersa436fde2013-08-27 23:34:06 -07001435 if (UNLIKELY(klass.get() == NULL)) {
1436 CHECK(self->IsExceptionPending()); // Expect an OOME.
1437 return NULL;
1438 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001439 klass->SetDexCache(FindDexCache(dex_file));
Mathieu Chartier590fee92013-09-13 13:46:47 -07001440 LoadClass(dex_file, dex_class_def, klass, class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001441 // Check for a pending exception during load
Brian Carlstromaded5f72011-10-07 17:15:04 -07001442 if (self->IsExceptionPending()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001443 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001444 return NULL;
1445 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001446 ObjectLock<mirror::Class> lock(self, &klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001447 klass->SetClinitThreadId(self->GetTid());
Mathieu Chartier590fee92013-09-13 13:46:47 -07001448 // Add the newly loaded class to the loaded classes table.
1449 mirror::Class* existing = InsertClass(descriptor, klass.get(), Hash(descriptor));
1450 if (existing != NULL) {
1451 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
1452 // this thread to block.
1453 return EnsureResolved(self, existing);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001454 }
1455 // Finish loading (if necessary) by finding parents
1456 CHECK(!klass->IsLoaded());
1457 if (!LoadSuperAndInterfaces(klass, dex_file)) {
1458 // Loading failed.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001459 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001460 return NULL;
1461 }
1462 CHECK(klass->IsLoaded());
1463 // Link the class (if necessary)
1464 CHECK(!klass->IsResolved());
Mathieu Chartier590fee92013-09-13 13:46:47 -07001465 // TODO: Use fast jobjects?
1466 SirtRef<mirror::ObjectArray<mirror::Class> > interfaces(self, nullptr);
1467 if (!LinkClass(self, klass, interfaces)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001468 // Linking failed.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001469 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001470 return NULL;
1471 }
1472 CHECK(klass->IsResolved());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001473
1474 /*
1475 * We send CLASS_PREPARE events to the debugger from here. The
1476 * definition of "preparation" is creating the static fields for a
1477 * class and initializing them to the standard default values, but not
1478 * executing any code (that comes later, during "initialization").
1479 *
1480 * We did the static preparation in LinkClass.
1481 *
1482 * The class has been prepared and resolved but possibly not yet verified
1483 * at this point.
1484 */
1485 Dbg::PostClassPrepare(klass.get());
1486
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001487 return klass.get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001488}
1489
Brian Carlstrom4873d462011-08-21 15:23:39 -07001490// Precomputes size that will be needed for Class, matching LinkStaticFields
Ian Rogers6fac4472014-02-25 17:01:10 -08001491uint32_t ClassLinker::SizeOfClass(const DexFile& dex_file,
Brian Carlstrom4873d462011-08-21 15:23:39 -07001492 const DexFile::ClassDef& dex_class_def) {
1493 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001494 size_t num_ref = 0;
1495 size_t num_32 = 0;
1496 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001497 if (class_data != NULL) {
1498 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
1499 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001500 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001501 char c = descriptor[0];
1502 if (c == 'L' || c == '[') {
1503 num_ref++;
1504 } else if (c == 'J' || c == 'D') {
1505 num_64++;
1506 } else {
1507 num_32++;
1508 }
1509 }
1510 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07001511 // start with generic class data
Ian Rogers6fac4472014-02-25 17:01:10 -08001512 uint32_t size = sizeof(mirror::Class);
Brian Carlstrom4873d462011-08-21 15:23:39 -07001513 // follow with reference fields which must be contiguous at start
1514 size += (num_ref * sizeof(uint32_t));
1515 // if there are 64-bit fields to add, make sure they are aligned
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001516 if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
Brian Carlstrom4873d462011-08-21 15:23:39 -07001517 if (num_32 != 0) {
1518 // use an available 32-bit field for padding
1519 num_32--;
1520 }
1521 size += sizeof(uint32_t); // either way, we are adding a word
1522 DCHECK_EQ(size, RoundUp(size, 8));
1523 }
1524 // tack on any 64-bit fields now that alignment is assured
1525 size += (num_64 * sizeof(uint64_t));
1526 // tack on any remaining 32-bit fields
1527 size += (num_32 * sizeof(uint32_t));
1528 return size;
1529}
1530
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001531OatFile::OatClass ClassLinker::GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) {
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001532 DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
Ian Rogers19846512012-02-24 11:42:47 -08001533 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001534 CHECK(oat_file != NULL) << dex_file.GetLocation();
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001535 uint dex_location_checksum = dex_file.GetLocationChecksum();
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001536 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07001537 &dex_location_checksum);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001538 CHECK(oat_dex_file != NULL) << dex_file.GetLocation();
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001539 return oat_dex_file->GetOatClass(class_def_idx);
Ian Rogers19846512012-02-24 11:42:47 -08001540}
1541
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001542static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint16_t class_def_idx,
1543 uint32_t method_idx) {
1544 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
1545 const byte* class_data = dex_file.GetClassData(class_def);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001546 CHECK(class_data != NULL);
1547 ClassDataItemIterator it(dex_file, class_data);
1548 // Skip fields
1549 while (it.HasNextStaticField()) {
1550 it.Next();
1551 }
1552 while (it.HasNextInstanceField()) {
1553 it.Next();
1554 }
1555 // Process methods
1556 size_t class_def_method_index = 0;
1557 while (it.HasNextDirectMethod()) {
1558 if (it.GetMemberIndex() == method_idx) {
1559 return class_def_method_index;
1560 }
1561 class_def_method_index++;
1562 it.Next();
1563 }
1564 while (it.HasNextVirtualMethod()) {
1565 if (it.GetMemberIndex() == method_idx) {
1566 return class_def_method_index;
1567 }
1568 class_def_method_index++;
1569 it.Next();
1570 }
1571 DCHECK(!it.HasNext());
1572 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
1573 return 0;
1574}
1575
Ian Rogersef7d42f2014-01-06 12:55:46 -08001576const OatFile::OatMethod ClassLinker::GetOatMethodFor(mirror::ArtMethod* method) {
Ian Rogers19846512012-02-24 11:42:47 -08001577 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08001578 // method for direct methods (or virtual methods made direct).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001579 mirror::Class* declaring_class = method->GetDeclaringClass();
Ian Rogersfb6adba2012-03-04 21:51:51 -08001580 size_t oat_method_index;
1581 if (method->IsStatic() || method->IsDirect()) {
1582 // Simple case where the oat method index was stashed at load time.
1583 oat_method_index = method->GetMethodIndex();
1584 } else {
1585 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
1586 // by search for its position in the declared virtual methods.
1587 oat_method_index = declaring_class->NumDirectMethods();
1588 size_t end = declaring_class->NumVirtualMethods();
1589 bool found = false;
1590 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08001591 if (declaring_class->GetVirtualMethod(i) == method) {
1592 found = true;
1593 break;
1594 }
Ian Rogersf320b632012-03-13 18:47:47 -07001595 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08001596 }
1597 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
1598 }
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001599 DCHECK_EQ(oat_method_index,
1600 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001601 method->GetDeclaringClass()->GetDexClassDefIndex(),
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001602 method->GetDexMethodIndex()));
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001603 const OatFile::OatClass oat_class = GetOatClass(*declaring_class->GetDexCache()->GetDexFile(),
1604 declaring_class->GetDexClassDefIndex());
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001605
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001606 return oat_class.GetOatMethod(oat_method_index);
TDYa12785321912012-04-01 15:24:56 -07001607}
1608
1609// Special case to get oat code without overwriting a trampoline.
Ian Rogersef7d42f2014-01-06 12:55:46 -08001610const void* ClassLinker::GetQuickOatCodeFor(mirror::ArtMethod* method) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001611 CHECK(!method->IsAbstract()) << PrettyMethod(method);
Jeff Hao8df6cea2013-07-29 13:54:48 -07001612 if (method->IsProxyMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001613 return GetQuickProxyInvokeHandler();
Jeff Hao8df6cea2013-07-29 13:54:48 -07001614 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001615 const void* result = GetOatMethodFor(method).GetQuickCode();
1616 if (result == nullptr) {
Ian Rogers1a570662014-03-12 01:02:21 -07001617 if (method->IsNative()) {
1618 // No code and native? Use generic trampoline.
1619 result = GetQuickGenericJniTrampoline();
1620 } else if (method->IsPortableCompiled()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001621 // No code? Do we expect portable code?
1622 result = GetQuickToPortableBridge();
1623 } else {
1624 // No code? You must mean to go into the interpreter.
1625 result = GetQuickToInterpreterBridge();
1626 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001627 }
1628 return result;
TDYa12785321912012-04-01 15:24:56 -07001629}
1630
Ian Rogersef7d42f2014-01-06 12:55:46 -08001631const void* ClassLinker::GetPortableOatCodeFor(mirror::ArtMethod* method,
1632 bool* have_portable_code) {
1633 CHECK(!method->IsAbstract()) << PrettyMethod(method);
1634 *have_portable_code = false;
1635 if (method->IsProxyMethod()) {
1636 return GetPortableProxyInvokeHandler();
1637 }
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01001638 const OatFile::OatMethod oat_method = GetOatMethodFor(method);
1639 const void* result = oat_method.GetPortableCode();
Ian Rogersef7d42f2014-01-06 12:55:46 -08001640 if (result == nullptr) {
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01001641 if (oat_method.GetQuickCode() == nullptr) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001642 // No code? You must mean to go into the interpreter.
1643 result = GetPortableToInterpreterBridge();
1644 } else {
1645 // No code? But there's quick code, so use a bridge.
1646 result = GetPortableToQuickBridge();
1647 }
1648 } else {
1649 *have_portable_code = true;
1650 }
1651 return result;
1652}
1653
1654const void* ClassLinker::GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
1655 uint32_t method_idx) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001656 const OatFile::OatClass oat_class = GetOatClass(dex_file, class_def_idx);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001657 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001658 return oat_class.GetOatMethod(oat_method_idx).GetQuickCode();
Ian Rogersef7d42f2014-01-06 12:55:46 -08001659}
1660
1661const void* ClassLinker::GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
1662 uint32_t method_idx) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001663 const OatFile::OatClass oat_class = GetOatClass(dex_file, class_def_idx);
Ian Rogersef7d42f2014-01-06 12:55:46 -08001664 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001665 return oat_class.GetOatMethod(oat_method_idx).GetPortableCode();
Mathieu Chartiere35517a2012-10-30 18:49:55 -07001666}
1667
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001668// Returns true if the method must run with interpreter, false otherwise.
Ian Rogersef7d42f2014-01-06 12:55:46 -08001669static bool NeedsInterpreter(mirror::ArtMethod* method, const void* quick_code,
1670 const void* portable_code) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1671 if ((quick_code == nullptr) && (portable_code == nullptr)) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001672 // No code: need interpreter.
Andreas Gampe2da88232014-02-27 12:26:20 -08001673 // May return true for native code, in the case of generic JNI
1674 // DCHECK(!method->IsNative());
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001675 return true;
1676 }
Dragos Sbirlea90af14d2013-08-15 17:50:16 -07001677#ifdef ART_SEA_IR_MODE
1678 ScopedObjectAccess soa(Thread::Current());
1679 if (std::string::npos != PrettyMethod(method).find("fibonacci")) {
1680 LOG(INFO) << "Found " << PrettyMethod(method);
1681 return false;
1682 }
1683#endif
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001684 // If interpreter mode is enabled, every method (except native and proxy) must
1685 // be run with interpreter.
1686 return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
1687 !method->IsNative() && !method->IsProxyMethod();
1688}
1689
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001690void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
Brian Carlstrom073278c2014-02-19 15:21:21 -08001691 DCHECK(klass->IsInitialized()) << PrettyDescriptor(klass);
Ian Rogers1c829822013-09-30 18:18:50 -07001692 if (klass->NumDirectMethods() == 0) {
1693 return; // No direct methods => no static methods.
Ian Rogers19846512012-02-24 11:42:47 -08001694 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001695 Runtime* runtime = Runtime::Current();
1696 if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
Ian Rogers1c829822013-09-30 18:18:50 -07001697 return; // OAT file unavailable.
Ian Rogers19846512012-02-24 11:42:47 -08001698 }
Ian Rogers1c829822013-09-30 18:18:50 -07001699 ClassHelper kh(klass);
1700 const DexFile& dex_file = kh.GetDexFile();
1701 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
1702 CHECK(dex_class_def != nullptr);
1703 const byte* class_data = dex_file.GetClassData(*dex_class_def);
1704 // There should always be class data if there were direct methods.
1705 CHECK(class_data != nullptr) << PrettyDescriptor(klass);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001706 const OatFile::OatClass oat_class = GetOatClass(dex_file, klass->GetDexClassDefIndex());
Ian Rogers19846512012-02-24 11:42:47 -08001707 ClassDataItemIterator it(dex_file, class_data);
1708 // Skip fields
1709 while (it.HasNextStaticField()) {
1710 it.Next();
1711 }
1712 while (it.HasNextInstanceField()) {
1713 it.Next();
1714 }
Ian Rogers1c829822013-09-30 18:18:50 -07001715 // Link the code of methods skipped by LinkCode.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001716 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001717 mirror::ArtMethod* method = klass->GetDirectMethod(method_index);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001718 if (!method->IsStatic()) {
1719 // Only update static methods.
1720 continue;
Ian Rogers19846512012-02-24 11:42:47 -08001721 }
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001722 const void* portable_code = oat_class.GetOatMethod(method_index).GetPortableCode();
1723 const void* quick_code = oat_class.GetOatMethod(method_index).GetQuickCode();
Ian Rogersef7d42f2014-01-06 12:55:46 -08001724 const bool enter_interpreter = NeedsInterpreter(method, quick_code, portable_code);
1725 bool have_portable_code = false;
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001726 if (enter_interpreter) {
1727 // Use interpreter entry point.
Ian Rogers1a570662014-03-12 01:02:21 -07001728 // Check whether the method is native, in which case it's generic JNI.
Andreas Gampe2da88232014-02-27 12:26:20 -08001729 if (quick_code == nullptr && portable_code == nullptr && method->IsNative()) {
1730 quick_code = GetQuickGenericJniTrampoline();
Ian Rogers1a570662014-03-12 01:02:21 -07001731 portable_code = GetPortableToQuickBridge();
Andreas Gampe2da88232014-02-27 12:26:20 -08001732 } else {
Ian Rogers1a570662014-03-12 01:02:21 -07001733 portable_code = GetPortableToInterpreterBridge();
Andreas Gampe2da88232014-02-27 12:26:20 -08001734 quick_code = GetQuickToInterpreterBridge();
1735 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001736 } else {
1737 if (portable_code == nullptr) {
1738 portable_code = GetPortableToQuickBridge();
1739 } else {
1740 have_portable_code = true;
1741 }
1742 if (quick_code == nullptr) {
1743 quick_code = GetQuickToPortableBridge();
1744 }
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001745 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001746 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code, portable_code,
1747 have_portable_code);
Ian Rogers19846512012-02-24 11:42:47 -08001748 }
Ian Rogers62d6c772013-02-27 08:32:07 -08001749 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08001750}
1751
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001752static void LinkCode(const SirtRef<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
Andreas Gampe90546832014-03-12 18:07:19 -07001753 const DexFile& dex_file, uint32_t dex_method_index, uint32_t method_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001754 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001755 // Method shouldn't have already been linked.
Ian Rogersef7d42f2014-01-06 12:55:46 -08001756 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
1757 DCHECK(method->GetEntryPointFromPortableCompiledCode() == nullptr);
Brian Carlstrom92827a52011-10-10 15:50:01 -07001758 // Every kind of method should at least get an invoke stub from the oat_method.
1759 // non-abstract methods also get their code pointers.
1760 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
Brian Carlstrom265091e2013-01-30 14:08:26 -08001761 oat_method.LinkMethod(method.get());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001762
Jeff Hao16743632013-05-08 10:59:04 -07001763 // Install entry point from interpreter.
Jeff Hao790ad902013-05-22 15:02:08 -07001764 Runtime* runtime = Runtime::Current();
Ian Rogersef7d42f2014-01-06 12:55:46 -08001765 bool enter_interpreter = NeedsInterpreter(method.get(),
1766 method->GetEntryPointFromQuickCompiledCode(),
1767 method->GetEntryPointFromPortableCompiledCode());
Andreas Gampebf6b92a2014-03-05 16:11:04 -08001768 if (enter_interpreter && !method->IsNative()) {
Ian Rogers848871b2013-08-05 10:56:33 -07001769 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001770 } else {
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07001771 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Jeff Hao16743632013-05-08 10:59:04 -07001772 }
1773
Brian Carlstrom92827a52011-10-10 15:50:01 -07001774 if (method->IsAbstract()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001775 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
1776 method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
Brian Carlstrom92827a52011-10-10 15:50:01 -07001777 return;
1778 }
Ian Rogers19846512012-02-24 11:42:47 -08001779
Ian Rogersef7d42f2014-01-06 12:55:46 -08001780 bool have_portable_code = false;
Ian Rogers19846512012-02-24 11:42:47 -08001781 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001782 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001783 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
1784 // after initializing class (see ClassLinker::InitializeClass method).
Ian Rogersef7d42f2014-01-06 12:55:46 -08001785 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionTrampoline(runtime->GetClassLinker()));
1786 method->SetEntryPointFromPortableCompiledCode(GetPortableResolutionTrampoline(runtime->GetClassLinker()));
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02001787 } else if (enter_interpreter) {
Andreas Gampebf6b92a2014-03-05 16:11:04 -08001788 if (!method->IsNative()) {
1789 // Set entry point from compiled code if there's no code or in interpreter only mode.
1790 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
1791 method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
1792 } else {
1793 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniTrampoline());
1794 method->SetEntryPointFromPortableCompiledCode(GetPortableToQuickBridge());
1795 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001796 } else if (method->GetEntryPointFromPortableCompiledCode() != nullptr) {
1797 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
1798 have_portable_code = true;
1799 method->SetEntryPointFromQuickCompiledCode(GetQuickToPortableBridge());
1800 } else {
1801 DCHECK(method->GetEntryPointFromQuickCompiledCode() != nullptr);
1802 method->SetEntryPointFromPortableCompiledCode(GetPortableToQuickBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08001803 }
jeffhao26c0a1a2012-01-17 16:28:33 -08001804
Ian Rogers62d6c772013-02-27 08:32:07 -08001805 if (method->IsNative()) {
1806 // Unregistering restores the dlsym lookup stub.
1807 method->UnregisterNative(Thread::Current());
Andreas Gampe90546832014-03-12 18:07:19 -07001808
1809 if (enter_interpreter) {
1810 // We have a native method here without code. Then it should have either the GenericJni
1811 // trampoline as entrypoint (non-static), or the Resolution trampoline (static).
1812 DCHECK(method->GetEntryPointFromQuickCompiledCode() ==
1813 GetQuickResolutionTrampoline(runtime->GetClassLinker())
Andreas Gampe9a6a99a2014-03-14 07:52:20 -07001814 || method->GetEntryPointFromQuickCompiledCode() == GetQuickGenericJniTrampoline());
Andreas Gampe90546832014-03-12 18:07:19 -07001815
1816 DCHECK_EQ(method->GetFrameSizeInBytes<false>(), 0U);
1817
1818 // Fix up method metadata if necessary.
Andreas Gampe9a6a99a2014-03-14 07:52:20 -07001819 uint32_t s_len;
1820 const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(dex_method_index), &s_len);
1821 uint32_t refs = 1; // Native method always has "this" or class.
1822 for (uint32_t i = 1; i < s_len; ++i) {
1823 if (shorty[i] == 'L') {
1824 refs++;
Andreas Gampe90546832014-03-12 18:07:19 -07001825 }
Andreas Gampe90546832014-03-12 18:07:19 -07001826 }
Andreas Gampe9a6a99a2014-03-14 07:52:20 -07001827 size_t sirt_size = StackIndirectReferenceTable::GetAlignedSirtSize(refs);
1828
1829 // Get the generic spill masks and base frame size.
1830 mirror::ArtMethod* callee_save_method =
1831 Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
1832
1833 method->SetFrameSizeInBytes(callee_save_method->GetFrameSizeInBytes() + sirt_size);
1834 method->SetCoreSpillMask(callee_save_method->GetCoreSpillMask());
1835 method->SetFpSpillMask(callee_save_method->GetFpSpillMask());
Andreas Gampe90546832014-03-12 18:07:19 -07001836 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07001837 }
Ian Rogersf3e98552013-03-20 15:49:49 -07001838
Ian Rogers62d6c772013-02-27 08:32:07 -08001839 // Allow instrumentation its chance to hijack code.
Jeff Haoaa4a7932013-05-13 11:28:27 -07001840 runtime->GetInstrumentation()->UpdateMethodsCode(method.get(),
Ian Rogersef7d42f2014-01-06 12:55:46 -08001841 method->GetEntryPointFromQuickCompiledCode(),
1842 method->GetEntryPointFromPortableCompiledCode(),
1843 have_portable_code);
Brian Carlstrom92827a52011-10-10 15:50:01 -07001844}
1845
Brian Carlstromf615a612011-07-23 12:50:34 -07001846void ClassLinker::LoadClass(const DexFile& dex_file,
1847 const DexFile::ClassDef& dex_class_def,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001848 const SirtRef<mirror::Class>& klass,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001849 mirror::ClassLoader* class_loader) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001850 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001851 CHECK(klass->GetDexCache() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001852 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07001853 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001854 CHECK(descriptor != NULL);
1855
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001856 klass->SetClass(GetClassRoot(kJavaLangClass));
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -07001857 if (kUseBakerOrBrooksReadBarrier) {
1858 klass->AssertReadBarrierPointer();
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -08001859 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001860 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07001861 // Make sure that none of our runtime-only flags are set.
Brian Carlstrom8e3fb142013-10-09 21:00:27 -07001862 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001863 klass->SetAccessFlags(access_flags);
1864 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08001865 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001866 klass->SetStatus(mirror::Class::kStatusIdx, NULL);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001867
Ian Rogers8b2c0b92013-09-19 02:56:49 -07001868 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001869 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001870
Ian Rogers0571d352011-11-03 19:51:38 -07001871 const byte* class_data = dex_file.GetClassData(dex_class_def);
1872 if (class_data == NULL) {
1873 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07001874 }
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001875
1876 if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
1877 const OatFile::OatClass oat_class = GetOatClass(dex_file, klass->GetDexClassDefIndex());
1878 LoadClassMembers(dex_file, class_data, klass, class_loader, &oat_class);
1879 } else {
1880 LoadClassMembers(dex_file, class_data, klass, class_loader, nullptr);
1881 }
1882}
1883
1884void ClassLinker::LoadClassMembers(const DexFile& dex_file,
1885 const byte* class_data,
1886 const SirtRef<mirror::Class>& klass,
1887 mirror::ClassLoader* class_loader,
1888 const OatFile::OatClass* oat_class) {
1889 // Load fields.
Ian Rogers0571d352011-11-03 19:51:38 -07001890 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07001891 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07001892 if (it.NumStaticFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001893 mirror::ObjectArray<mirror::ArtField>* statics = AllocArtFieldArray(self, it.NumStaticFields());
1894 if (UNLIKELY(statics == NULL)) {
1895 CHECK(self->IsExceptionPending()); // OOME.
1896 return;
1897 }
1898 klass->SetSFields(statics);
Ian Rogers0571d352011-11-03 19:51:38 -07001899 }
1900 if (it.NumInstanceFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001901 mirror::ObjectArray<mirror::ArtField>* fields =
1902 AllocArtFieldArray(self, it.NumInstanceFields());
1903 if (UNLIKELY(fields == NULL)) {
1904 CHECK(self->IsExceptionPending()); // OOME.
1905 return;
1906 }
1907 klass->SetIFields(fields);
Ian Rogers0571d352011-11-03 19:51:38 -07001908 }
1909 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001910 SirtRef<mirror::ArtField> sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07001911 if (UNLIKELY(sfield.get() == NULL)) {
1912 CHECK(self->IsExceptionPending()); // OOME.
1913 return;
1914 }
Ian Rogers0571d352011-11-03 19:51:38 -07001915 klass->SetStaticField(i, sfield.get());
1916 LoadField(dex_file, it, klass, sfield);
1917 }
1918 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001919 SirtRef<mirror::ArtField> ifield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07001920 if (UNLIKELY(ifield.get() == NULL)) {
1921 CHECK(self->IsExceptionPending()); // OOME.
1922 return;
1923 }
Ian Rogers0571d352011-11-03 19:51:38 -07001924 klass->SetInstanceField(i, ifield.get());
1925 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001926 }
1927
Ian Rogers0571d352011-11-03 19:51:38 -07001928 // Load methods.
1929 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07001930 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07001931 mirror::ObjectArray<mirror::ArtMethod>* directs =
1932 AllocArtMethodArray(self, it.NumDirectMethods());
1933 if (UNLIKELY(directs == NULL)) {
1934 CHECK(self->IsExceptionPending()); // OOME.
1935 return;
1936 }
1937 klass->SetDirectMethods(directs);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001938 }
Ian Rogers0571d352011-11-03 19:51:38 -07001939 if (it.NumVirtualMethods() != 0) {
1940 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07001941 mirror::ObjectArray<mirror::ArtMethod>* virtuals =
1942 AllocArtMethodArray(self, it.NumVirtualMethods());
1943 if (UNLIKELY(virtuals == NULL)) {
1944 CHECK(self->IsExceptionPending()); // OOME.
1945 return;
1946 }
1947 klass->SetVirtualMethods(virtuals);
Brian Carlstrom934486c2011-07-12 23:42:50 -07001948 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001949 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001950 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001951 SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogersa436fde2013-08-27 23:34:06 -07001952 if (UNLIKELY(method.get() == NULL)) {
1953 CHECK(self->IsExceptionPending()); // OOME.
1954 return;
1955 }
Ian Rogers0571d352011-11-03 19:51:38 -07001956 klass->SetDirectMethod(i, method.get());
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001957 if (oat_class != nullptr) {
1958 LinkCode(method, oat_class, dex_file, it.GetMemberIndex(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001959 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001960 method->SetMethodIndex(class_def_method_index);
1961 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001962 }
1963 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001964 SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
Ian Rogersa436fde2013-08-27 23:34:06 -07001965 if (UNLIKELY(method.get() == NULL)) {
1966 CHECK(self->IsExceptionPending()); // OOME.
1967 return;
1968 }
Ian Rogers0571d352011-11-03 19:51:38 -07001969 klass->SetVirtualMethod(i, method.get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08001970 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01001971 if (oat_class != nullptr) {
1972 LinkCode(method, oat_class, dex_file, it.GetMemberIndex(), class_def_method_index);
Ian Rogers0571d352011-11-03 19:51:38 -07001973 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08001974 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07001975 }
1976 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001977}
1978
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001979void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001980 const SirtRef<mirror::Class>& klass,
1981 const SirtRef<mirror::ArtField>& dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001982 uint32_t field_idx = it.GetMemberIndex();
1983 dst->SetDexFieldIndex(field_idx);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001984 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07001985 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07001986}
1987
Brian Carlstromea46f952013-07-30 01:26:50 -07001988mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
Ian Rogersa436fde2013-08-27 23:34:06 -07001989 const ClassDataItemIterator& it,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001990 const SirtRef<mirror::Class>& klass) {
Ian Rogers19846512012-02-24 11:42:47 -08001991 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08001992 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07001993 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07001994
Brian Carlstromea46f952013-07-30 01:26:50 -07001995 mirror::ArtMethod* dst = AllocArtMethod(self);
Ian Rogersa436fde2013-08-27 23:34:06 -07001996 if (UNLIKELY(dst == NULL)) {
1997 CHECK(self->IsExceptionPending()); // OOME.
1998 return NULL;
1999 }
Brian Carlstromea46f952013-07-30 01:26:50 -07002000 DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002001
Ian Rogers50b35e22012-10-04 10:09:15 -07002002 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07002003 dst->SetDexMethodIndex(dex_method_idx);
2004 dst->SetDeclaringClass(klass.get());
Ian Rogers0571d352011-11-03 19:51:38 -07002005 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Brian Carlstrom934486c2011-07-12 23:42:50 -07002006
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002007 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08002008 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002009 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002010
Ian Rogers241b5de2013-10-09 17:58:57 -07002011 uint32_t access_flags = it.GetMemberAccessFlags();
2012
Ian Rogersdfb325e2013-10-30 01:00:44 -07002013 if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07002014 // Set finalizable flag on declaring class.
Ian Rogersdfb325e2013-10-30 01:00:44 -07002015 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
2016 // Void return type.
2017 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged
2018 klass->SetFinalizable();
2019 } else {
2020 ClassHelper kh(klass.get());
2021 const char* klass_descriptor = kh.GetDescriptor();
2022 // The Enum class declares a "final" finalize() method to prevent subclasses from
2023 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
2024 // subclasses, so we exclude it here.
2025 // We also want to avoid setting the flag on Object, where we know that finalize() is
2026 // empty.
2027 if ((strcmp("Ljava/lang/Object;", klass_descriptor) != 0) &&
2028 (strcmp("Ljava/lang/Enum;", klass_descriptor) != 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07002029 klass->SetFinalizable();
Ian Rogers241b5de2013-10-09 17:58:57 -07002030 }
2031 }
2032 }
2033 } else if (method_name[0] == '<') {
2034 // Fix broken access flags for initializers. Bug 11157540.
Ian Rogersdfb325e2013-10-30 01:00:44 -07002035 bool is_init = (strcmp("<init>", method_name) == 0);
2036 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
Ian Rogers241b5de2013-10-09 17:58:57 -07002037 if (UNLIKELY(!is_init && !is_clinit)) {
2038 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
2039 } else {
2040 if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
2041 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
2042 << PrettyDescriptor(klass.get()) << " in dex file " << dex_file.GetLocation();
2043 access_flags |= kAccConstructor;
2044 }
2045 }
2046 }
2047 dst->SetAccessFlags(access_flags);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002048
Ian Rogers50b35e22012-10-04 10:09:15 -07002049 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002050 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07002051}
2052
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002053void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07002054 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002055 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Ian Rogersa436fde2013-08-27 23:34:06 -07002056 CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002057 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07002058}
2059
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002060void ClassLinker::AppendToBootClassPath(const DexFile& dex_file,
2061 const SirtRef<mirror::DexCache>& dex_cache) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002062 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002063 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07002064 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002065}
2066
Brian Carlstromaded5f72011-10-07 17:15:04 -07002067bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002068 dex_lock_.AssertSharedHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002069 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2070 if (dex_caches_[i]->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08002071 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002072 }
2073 }
2074 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07002075}
2076
Brian Carlstromaded5f72011-10-07 17:15:04 -07002077bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002078 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07002079 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002080}
2081
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002082void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file,
2083 const SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002084 dex_lock_.AssertExclusiveHeld(Thread::Current());
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002085 CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -07002086 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()))
2087 << dex_cache->GetLocation()->ToModifiedUtf8() << " " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002088 dex_caches_.push_back(dex_cache.get());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002089 dex_cache->SetDexFile(&dex_file);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002090 if (log_new_dex_caches_roots_) {
2091 // TODO: This is not safe if we can remove dex caches.
2092 new_dex_cache_roots_.push_back(dex_caches_.size() - 1);
2093 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002094}
2095
Brian Carlstromaded5f72011-10-07 17:15:04 -07002096void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07002097 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002098 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002099 ReaderMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002100 if (IsDexFileRegisteredLocked(dex_file)) {
2101 return;
2102 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002103 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002104 // Don't alloc while holding the lock, since allocation may need to
2105 // suspend all threads and another thread may need the dex_lock_ to
2106 // get to a suspend point.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002107 SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
Ian Rogersa436fde2013-08-27 23:34:06 -07002108 CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002109 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002110 WriterMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002111 if (IsDexFileRegisteredLocked(dex_file)) {
2112 return;
2113 }
2114 RegisterDexFileLocked(dex_file, dex_cache);
2115 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002116}
2117
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002118void ClassLinker::RegisterDexFile(const DexFile& dex_file,
2119 const SirtRef<mirror::DexCache>& dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002120 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002121 RegisterDexFileLocked(dex_file, dex_cache);
2122}
2123
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002124mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002125 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002126 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002127 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002128 mirror::DexCache* dex_cache = dex_caches_[i];
Mathieu Chartier66f19252012-09-18 08:57:04 -07002129 if (dex_cache->GetDexFile() == &dex_file) {
2130 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002131 }
2132 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002133 // Search matching by location name.
2134 std::string location(dex_file.GetLocation());
2135 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002136 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002137 if (dex_cache->GetDexFile()->GetLocation() == location) {
2138 return dex_cache;
2139 }
2140 }
2141 // Failure, dump diagnostic and abort.
2142 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002143 mirror::DexCache* dex_cache = dex_caches_[i];
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002144 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
2145 }
2146 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002147 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002148}
2149
Brian Carlstromea46f952013-07-30 01:26:50 -07002150void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) const {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002151 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08002152 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2153 dex_caches_[i]->Fixup(resolution_method);
2154 }
2155}
2156
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002157mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002158 mirror::Class* klass = AllocClass(self, sizeof(mirror::Class));
2159 if (UNLIKELY(klass == NULL)) {
2160 return NULL;
2161 }
2162 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002163}
2164
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002165mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class,
2166 Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002167 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07002168 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002169 Thread* self = Thread::Current();
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002170 SirtRef<mirror::Class> sirt_class(self, primitive_class);
2171 ObjectLock<mirror::Class> lock(self, &sirt_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002172 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002173 primitive_class->SetPrimitiveType(type);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002174 primitive_class->SetStatus(mirror::Class::kStatusInitialized, self);
2175 const char* descriptor = Primitive::Descriptor(type);
2176 mirror::Class* existing = InsertClass(descriptor, primitive_class, Hash(descriptor));
Ian Rogersc8982582012-09-07 16:53:25 -07002177 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002178 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07002179}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002180
Brian Carlstrombe977852011-07-19 14:54:54 -07002181// Create an array class (i.e. the class object for the array, not the
2182// array itself). "descriptor" looks like "[C" or "[[[[B" or
2183// "[Ljava/lang/String;".
2184//
2185// If "descriptor" refers to an array of primitives, look up the
2186// primitive type's internally-generated class object.
2187//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002188// "class_loader" is the class loader of the class that's referring to
2189// us. It's used to ensure that we're looking for the element type in
2190// the right context. It does NOT become the class loader for the
2191// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07002192//
2193// Returns NULL with an exception raised on failure.
Ian Rogers98379392014-02-24 16:53:16 -08002194mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002195 const SirtRef<mirror::ClassLoader>& class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002196 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002197 CHECK_EQ('[', descriptor[0]);
Ian Rogers98379392014-02-24 16:53:16 -08002198 SirtRef<mirror::Class> component_type(self, FindClass(self, descriptor + 1, class_loader));
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002199 if (component_type.get() == nullptr) {
2200 DCHECK(self->IsExceptionPending());
2201 return nullptr;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002202 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002203
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002204 // See if the component type is already loaded. Array classes are
2205 // always associated with the class loader of their underlying
2206 // element type -- an array of Strings goes with the loader for
2207 // java/lang/String -- so we need to look for it there. (The
2208 // caller should have checked for the existence of the class
2209 // before calling here, but they did so with *their* class loader,
2210 // not the component type's loader.)
2211 //
2212 // If we find it, the caller adds "loader" to the class' initiating
2213 // loader list, which should prevent us from going through this again.
2214 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002215 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002216 // are the same, because our caller (FindClass) just did the
2217 // lookup. (Even if we get this wrong we still have correct behavior,
2218 // because we effectively do this lookup again when we add the new
2219 // class to the hash table --- necessary because of possible races with
2220 // other threads.)
Mathieu Chartier590fee92013-09-13 13:46:47 -07002221 if (class_loader.get() != component_type->GetClassLoader()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002222 mirror::Class* new_class = LookupClass(descriptor, component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002223 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002224 return new_class;
2225 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002226 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002227
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002228 // Fill out the fields in the Class.
2229 //
2230 // It is possible to execute some methods against arrays, because
2231 // all arrays are subclasses of java_lang_Object_, so we need to set
2232 // up a vtable. We can just point at the one in java_lang_Object_.
2233 //
2234 // Array classes are simple enough that we don't need to do a full
2235 // link step.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002236 SirtRef<mirror::Class> new_class(self, NULL);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002237 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002238 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002239 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002240 new_class.reset(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002241 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002242 new_class.reset(GetClassRoot(kObjectArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002243 } else if (strcmp(descriptor, class_roots_descriptors_[kJavaLangStringArrayClass]) == 0) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002244 new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002245 } else if (strcmp(descriptor,
2246 class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002247 new_class.reset(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002248 } else if (strcmp(descriptor,
2249 class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) == 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002250 new_class.reset(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002251 } else if (strcmp(descriptor, "[C") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002252 new_class.reset(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002253 } else if (strcmp(descriptor, "[I") == 0) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002254 new_class.reset(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002255 }
2256 }
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002257 if (new_class.get() == nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002258 new_class.reset(AllocClass(self, sizeof(mirror::Class)));
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002259 if (new_class.get() == nullptr) {
2260 return nullptr;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002261 }
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002262 new_class->SetComponentType(component_type.get());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002263 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002264 ObjectLock<mirror::Class> lock(self, &new_class); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002265 DCHECK(new_class->GetComponentType() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002266 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002267 new_class->SetSuperClass(java_lang_Object);
2268 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002269 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002270 new_class->SetClassLoader(component_type->GetClassLoader());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002271 new_class->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002272 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002273 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002274
2275
2276 // All arrays have java/lang/Cloneable and java/io/Serializable as
2277 // interfaces. We need to set that up here, so that stuff like
2278 // "instanceof" works right.
2279 //
2280 // Note: The GC could run during the call to FindSystemClass,
2281 // so we need to make sure the class object is GC-valid while we're in
2282 // there. Do this by clearing the interface list so the GC will just
2283 // think that the entries are null.
2284
2285
2286 // Use the single, global copies of "interfaces" and "iftable"
2287 // (remember not to free them for arrays).
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002288 CHECK(array_iftable_ != nullptr);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07002289 new_class->SetIfTable(array_iftable_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002290
Elliott Hughes00626c22013-06-14 15:04:14 -07002291 // Inherit access flags from the component type.
2292 int access_flags = new_class->GetComponentType()->GetAccessFlags();
2293 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2294 access_flags &= kAccJavaFlagsMask;
2295 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002296 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07002297 access_flags |= kAccAbstract | kAccFinal;
2298 access_flags &= ~kAccInterface;
2299
2300 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002301
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002302 mirror::Class* existing = InsertClass(descriptor, new_class.get(), Hash(descriptor));
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002303 if (existing == nullptr) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002304 return new_class.get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002305 }
2306 // Another thread must have loaded the class after we
2307 // started but before we finished. Abandon what we've
2308 // done.
2309 //
2310 // (Yes, this happens.)
2311
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002312 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002313}
2314
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002315mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Ian Rogers62f05122014-03-21 11:21:29 -07002316 switch (type) {
2317 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002318 return GetClassRoot(kPrimitiveByte);
Ian Rogers62f05122014-03-21 11:21:29 -07002319 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002320 return GetClassRoot(kPrimitiveChar);
Ian Rogers62f05122014-03-21 11:21:29 -07002321 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002322 return GetClassRoot(kPrimitiveDouble);
Ian Rogers62f05122014-03-21 11:21:29 -07002323 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002324 return GetClassRoot(kPrimitiveFloat);
Ian Rogers62f05122014-03-21 11:21:29 -07002325 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002326 return GetClassRoot(kPrimitiveInt);
Ian Rogers62f05122014-03-21 11:21:29 -07002327 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002328 return GetClassRoot(kPrimitiveLong);
Ian Rogers62f05122014-03-21 11:21:29 -07002329 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002330 return GetClassRoot(kPrimitiveShort);
Ian Rogers62f05122014-03-21 11:21:29 -07002331 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002332 return GetClassRoot(kPrimitiveBoolean);
Ian Rogers62f05122014-03-21 11:21:29 -07002333 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002334 return GetClassRoot(kPrimitiveVoid);
Ian Rogers62f05122014-03-21 11:21:29 -07002335 default:
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002336 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002337 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002338 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002339 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002340 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002341}
2342
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002343mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass,
2344 size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002345 if (VLOG_IS_ON(class_linker)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002346 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08002347 std::string source;
2348 if (dex_cache != NULL) {
2349 source += " from ";
2350 source += dex_cache->GetLocation()->ToModifiedUtf8();
2351 }
2352 LOG(INFO) << "Loaded class " << descriptor << source;
2353 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002354 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers1d54e732013-05-02 21:10:01 -07002355 mirror::Class* existing =
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002356 LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002357 if (existing != NULL) {
2358 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07002359 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002360 if (kIsDebugBuild && klass->GetClassLoader() == NULL && dex_cache_image_class_lookup_required_) {
2361 // Check a class loaded with the system class loader matches one in the image if the class
2362 // is in the image.
2363 existing = LookupClassFromImage(descriptor);
2364 if (existing != NULL) {
2365 CHECK(klass == existing);
2366 }
2367 }
Mathieu Chartier4e305412014-02-19 10:54:44 -08002368 VerifyObject(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002369 class_table_.insert(std::make_pair(hash, klass));
Mathieu Chartier893263b2014-03-04 11:07:42 -08002370 if (log_new_class_table_roots_) {
2371 new_class_roots_.push_back(std::make_pair(hash, klass));
2372 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002373 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002374}
2375
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002376bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002377 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002378 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002379 for (auto it = class_table_.lower_bound(hash), end = class_table_.end(); it != end && it->first == hash;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002380 ++it) {
2381 mirror::Class* klass = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002382 ClassHelper kh(klass);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002383 if ((klass->GetClassLoader() == class_loader) &&
2384 (strcmp(descriptor, kh.GetDescriptor()) == 0)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002385 class_table_.erase(it);
Brian Carlstromae826982011-11-09 01:33:42 -08002386 return true;
2387 }
2388 }
2389 return false;
2390}
2391
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002392mirror::Class* ClassLinker::LookupClass(const char* descriptor,
2393 const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002394 size_t hash = Hash(descriptor);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002395 {
2396 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
2397 mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
2398 if (result != NULL) {
2399 return result;
2400 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07002401 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002402 if (class_loader != NULL || !dex_cache_image_class_lookup_required_) {
2403 return NULL;
2404 } else {
2405 // Lookup failed but need to search dex_caches_.
2406 mirror::Class* result = LookupClassFromImage(descriptor);
2407 if (result != NULL) {
2408 InsertClass(descriptor, result, hash);
2409 } else {
2410 // Searching the image dex files/caches failed, we don't want to get into this situation
2411 // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image
2412 // classes into the class table.
2413 const int32_t kMaxFailedDexCacheLookups = 1000;
2414 if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) {
2415 MoveImageClassesToClassTable();
2416 }
2417 }
2418 return result;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002419 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002420}
2421
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002422mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor,
2423 const mirror::ClassLoader* class_loader,
2424 size_t hash) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002425 auto end = class_table_.end();
2426 for (auto it = class_table_.lower_bound(hash); it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002427 mirror::Class* klass = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002428 ClassHelper kh(klass);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002429 if ((klass->GetClassLoader() == class_loader) &&
2430 (strcmp(descriptor, kh.GetDescriptor()) == 0)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002431 if (kIsDebugBuild) {
2432 // Check for duplicates in the table.
2433 for (++it; it != end && it->first == hash; ++it) {
2434 mirror::Class* klass2 = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002435 ClassHelper kh(klass2);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002436 CHECK(!((klass2->GetClassLoader() == class_loader) &&
2437 (strcmp(descriptor, kh.GetDescriptor()) == 0)))
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002438 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
2439 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002440 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002441 }
Ian Rogers5d76c432011-10-31 21:42:49 -07002442 return klass;
2443 }
2444 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002445 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002446}
2447
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002448static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches()
2449 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2450 gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
2451 CHECK(image != NULL);
2452 mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
2453 return root->AsObjectArray<mirror::DexCache>();
2454}
2455
2456void ClassLinker::MoveImageClassesToClassTable() {
2457 Thread* self = Thread::Current();
2458 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2459 if (!dex_cache_image_class_lookup_required_) {
2460 return; // All dex cache classes are already in the class table.
2461 }
2462 const char* old_no_suspend_cause =
2463 self->StartAssertNoThreadSuspension("Moving image classes to class table");
2464 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002465 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
2466 mirror::DexCache* dex_cache = dex_caches->Get(i);
2467 mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes();
2468 for (int32_t j = 0; j < types->GetLength(); j++) {
2469 mirror::Class* klass = types->Get(j);
2470 if (klass != NULL) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002471 ClassHelper kh(klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002472 DCHECK(klass->GetClassLoader() == NULL);
2473 const char* descriptor = kh.GetDescriptor();
2474 size_t hash = Hash(descriptor);
2475 mirror::Class* existing = LookupClassFromTableLocked(descriptor, NULL, hash);
2476 if (existing != NULL) {
2477 CHECK(existing == klass) << PrettyClassAndClassLoader(existing) << " != "
2478 << PrettyClassAndClassLoader(klass);
2479 } else {
2480 class_table_.insert(std::make_pair(hash, klass));
Mathieu Chartier893263b2014-03-04 11:07:42 -08002481 if (log_new_class_table_roots_) {
2482 new_class_roots_.push_back(std::make_pair(hash, klass));
2483 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002484 }
2485 }
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002486 }
2487 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002488 dex_cache_image_class_lookup_required_ = false;
2489 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2490}
2491
2492mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
2493 Thread* self = Thread::Current();
2494 const char* old_no_suspend_cause =
2495 self->StartAssertNoThreadSuspension("Image class lookup");
2496 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
2497 for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
2498 mirror::DexCache* dex_cache = dex_caches->Get(i);
2499 const DexFile* dex_file = dex_cache->GetDexFile();
Vladimir Marko801a8112014-01-06 14:28:16 +00002500 // Try binary searching the string/type index.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002501 const DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
2502 if (string_id != NULL) {
2503 const DexFile::TypeId* type_id =
2504 dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
2505 if (type_id != NULL) {
2506 uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id);
2507 mirror::Class* klass = dex_cache->GetResolvedType(type_idx);
2508 if (klass != NULL) {
2509 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2510 return klass;
2511 }
2512 }
2513 }
2514 }
2515 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
2516 return NULL;
2517}
2518
2519void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) {
2520 result.clear();
2521 if (dex_cache_image_class_lookup_required_) {
2522 MoveImageClassesToClassTable();
2523 }
2524 size_t hash = Hash(descriptor);
2525 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002526 for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
Mathieu Chartier02e25112013-08-14 16:14:24 -07002527 it != end && it->first == hash; ++it) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002528 mirror::Class* klass = it->second;
Mathieu Chartier590fee92013-09-13 13:46:47 -07002529 ClassHelper kh(klass);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002530 if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002531 result.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08002532 }
2533 }
2534}
2535
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002536void ClassLinker::VerifyClass(const SirtRef<mirror::Class>& klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002537 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07002538 Thread* self = Thread::Current();
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002539 ObjectLock<mirror::Class> lock(self, &klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08002540
Ian Rogers9ffb0392012-09-10 11:56:50 -07002541 // Don't attempt to re-verify if already sufficiently verified.
2542 if (klass->IsVerified() ||
2543 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07002544 return;
2545 }
2546
Ian Rogers9ffb0392012-09-10 11:56:50 -07002547 // The class might already be erroneous, for example at compile time if we attempted to verify
2548 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002549 if (klass->IsErroneous()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002550 ThrowEarlierClassFailure(klass.get());
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08002551 return;
2552 }
2553
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002554 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002555 klass->SetStatus(mirror::Class::kStatusVerifying, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002556 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002557 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002558 << PrettyClass(klass.get());
Ian Rogers9ffb0392012-09-10 11:56:50 -07002559 CHECK(!Runtime::Current()->IsCompiler());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002560 klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07002561 }
jeffhao98eacac2011-09-14 16:11:53 -07002562
Jeff Hao4a200f52014-04-01 14:58:49 -07002563 // Skip verification if disabled.
2564 if (!Runtime::Current()->IsVerificationEnabled()) {
2565 klass->SetStatus(mirror::Class::kStatusVerified, self);
2566 return;
2567 }
2568
Ian Rogers9ffb0392012-09-10 11:56:50 -07002569 // Verify super class.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002570 SirtRef<mirror::Class> super(self, klass->GetSuperClass());
2571 if (super.get() != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07002572 // Acquire lock to prevent races on verifying the super class.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002573 ObjectLock<mirror::Class> lock(self, &super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002574
2575 if (!super->IsVerified() && !super->IsErroneous()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002576 VerifyClass(super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002577 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07002578 if (!super->IsCompileTimeVerified()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002579 std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002580 PrettyDescriptor(klass.get()).c_str(),
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002581 PrettyDescriptor(super.get()).c_str()));
Ian Rogers1c5eb702012-02-01 09:18:34 -08002582 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Ian Rogers62d6c772013-02-27 08:32:07 -08002583 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002584 if (cause.get() != nullptr) {
Ian Rogers1c5eb702012-02-01 09:18:34 -08002585 self->ClearException();
2586 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002587 ThrowVerifyError(klass.get(), "%s", error_msg.c_str());
2588 if (cause.get() != nullptr) {
2589 self->GetException(nullptr)->SetCause(cause.get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08002590 }
Jeff Hao22cb09b2013-12-12 14:29:15 -08002591 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex());
Vladimir Marko2b5eaa22013-12-13 13:59:30 +00002592 if (Runtime::Current()->IsCompiler()) {
2593 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref);
2594 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002595 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers1c5eb702012-02-01 09:18:34 -08002596 return;
2597 }
2598 }
2599
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002600 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07002601 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002602 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002603 bool preverified = VerifyClassUsingOatFile(dex_file, klass.get(), oat_file_class_status);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002604 if (oat_file_class_status == mirror::Class::kStatusError) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07002605 VLOG(class_linker) << "Skipping runtime verification of erroneous class "
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002606 << PrettyDescriptor(klass.get()) << " in "
Ian Rogerse6bb3b22013-08-19 21:51:45 -07002607 << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002608 ThrowVerifyError(klass.get(), "Rejecting class %s because it failed compile-time verification",
2609 PrettyDescriptor(klass.get()).c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002610 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhaoec014232012-09-05 10:42:25 -07002611 return;
2612 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002613 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
Ian Rogers62d6c772013-02-27 08:32:07 -08002614 std::string error_msg;
jeffhaof1e6b7c2012-06-05 18:33:30 -07002615 if (!preverified) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002616 verifier_failure = verifier::MethodVerifier::VerifyClass(klass.get(),
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002617 Runtime::Current()->IsCompiler(),
2618 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07002619 }
2620 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07002621 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002622 VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass.get())
Ian Rogers529781d2012-07-23 17:24:29 -07002623 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2624 << " because: " << error_msg;
2625 }
Ian Rogers1f539342012-10-03 21:09:42 -07002626 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002627 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002628 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002629 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002630 // Even though there were no verifier failures we need to respect whether the super-class
2631 // was verified or requiring runtime reverification.
2632 if (super.get() == NULL || super->IsVerified()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002633 klass->SetStatus(mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002634 } else {
2635 CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002636 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07002637 // Pretend a soft failure occured so that we don't consider the class verified below.
2638 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07002639 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002640 } else {
2641 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
2642 // Soft failures at compile time should be retried at runtime. Soft
2643 // failures at runtime will be handled by slow paths in the generated
2644 // code. Set status accordingly.
2645 if (Runtime::Current()->IsCompiler()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002646 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002647 } else {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002648 klass->SetStatus(mirror::Class::kStatusVerified, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07002649 }
2650 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07002651 } else {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002652 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass.get())
Ian Rogers1c5eb702012-02-01 09:18:34 -08002653 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
2654 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002655 self->AssertNoPendingException();
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002656 ThrowVerifyError(klass.get(), "%s", error_msg.c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002657 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07002658 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002659 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07002660 // Class is verified so we don't need to do any access check on its methods.
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02002661 // Let the interpreter know it by setting the kAccPreverified flag onto each
2662 // method.
2663 // Note: we're going here during compilation and at runtime. When we set the
2664 // kAccPreverified flag when compiling image classes, the flag is recorded
2665 // in the image and is set when loading the image.
2666 klass->SetPreverifiedFlagOnAllMethods();
2667 }
jeffhao98eacac2011-09-14 16:11:53 -07002668}
2669
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002670bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
2671 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002672 // If we're compiling, we can only verify the class using the oat file if
2673 // we are not compiling the image or if the class we're verifying is not part of
2674 // the app. In other words, we will only check for preverification of bootclasspath
2675 // classes.
2676 if (Runtime::Current()->IsCompiler()) {
2677 // Are we compiling the bootclasspath?
2678 if (!Runtime::Current()->UseCompileTimeClassPath()) {
2679 return false;
2680 }
2681 // We are compiling an app (not the image).
2682
2683 // Is this an app class? (I.e. not a bootclasspath class)
2684 if (klass->GetClassLoader() != NULL) {
2685 return false;
2686 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002687 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002688
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002689 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07002690 // Make this work with gtests, which do not set up the image properly.
2691 // TODO: we should clean up gtests to set up the image path properly.
2692 if (Runtime::Current()->IsCompiler() && (oat_file == NULL)) {
2693 return false;
2694 }
2695
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002696 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002697 uint dex_location_checksum = dex_file.GetLocationChecksum();
Ian Rogers8d31bbd2013-10-13 10:44:14 -07002698 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002699 &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002700 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002701 uint16_t class_def_index = klass->GetDexClassDefIndex();
Vladimir Markod3c5beb2014-04-11 16:32:51 +01002702 oat_file_class_status = oat_dex_file->GetOatClass(class_def_index).GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002703 if (oat_file_class_status == mirror::Class::kStatusVerified ||
2704 oat_file_class_status == mirror::Class::kStatusInitialized) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07002705 return true;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002706 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002707 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07002708 // Compile time verification failed with a soft error. Compile time verification can fail
2709 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08002710 // class ... {
2711 // Foo x;
2712 // .... () {
2713 // if (...) {
2714 // v1 gets assigned a type of resolved class Foo
2715 // } else {
2716 // v1 gets assigned a type of unresolved class Bar
2717 // }
2718 // iput x = v1
2719 // } }
2720 // when we merge v1 following the if-the-else it results in Conflict
2721 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
2722 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
2723 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
2724 // at compile time).
2725 return false;
2726 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002727 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07002728 // Compile time verification failed with a hard error. This is caused by invalid instructions
2729 // in the class. These errors are unrecoverable.
2730 return false;
2731 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002732 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08002733 // Status is uninitialized if we couldn't determine the status at compile time, for example,
2734 // not loading the class.
2735 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
2736 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002737 return false;
2738 }
Elliott Hughes634eb2e2012-03-22 16:06:28 -07002739 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002740 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " "
2741 << ClassHelper(klass).GetDescriptor();
Brian Carlstrom5b332c82012-02-01 15:02:31 -08002742
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002743 return false;
2744}
2745
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002746void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file,
2747 const SirtRef<mirror::Class>& klass) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002748 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
2749 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
2750 }
2751 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
2752 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
2753 }
2754}
2755
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002756void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
Brian Carlstromea46f952013-07-30 01:26:50 -07002757 mirror::ArtMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002758 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
2759 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
2760 if (code_item == NULL) {
2761 return; // native or abstract method
2762 }
2763 if (code_item->tries_size_ == 0) {
2764 return; // nothing to process
2765 }
2766 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
2767 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
2768 ClassLinker* linker = Runtime::Current()->GetClassLinker();
2769 for (uint32_t idx = 0; idx < handlers_size; idx++) {
2770 CatchHandlerIterator iterator(handlers_ptr);
2771 for (; iterator.HasNext(); iterator.Next()) {
2772 // Ensure exception types are resolved so that they don't need resolution to be delivered,
2773 // unresolved exception types will be ignored by exception delivery
2774 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002775 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08002776 if (exception_type == NULL) {
2777 DCHECK(Thread::Current()->IsExceptionPending());
2778 Thread::Current()->ClearException();
2779 }
2780 }
2781 }
2782 handlers_ptr = iterator.EndDataPointer();
2783 }
2784}
2785
Brian Carlstromea46f952013-07-30 01:26:50 -07002786static void CheckProxyConstructor(mirror::ArtMethod* constructor);
2787static void CheckProxyMethod(mirror::ArtMethod* method,
2788 SirtRef<mirror::ArtMethod>& prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08002789
Mathieu Chartier590fee92013-09-13 13:46:47 -07002790mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccess& soa, jstring name,
2791 jobjectArray interfaces, jobject loader,
2792 jobjectArray methods, jobjectArray throws) {
2793 Thread* self = soa.Self();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002794 SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
2795 sizeof(mirror::SynthesizedProxyClass)));
Ian Rogersa436fde2013-08-27 23:34:06 -07002796 if (klass.get() == NULL) {
2797 CHECK(self->IsExceptionPending()); // OOME.
2798 return NULL;
2799 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002800 DCHECK(klass->GetClass() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002801 klass->SetObjectSize(sizeof(mirror::Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002802 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Mathieu Chartier590fee92013-09-13 13:46:47 -07002803 klass->SetClassLoader(soa.Decode<mirror::ClassLoader*>(loader));
Ian Rogersc2b44472011-12-14 21:17:17 -08002804 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Mathieu Chartier590fee92013-09-13 13:46:47 -07002805 klass->SetName(soa.Decode<mirror::String*>(name));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002806 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002807 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002808 klass->SetStatus(mirror::Class::kStatusIdx, self);
Ian Rogersc2b44472011-12-14 21:17:17 -08002809
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002810 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogersa436fde2013-08-27 23:34:06 -07002811 {
2812 mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
2813 if (UNLIKELY(sfields == NULL)) {
2814 CHECK(self->IsExceptionPending()); // OOME.
2815 return NULL;
2816 }
2817 klass->SetSFields(sfields);
2818 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002819 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
2820 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Brian Carlstromea46f952013-07-30 01:26:50 -07002821 SirtRef<mirror::ArtField> interfaces_sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002822 if (UNLIKELY(interfaces_sfield.get() == NULL)) {
2823 CHECK(self->IsExceptionPending()); // OOME.
2824 return NULL;
2825 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002826 klass->SetStaticField(0, interfaces_sfield.get());
2827 interfaces_sfield->SetDexFieldIndex(0);
2828 interfaces_sfield->SetDeclaringClass(klass.get());
2829 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
2830 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Brian Carlstromea46f952013-07-30 01:26:50 -07002831 SirtRef<mirror::ArtField> throws_sfield(self, AllocArtField(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002832 if (UNLIKELY(throws_sfield.get() == NULL)) {
2833 CHECK(self->IsExceptionPending()); // OOME.
2834 return NULL;
2835 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002836 klass->SetStaticField(1, throws_sfield.get());
2837 throws_sfield->SetDexFieldIndex(1);
2838 throws_sfield->SetDeclaringClass(klass.get());
2839 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04002840
Ian Rogers466bb252011-10-14 03:29:56 -07002841 // Proxies have 1 direct method, the constructor
Ian Rogersa436fde2013-08-27 23:34:06 -07002842 {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002843 mirror::ObjectArray<mirror::ArtMethod>* directs = AllocArtMethodArray(self, 1);
Ian Rogersa436fde2013-08-27 23:34:06 -07002844 if (UNLIKELY(directs == NULL)) {
2845 CHECK(self->IsExceptionPending()); // OOME.
2846 return NULL;
2847 }
2848 klass->SetDirectMethods(directs);
2849 mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class);
2850 if (UNLIKELY(constructor == NULL)) {
2851 CHECK(self->IsExceptionPending()); // OOME.
2852 return NULL;
2853 }
2854 klass->SetDirectMethod(0, constructor);
2855 }
Jesse Wilson95caa792011-10-12 18:14:17 -04002856
Mathieu Chartier590fee92013-09-13 13:46:47 -07002857 // Create virtual method using specified prototypes.
2858 size_t num_virtual_methods =
2859 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods)->GetLength();
Ian Rogersa436fde2013-08-27 23:34:06 -07002860 {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002861 mirror::ObjectArray<mirror::ArtMethod>* virtuals = AllocArtMethodArray(self, num_virtual_methods);
Ian Rogersa436fde2013-08-27 23:34:06 -07002862 if (UNLIKELY(virtuals == NULL)) {
2863 CHECK(self->IsExceptionPending()); // OOME.
2864 return NULL;
2865 }
2866 klass->SetVirtualMethods(virtuals);
2867 }
Jesse Wilson95caa792011-10-12 18:14:17 -04002868 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002869 mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
2870 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
2871 SirtRef<mirror::ArtMethod> prototype(self, decoded_methods->Get(i));
Ian Rogersa436fde2013-08-27 23:34:06 -07002872 mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype);
2873 if (UNLIKELY(clone == NULL)) {
2874 CHECK(self->IsExceptionPending()); // OOME.
2875 return NULL;
2876 }
2877 klass->SetVirtualMethod(i, clone);
Jesse Wilson95caa792011-10-12 18:14:17 -04002878 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002879
2880 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002881 klass->SetStatus(mirror::Class::kStatusLoaded, self); // Class is now effectively in the loaded state
Ian Rogers62d6c772013-02-27 08:32:07 -08002882 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08002883
Ian Rogersc8982582012-09-07 16:53:25 -07002884 {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002885 ObjectLock<mirror::Class> lock(self, &klass); // Must hold lock on object when resolved.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002886 // Link the fields and virtual methods, creating vtable and iftables
Mathieu Chartier590fee92013-09-13 13:46:47 -07002887 SirtRef<mirror::ObjectArray<mirror::Class> > sirt_interfaces(
2888 self, soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2889 if (!LinkClass(self, klass, sirt_interfaces)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002890 klass->SetStatus(mirror::Class::kStatusError, self);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002891 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002892 }
2893
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002894 interfaces_sfield->SetObject<false>(klass.get(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2895 throws_sfield->SetObject<false>(klass.get(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002896 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogersc8982582012-09-07 16:53:25 -07002897 }
Ian Rogersc2b44472011-12-14 21:17:17 -08002898
2899 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07002900 if (kIsDebugBuild) {
Ian Rogersc2b44472011-12-14 21:17:17 -08002901 CHECK(klass->GetIFields() == NULL);
2902 CheckProxyConstructor(klass->GetDirectMethod(0));
2903 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002904 mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
2905 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
2906 SirtRef<mirror::ArtMethod> prototype(self, decoded_methods->Get(i));
Ian Rogersc2b44472011-12-14 21:17:17 -08002907 CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
2908 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002909
Mathieu Chartier590fee92013-09-13 13:46:47 -07002910 mirror::String* decoded_name = soa.Decode<mirror::String*>(name);
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002911 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
Mathieu Chartier590fee92013-09-13 13:46:47 -07002912 decoded_name->ToModifiedUtf8().c_str()));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002913 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
2914
2915 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
Mathieu Chartier590fee92013-09-13 13:46:47 -07002916 decoded_name->ToModifiedUtf8().c_str()));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07002917 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08002918
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002919 mirror::SynthesizedProxyClass* synth_proxy_class =
2920 down_cast<mirror::SynthesizedProxyClass*>(klass.get());
Mathieu Chartier590fee92013-09-13 13:46:47 -07002921 CHECK_EQ(synth_proxy_class->GetInterfaces(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
2922 CHECK_EQ(synth_proxy_class->GetThrows(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
Ian Rogersc2b44472011-12-14 21:17:17 -08002923 }
Mathieu Chartier31b9d662013-10-14 11:53:12 -07002924 std::string descriptor(GetDescriptorForProxy(klass.get()));
2925 mirror::Class* existing = InsertClass(descriptor.c_str(), klass.get(), Hash(descriptor.c_str()));
2926 CHECK(existing == nullptr);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002927 return klass.get();
Jesse Wilson95caa792011-10-12 18:14:17 -04002928}
2929
Ian Rogersef7d42f2014-01-06 12:55:46 -08002930std::string ClassLinker::GetDescriptorForProxy(mirror::Class* proxy_class) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002931 DCHECK(proxy_class->IsProxyClass());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002932 mirror::String* name = proxy_class->GetName();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002933 DCHECK(name != NULL);
2934 return DotToDescriptor(name->ToModifiedUtf8().c_str());
2935}
2936
Ian Rogersef7d42f2014-01-06 12:55:46 -08002937mirror::ArtMethod* ClassLinker::FindMethodForProxy(mirror::Class* proxy_class,
2938 mirror::ArtMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08002939 DCHECK(proxy_class->IsProxyClass());
2940 DCHECK(proxy_method->IsProxyMethod());
2941 // Locate the dex cache of the original interface/Object
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002942 mirror::DexCache* dex_cache = NULL;
Ian Rogers16f93672012-02-14 12:29:06 -08002943 {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002944 mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002945 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08002946 for (size_t i = 0; i != dex_caches_.size(); ++i) {
2947 if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
2948 dex_cache = dex_caches_[i];
2949 break;
2950 }
2951 }
2952 }
2953 CHECK(dex_cache != NULL);
2954 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Brian Carlstromea46f952013-07-30 01:26:50 -07002955 mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers16f93672012-02-14 12:29:06 -08002956 CHECK(resolved_method != NULL);
2957 return resolved_method;
2958}
2959
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002960
Brian Carlstromea46f952013-07-30 01:26:50 -07002961mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002962 const SirtRef<mirror::Class>& klass,
Brian Carlstromea46f952013-07-30 01:26:50 -07002963 mirror::Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07002964 // Create constructor for Proxy that must initialize h
Brian Carlstromea46f952013-07-30 01:26:50 -07002965 mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002966 proxy_class->GetDirectMethods();
Brian Carlstromea46f952013-07-30 01:26:50 -07002967 CHECK_EQ(proxy_direct_methods->GetLength(), 16);
2968 mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2);
Ian Rogers466bb252011-10-14 03:29:56 -07002969 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
2970 // code_ too)
Brian Carlstromea46f952013-07-30 01:26:50 -07002971 mirror::ArtMethod* constructor =
2972 down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07002973 if (constructor == NULL) {
2974 CHECK(self->IsExceptionPending()); // OOME.
2975 return NULL;
2976 }
Ian Rogers466bb252011-10-14 03:29:56 -07002977 // Make this constructor public and fix the class to be our Proxy version
2978 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002979 constructor->SetDeclaringClass(klass.get());
Ian Rogersc2b44472011-12-14 21:17:17 -08002980 return constructor;
2981}
2982
Brian Carlstromea46f952013-07-30 01:26:50 -07002983static void CheckProxyConstructor(mirror::ArtMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002984 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07002985 CHECK(constructor->IsConstructor());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002986 MethodHelper mh(constructor);
2987 CHECK_STREQ(mh.GetName(), "<init>");
Ian Rogersd91d6d62013-09-25 20:26:14 -07002988 CHECK_STREQ(mh.GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V");
Ian Rogers466bb252011-10-14 03:29:56 -07002989 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04002990}
2991
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002992mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self,
2993 const SirtRef<mirror::Class>& klass,
2994 const SirtRef<mirror::ArtMethod>& prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002995 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
2996 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08002997 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
2998 prototype.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002999 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07003000 // as necessary
Brian Carlstromea46f952013-07-30 01:26:50 -07003001 mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07003002 if (UNLIKELY(method == NULL)) {
3003 CHECK(self->IsExceptionPending()); // OOME.
3004 return NULL;
3005 }
Ian Rogers466bb252011-10-14 03:29:56 -07003006
3007 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
3008 // the intersection of throw exceptions as defined in Proxy
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003009 method->SetDeclaringClass(klass.get());
Ian Rogers466bb252011-10-14 03:29:56 -07003010 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04003011
Ian Rogers466bb252011-10-14 03:29:56 -07003012 // At runtime the method looks like a reference and argument saving method, clone the code
3013 // related parameters from this method.
Brian Carlstromea46f952013-07-30 01:26:50 -07003014 mirror::ArtMethod* refs_and_args =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003015 Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Ian Rogers466bb252011-10-14 03:29:56 -07003016 method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
3017 method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
3018 method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
Ian Rogersef7d42f2014-01-06 12:55:46 -08003019 method->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler());
3020 method->SetEntryPointFromPortableCompiledCode(GetPortableProxyInvokeHandler());
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07003021 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Ian Rogers16f93672012-02-14 12:29:06 -08003022
Ian Rogersc2b44472011-12-14 21:17:17 -08003023 return method;
3024}
Jesse Wilson95caa792011-10-12 18:14:17 -04003025
Brian Carlstromea46f952013-07-30 01:26:50 -07003026static void CheckProxyMethod(mirror::ArtMethod* method,
3027 SirtRef<mirror::ArtMethod>& prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003028 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07003029 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003030 CHECK(!prototype->IsFinal());
3031 CHECK(method->IsFinal());
3032 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08003033
3034 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
3035 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
3036 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
3037 CHECK_EQ(prototype->GetDexCacheResolvedMethods(), method->GetDexCacheResolvedMethods());
3038 CHECK_EQ(prototype->GetDexCacheResolvedTypes(), method->GetDexCacheResolvedTypes());
Ian Rogers19846512012-02-24 11:42:47 -08003039 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
3040
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003041 MethodHelper mh(method);
Ian Rogers19846512012-02-24 11:42:47 -08003042 MethodHelper mh2(prototype.get());
3043 CHECK_STREQ(mh.GetName(), mh2.GetName());
3044 CHECK_STREQ(mh.GetShorty(), mh2.GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07003045 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08003046 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04003047}
3048
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003049static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics,
3050 bool can_init_parents)
3051 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08003052 if (can_init_statics && can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003053 return true;
3054 }
3055 if (!can_init_statics) {
3056 // Check if there's a class initializer.
Ian Rogersd91d6d62013-09-25 20:26:14 -07003057 mirror::ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003058 if (clinit != NULL) {
3059 return false;
3060 }
3061 // Check if there are encoded static values needing initialization.
3062 if (klass->NumStaticFields() != 0) {
3063 ClassHelper kh(klass);
3064 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
3065 DCHECK(dex_class_def != NULL);
3066 if (dex_class_def->static_values_off_ != 0) {
3067 return false;
3068 }
3069 }
3070 }
3071 if (!klass->IsInterface() && klass->HasSuperClass()) {
3072 mirror::Class* super_class = klass->GetSuperClass();
3073 if (!can_init_parents && !super_class->IsInitialized()) {
3074 return false;
3075 } else {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08003076 if (!CanWeInitializeClass(super_class, can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003077 return false;
3078 }
3079 }
3080 }
3081 return true;
3082}
3083
Mathieu Chartier590fee92013-09-13 13:46:47 -07003084bool ClassLinker::IsInitialized() const {
3085 return init_done_;
3086}
3087
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003088bool ClassLinker::InitializeClass(const SirtRef<mirror::Class>& klass, bool can_init_statics,
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003089 bool can_init_parents) {
3090 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
3091
3092 // Are we already initialized and therefore done?
3093 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
3094 // an initialized class will never change its state.
3095 if (klass->IsInitialized()) {
3096 return true;
3097 }
3098
3099 // Fast fail if initialization requires a full runtime. Not part of the JLS.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003100 if (!CanWeInitializeClass(klass.get(), can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003101 return false;
3102 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003103
Carl Shapirob5573532011-07-12 18:22:59 -07003104 Thread* self = Thread::Current();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003105 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003106 {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003107 ObjectLock<mirror::Class> lock(self, &klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003108
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003109 // Re-check under the lock in case another thread initialized ahead of us.
3110 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003111 return true;
3112 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003113
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003114 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07003115 if (klass->IsErroneous()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003116 ThrowEarlierClassFailure(klass.get());
Brian Carlstromd1422f82011-09-28 11:37:09 -07003117 return false;
3118 }
3119
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003120 CHECK(klass->IsResolved()) << PrettyClass(klass.get()) << ": state=" << klass->GetStatus();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003121
3122 if (!klass->IsVerified()) {
jeffhao98eacac2011-09-14 16:11:53 -07003123 VerifyClass(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003124 if (!klass->IsVerified()) {
3125 // We failed to verify, expect either the klass to be erroneous or verification failed at
3126 // compile time.
3127 if (klass->IsErroneous()) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07003128 CHECK(self->IsExceptionPending());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003129 } else {
3130 CHECK(Runtime::Current()->IsCompiler());
3131 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07003132 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003133 return false;
3134 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003135 }
3136
Brian Carlstromd1422f82011-09-28 11:37:09 -07003137 // If the class is kStatusInitializing, either this thread is
3138 // initializing higher up the stack or another thread has beat us
3139 // to initializing and we need to wait. Either way, this
3140 // invocation of InitializeClass will not be responsible for
3141 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003142 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Elliott Hughes005ab2e2011-09-11 17:15:31 -07003143 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07003144 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003145 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003146 return true;
3147 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003148 // No. That's fine. Wait for another thread to finish initializing.
3149 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003150 }
3151
3152 if (!ValidateSuperClassDescriptors(klass)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003153 klass->SetStatus(mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003154 return false;
3155 }
3156
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003157 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003158
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003159 // From here out other threads may observe that we're initializing and so changes of state
3160 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07003161 klass->SetClinitThreadId(self->GetTid());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003162 klass->SetStatus(mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003163
3164 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003165 }
3166
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07003167 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003168 if (!klass->IsInterface() && klass->HasSuperClass()) {
3169 mirror::Class* super_class = klass->GetSuperClass();
3170 if (!super_class->IsInitialized()) {
3171 CHECK(!super_class->IsInterface());
3172 CHECK(can_init_parents);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003173 SirtRef<mirror::Class> sirt_super(self, super_class);
3174 bool super_initialized = InitializeClass(sirt_super, can_init_statics, true);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003175 if (!super_initialized) {
3176 // The super class was verified ahead of entering initializing, we should only be here if
3177 // the super class became erroneous due to initialization.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003178 CHECK(sirt_super->IsErroneous() && self->IsExceptionPending())
3179 << "Super class initialization failed for " << PrettyDescriptor(sirt_super.get())
3180 << " that has unexpected status " << sirt_super->GetStatus()
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003181 << "\nPending exception:\n"
3182 << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003183 ObjectLock<mirror::Class> lock(self, &klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003184 // Initialization failed because the super-class is erroneous.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003185 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003186 return false;
3187 }
Ian Rogers1bddec32012-02-04 12:27:34 -08003188 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003189 }
3190
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003191 if (klass->NumStaticFields() > 0) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003192 ClassHelper kh(klass.get());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003193 const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
3194 CHECK(dex_class_def != NULL);
3195 const DexFile& dex_file = kh.GetDexFile();
Mathieu Chartier590fee92013-09-13 13:46:47 -07003196 SirtRef<mirror::ClassLoader> class_loader(self, klass->GetClassLoader());
3197 SirtRef<mirror::DexCache> dex_cache(self, kh.GetDexCache());
3198 EncodedStaticFieldValueIterator it(dex_file, &dex_cache, &class_loader,
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003199 this, *dex_class_def);
3200 if (it.HasNext()) {
3201 CHECK(can_init_statics);
3202 // We reordered the fields, so we need to be able to map the field indexes to the right fields.
3203 SafeMap<uint32_t, mirror::ArtField*> field_map;
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003204 ConstructFieldMap(dex_file, *dex_class_def, klass.get(), field_map);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003205 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003206 if (Runtime::Current()->IsActiveTransaction()) {
3207 it.ReadValueToField<true>(field_map.Get(i));
3208 } else {
3209 it.ReadValueToField<false>(field_map.Get(i));
3210 }
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003211 }
3212 }
3213 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003214
Ian Rogersd91d6d62013-09-25 20:26:14 -07003215 mirror::ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003216 if (clinit != NULL) {
3217 CHECK(can_init_statics);
3218 if (LIKELY(Runtime::Current()->IsStarted())) {
Jeff Hao5d917302013-02-27 17:57:33 -08003219 JValue result;
Ian Rogers0177e532014-02-11 16:30:46 -08003220 clinit->Invoke(self, NULL, 0, &result, "V");
Ian Rogers64b6d142012-10-29 16:34:15 -07003221 } else {
Jeff Hao6474d192013-03-26 14:08:09 -07003222 art::interpreter::EnterInterpreterFromInvoke(self, clinit, NULL, NULL, NULL);
Ian Rogers64b6d142012-10-29 16:34:15 -07003223 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003224 }
3225
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003226 uint64_t t1 = NanoTime();
3227
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003228 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003229 {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003230 ObjectLock<mirror::Class> lock(self, &klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003231
3232 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003233 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003234 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003235 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003236 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003237 RuntimeStats* global_stats = Runtime::Current()->GetStats();
3238 RuntimeStats* thread_stats = self->GetStats();
3239 ++global_stats->class_init_count;
3240 ++thread_stats->class_init_count;
3241 global_stats->class_init_time_ns += (t1 - t0);
3242 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003243 // Set the class as initialized except if failed to initialize static fields.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003244 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003245 if (VLOG_IS_ON(class_linker)) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003246 ClassHelper kh(klass.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003247 LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08003248 }
Brian Carlstrom073278c2014-02-19 15:21:21 -08003249 // Opportunistically set static method trampolines to their destination.
3250 FixupStaticTrampolines(klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003251 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003252 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003253 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003254}
3255
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003256bool ClassLinker::WaitForInitializeClass(const SirtRef<mirror::Class>& klass, Thread* self,
3257 ObjectLock<mirror::Class>& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003258 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003259 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003260 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003261 CHECK(!klass->IsInitialized());
Ian Rogers05f30572013-02-20 12:13:11 -08003262 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07003263
3264 // When we wake up, repeat the test for init-in-progress. If
3265 // there's an exception pending (only possible if
3266 // "interruptShouldThrow" was set), bail out.
3267 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003268 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003269 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07003270 return false;
3271 }
3272 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003273 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003274 continue;
3275 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003276 if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07003277 // Compile time initialization failed.
3278 return false;
3279 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003280 if (klass->IsErroneous()) {
3281 // The caller wants an exception, but it was thrown in a
3282 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07003283 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003284 PrettyDescriptor(klass.get()).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07003285 return false;
3286 }
3287 if (klass->IsInitialized()) {
3288 return true;
3289 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003290 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass.get()) << " is "
3291 << klass->GetStatus();
Brian Carlstromd1422f82011-09-28 11:37:09 -07003292 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003293 LOG(FATAL) << "Not Reached" << PrettyClass(klass.get());
Brian Carlstromd1422f82011-09-28 11:37:09 -07003294}
3295
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003296bool ClassLinker::ValidateSuperClassDescriptors(const SirtRef<mirror::Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003297 if (klass->IsInterface()) {
3298 return true;
3299 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003300 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003301 // begin with the methods local to the superclass
3302 if (klass->HasSuperClass() &&
3303 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003304 SirtRef<mirror::Class> super(self, klass->GetSuperClass());
Ian Rogers595799e2012-01-11 17:32:51 -08003305 for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08003306 mirror::ArtMethod* method = klass->GetVTable()->Get(i);
Ian Rogers595799e2012-01-11 17:32:51 -08003307 if (method != super->GetVTable()->Get(i) &&
Ian Rogers98379392014-02-24 16:53:16 -08003308 !IsSameMethodSignatureInDifferentClassContexts(self, method, super.get(), klass.get())) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003309 ThrowLinkageError(klass.get(), "Class %s method %s resolves differently in superclass %s",
3310 PrettyDescriptor(klass.get()).c_str(), PrettyMethod(method).c_str(),
3311 PrettyDescriptor(super.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003312 return false;
3313 }
3314 }
3315 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003316 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003317 SirtRef<mirror::Class> interface(self, klass->GetIfTable()->GetInterface(i));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003318 if (klass->GetClassLoader() != interface->GetClassLoader()) {
3319 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08003320 mirror::ArtMethod* method = klass->GetIfTable()->GetMethodArray(i)->Get(j);
Ian Rogers98379392014-02-24 16:53:16 -08003321 if (!IsSameMethodSignatureInDifferentClassContexts(self, method, interface.get(),
Ian Rogers595799e2012-01-11 17:32:51 -08003322 method->GetDeclaringClass())) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003323 ThrowLinkageError(klass.get(), "Class %s method %s resolves differently in interface %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003324 PrettyDescriptor(method->GetDeclaringClass()).c_str(),
3325 PrettyMethod(method).c_str(),
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003326 PrettyDescriptor(interface.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003327 return false;
3328 }
3329 }
3330 }
3331 }
3332 return true;
3333}
3334
Ian Rogers595799e2012-01-11 17:32:51 -08003335// Returns true if classes referenced by the signature of the method are the
3336// same classes in klass1 as they are in klass2.
Ian Rogers98379392014-02-24 16:53:16 -08003337bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(Thread* self,
3338 mirror::ArtMethod* method,
Ian Rogersef7d42f2014-01-06 12:55:46 -08003339 mirror::Class* klass1,
3340 mirror::Class* klass2) {
Ian Rogers9074b992011-10-26 17:41:55 -07003341 if (klass1 == klass2) {
3342 return true;
Brian Carlstrome10b6972011-09-26 13:49:03 -07003343 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003344 CHECK(klass1 != nullptr);
3345 CHECK(klass2 != nullptr);
3346 SirtRef<mirror::ClassLoader> loader1(self, klass1->GetClassLoader());
3347 SirtRef<mirror::ClassLoader> loader2(self, klass2->GetClassLoader());
Ian Rogers4445a7e2012-10-05 17:19:13 -07003348 const DexFile& dex_file = *method->GetDeclaringClass()->GetDexCache()->GetDexFile();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003349 const DexFile::ProtoId& proto_id =
3350 dex_file.GetMethodPrototype(dex_file.GetMethodId(method->GetDexMethodIndex()));
Ian Rogers0571d352011-11-03 19:51:38 -07003351 for (DexFileParameterIterator it(dex_file, proto_id); it.HasNext(); it.Next()) {
3352 const char* descriptor = it.GetDescriptor();
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003353 if (descriptor == nullptr) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003354 break;
3355 }
3356 if (descriptor[0] == 'L' || descriptor[0] == '[') {
3357 // Found a non-primitive type.
Ian Rogers98379392014-02-24 16:53:16 -08003358 if (!IsSameDescriptorInDifferentClassContexts(self, descriptor, loader1, loader2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003359 return false;
3360 }
3361 }
3362 }
3363 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003364 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003365 if (descriptor[0] == 'L' || descriptor[0] == '[') {
Ian Rogers98379392014-02-24 16:53:16 -08003366 if (!IsSameDescriptorInDifferentClassContexts(self, descriptor, loader1, loader2)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003367 return false;
3368 }
3369 }
3370 return true;
3371}
3372
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003373// Returns true if the descriptor resolves to the same class in the context of loader1 and loader2.
Ian Rogers98379392014-02-24 16:53:16 -08003374bool ClassLinker::IsSameDescriptorInDifferentClassContexts(Thread* self, const char* descriptor,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003375 SirtRef<mirror::ClassLoader>& loader1,
3376 SirtRef<mirror::ClassLoader>& loader2) {
3377 CHECK(descriptor != nullptr);
Ian Rogers98379392014-02-24 16:53:16 -08003378 SirtRef<mirror::Class> found1(self, FindClass(self, descriptor, loader1));
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003379 if (found1.get() == nullptr) {
3380 self->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003381 }
Ian Rogers98379392014-02-24 16:53:16 -08003382 mirror::Class* found2 = FindClass(self, descriptor, loader2);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003383 if (found2 == nullptr) {
3384 self->ClearException();
Ian Rogers595799e2012-01-11 17:32:51 -08003385 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003386 return found1.get() == found2;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003387}
3388
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003389bool ClassLinker::EnsureInitialized(const SirtRef<mirror::Class>& c, bool can_init_fields,
3390 bool can_init_parents) {
3391 DCHECK(c.get() != NULL);
Elliott Hughesf4c21c92011-08-19 17:31:31 -07003392 if (c->IsInitialized()) {
3393 return true;
3394 }
3395
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003396 bool success = InitializeClass(c, can_init_fields, can_init_parents);
Ian Rogers595799e2012-01-11 17:32:51 -08003397 if (!success) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003398 if (can_init_fields && can_init_parents) {
3399 CHECK(Thread::Current()->IsExceptionPending()) << PrettyClass(c.get());
3400 }
Ian Rogers595799e2012-01-11 17:32:51 -08003401 }
3402 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07003403}
3404
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003405void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Mathieu Chartier590fee92013-09-13 13:46:47 -07003406 mirror::Class* c,
3407 SafeMap<uint32_t, mirror::ArtField*>& field_map) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003408 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07003409 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003410 Thread* self = Thread::Current();
3411 SirtRef<mirror::DexCache> dex_cache(self, c->GetDexCache());
3412 SirtRef<mirror::ClassLoader> class_loader(self, c->GetClassLoader());
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003413 CHECK(!kMovingFields);
Ian Rogers0571d352011-11-03 19:51:38 -07003414 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003415 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), dex_cache, class_loader, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003416 }
3417}
3418
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003419bool ClassLinker::LinkClass(Thread* self, const SirtRef<mirror::Class>& klass,
3420 const SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003421 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003422 if (!LinkSuperClass(klass)) {
3423 return false;
3424 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003425 if (!LinkMethods(klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003426 return false;
3427 }
3428 if (!LinkInstanceFields(klass)) {
3429 return false;
3430 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07003431 if (!LinkStaticFields(klass)) {
3432 return false;
3433 }
3434 CreateReferenceInstanceOffsets(klass);
3435 CreateReferenceStaticOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003436 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003437 klass->SetStatus(mirror::Class::kStatusResolved, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003438 return true;
3439}
3440
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003441bool ClassLinker::LoadSuperAndInterfaces(const SirtRef<mirror::Class>& klass,
3442 const DexFile& dex_file) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003443 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003444 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
3445 uint16_t super_class_idx = class_def.superclass_idx_;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003446 if (super_class_idx != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003447 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003448 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07003449 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003450 return false;
3451 }
Ian Rogersbe125a92012-01-11 15:19:49 -08003452 // Verify
3453 if (!klass->CanAccess(super_class)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003454 ThrowIllegalAccessError(klass.get(), "Class %s extended by class %s is inaccessible",
3455 PrettyDescriptor(super_class).c_str(),
3456 PrettyDescriptor(klass.get()).c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08003457 return false;
3458 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003459 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003460 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003461 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003462 if (interfaces != NULL) {
3463 for (size_t i = 0; i < interfaces->Size(); i++) {
3464 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003465 mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003466 if (interface == NULL) {
3467 DCHECK(Thread::Current()->IsExceptionPending());
3468 return false;
3469 }
3470 // Verify
3471 if (!klass->CanAccess(interface)) {
3472 // TODO: the RI seemed to ignore this in my testing.
Ian Rogers62d6c772013-02-27 08:32:07 -08003473 ThrowIllegalAccessError(klass.get(), "Interface %s implemented by class %s is inaccessible",
3474 PrettyDescriptor(interface).c_str(),
3475 PrettyDescriptor(klass.get()).c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003476 return false;
3477 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003478 }
3479 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003480 // Mark the class as loaded.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003481 klass->SetStatus(mirror::Class::kStatusLoaded, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003482 return true;
3483}
3484
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003485bool ClassLinker::LinkSuperClass(const SirtRef<mirror::Class>& klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003486 CHECK(!klass->IsPrimitive());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003487 mirror::Class* super = klass->GetSuperClass();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003488 if (klass.get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003489 if (super != NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003490 ThrowClassFormatError(klass.get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003491 return false;
3492 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003493 return true;
3494 }
3495 if (super == NULL) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003496 ThrowLinkageError(klass.get(), "No superclass defined for class %s",
3497 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003498 return false;
3499 }
3500 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003501 if (super->IsFinal() || super->IsInterface()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003502 ThrowIncompatibleClassChangeError(klass.get(), "Superclass %s of %s is %s",
3503 PrettyDescriptor(super).c_str(),
3504 PrettyDescriptor(klass.get()).c_str(),
3505 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003506 return false;
3507 }
3508 if (!klass->CanAccess(super)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003509 ThrowIllegalAccessError(klass.get(), "Superclass %s is inaccessible to class %s",
3510 PrettyDescriptor(super).c_str(),
3511 PrettyDescriptor(klass.get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003512 return false;
3513 }
Elliott Hughes20cde902011-10-04 17:37:27 -07003514
3515 // Inherit kAccClassIsFinalizable from the superclass in case this class doesn't override finalize.
3516 if (super->IsFinalizable()) {
3517 klass->SetFinalizable();
3518 }
3519
Elliott Hughes2da50362011-10-10 16:57:08 -07003520 // Inherit reference flags (if any) from the superclass.
3521 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
3522 if (reference_flags != 0) {
3523 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
3524 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003525 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07003526 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003527 ThrowLinkageError(klass.get(),
3528 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
3529 PrettyDescriptor(klass.get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07003530 return false;
3531 }
Elliott Hughes2da50362011-10-10 16:57:08 -07003532
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003533 if (kIsDebugBuild) {
3534 // Ensure super classes are fully resolved prior to resolving fields..
3535 while (super != NULL) {
3536 CHECK(super->IsResolved());
3537 super = super->GetSuperClass();
3538 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003539 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003540 return true;
3541}
3542
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003543// Populate the class vtable and itable. Compute return type indices.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003544bool ClassLinker::LinkMethods(const SirtRef<mirror::Class>& klass,
3545 const SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003546 if (klass->IsInterface()) {
3547 // No vtable.
3548 size_t count = klass->NumVirtualMethods();
3549 if (!IsUint(16, count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003550 ThrowClassFormatError(klass.get(), "Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003551 return false;
3552 }
Carl Shapiro565f5072011-07-10 13:39:43 -07003553 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003554 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003555 }
jeffhaobdb76512011-09-07 11:43:16 -07003556 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003557 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003558 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07003559 // Link virtual and interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003560 return LinkVirtualMethods(klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003561 }
3562 return true;
3563}
3564
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003565bool ClassLinker::LinkVirtualMethods(const SirtRef<mirror::Class>& klass) {
Ian Rogers1f539342012-10-03 21:09:42 -07003566 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003567 if (klass->HasSuperClass()) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003568 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
3569 size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003570 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003571 // TODO: do not assign to the vtable field until it is fully constructed.
Brian Carlstromea46f952013-07-30 01:26:50 -07003572 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
Ian Rogers50b35e22012-10-04 10:09:15 -07003573 vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003574 if (UNLIKELY(vtable.get() == NULL)) {
3575 CHECK(self->IsExceptionPending()); // OOME.
3576 return false;
3577 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003578 // See if any of our virtual methods override the superclass.
3579 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003580 mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003581 MethodHelper local_mh(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003582 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003583 for (; j < actual_count; ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003584 mirror::ArtMethod* super_method = vtable->Get(j);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003585 MethodHelper super_mh(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003586 if (local_mh.HasSameNameAndSignature(&super_mh)) {
3587 if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
3588 if (super_method->IsFinal()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003589 ThrowLinkageError(klass.get(), "Method %s overrides final method in class %s",
Elliott Hughes39717372012-07-13 16:21:23 -07003590 PrettyMethod(local_method).c_str(),
3591 super_mh.GetDeclaringClassDescriptor());
3592 return false;
3593 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003594 vtable->Set<false>(j, local_method);
Elliott Hughes39717372012-07-13 16:21:23 -07003595 local_method->SetMethodIndex(j);
3596 break;
3597 } else {
3598 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
3599 << " would have incorrectly overridden the package-private method in "
3600 << PrettyDescriptor(super_mh.GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003601 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003602 }
3603 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07003604 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003605 // Not overriding, append.
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003606 vtable->Set<false>(actual_count, local_method);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003607 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003608 actual_count += 1;
3609 }
3610 }
3611 if (!IsUint(16, actual_count)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003612 ThrowClassFormatError(klass.get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003613 return false;
3614 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003615 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003616 CHECK_LE(actual_count, max_count);
3617 if (actual_count < max_count) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003618 vtable.reset(vtable->CopyOf(self, actual_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003619 if (UNLIKELY(vtable.get() == NULL)) {
3620 CHECK(self->IsExceptionPending()); // OOME.
3621 return false;
3622 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003623 }
Ian Rogers30fab402012-01-23 15:43:46 -08003624 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003625 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003626 CHECK(klass.get() == GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003627 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003628 if (!IsUint(16, num_virtual_methods)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003629 ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003630 return false;
3631 }
Brian Carlstromea46f952013-07-30 01:26:50 -07003632 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3633 vtable(self, AllocArtMethodArray(self, num_virtual_methods));
Ian Rogersa436fde2013-08-27 23:34:06 -07003634 if (UNLIKELY(vtable.get() == NULL)) {
3635 CHECK(self->IsExceptionPending()); // OOME.
3636 return false;
3637 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07003638 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003639 mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003640 vtable->Set<false>(i, virtual_method);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003641 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003642 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003643 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003644 }
3645 return true;
3646}
3647
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003648bool ClassLinker::LinkInterfaceMethods(const SirtRef<mirror::Class>& klass,
3649 const SirtRef<mirror::ObjectArray<mirror::Class> >& interfaces) {
Jeff Hao88474b42013-10-23 16:24:40 -07003650 // Set the imt table to be all conflicts by default.
3651 klass->SetImTable(Runtime::Current()->GetDefaultImt());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003652 size_t super_ifcount;
3653 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003654 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003655 } else {
3656 super_ifcount = 0;
3657 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003658 size_t ifcount = super_ifcount;
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003659 uint32_t num_interfaces;
3660 {
3661 ClassHelper kh(klass.get());
3662 num_interfaces =
3663 interfaces.get() == nullptr ? kh.NumDirectInterfaces() : interfaces->GetLength();
3664 ifcount += num_interfaces;
3665 for (size_t i = 0; i < num_interfaces; i++) {
3666 mirror::Class* interface =
3667 interfaces.get() == nullptr ? kh.GetDirectInterface(i) : interfaces->Get(i);
3668 ifcount += interface->GetIfTableCount();
3669 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003670 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003671 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003672 // Class implements no interfaces.
3673 DCHECK_EQ(klass->GetIfTableCount(), 0);
3674 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003675 return true;
3676 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003677 if (ifcount == super_ifcount) {
3678 // Class implements same interfaces as parent, are any of these not marker interfaces?
3679 bool has_non_marker_interface = false;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003680 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Ian Rogers9bc81912012-10-11 21:43:36 -07003681 for (size_t i = 0; i < ifcount; ++i) {
3682 if (super_iftable->GetMethodArrayCount(i) > 0) {
3683 has_non_marker_interface = true;
3684 break;
3685 }
3686 }
3687 if (!has_non_marker_interface) {
3688 // Class just inherits marker interfaces from parent so recycle parent's iftable.
3689 klass->SetIfTable(super_iftable);
3690 return true;
3691 }
3692 }
Ian Rogers1f539342012-10-03 21:09:42 -07003693 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003694 SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
Ian Rogersa436fde2013-08-27 23:34:06 -07003695 if (UNLIKELY(iftable.get() == NULL)) {
3696 CHECK(self->IsExceptionPending()); // OOME.
3697 return false;
3698 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003699 if (super_ifcount != 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003700 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003701 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003702 mirror::Class* super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07003703 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003704 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003705 }
3706 // Flatten the interface inheritance hierarchy.
3707 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003708 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003709 ClassHelper kh(klass.get());
Mathieu Chartier590fee92013-09-13 13:46:47 -07003710 mirror::Class* interface =
3711 interfaces.get() == nullptr ? kh.GetDirectInterface(i) : interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003712 DCHECK(interface != NULL);
3713 if (!interface->IsInterface()) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003714 ClassHelper ih(interface);
Ian Rogers62d6c772013-02-27 08:32:07 -08003715 ThrowIncompatibleClassChangeError(klass.get(), "Class %s implements non-interface class %s",
3716 PrettyDescriptor(klass.get()).c_str(),
3717 PrettyDescriptor(ih.GetDescriptor()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003718 return false;
3719 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003720 // Check if interface is already in iftable
3721 bool duplicate = false;
3722 for (size_t j = 0; j < idx; j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003723 mirror::Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003724 if (existing_interface == interface) {
3725 duplicate = true;
3726 break;
3727 }
3728 }
3729 if (!duplicate) {
3730 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07003731 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003732 // Add this interface's non-duplicate super-interfaces.
3733 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003734 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003735 bool super_duplicate = false;
3736 for (size_t k = 0; k < idx; k++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003737 mirror::Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003738 if (existing_interface == super_interface) {
3739 super_duplicate = true;
3740 break;
3741 }
3742 }
3743 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07003744 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08003745 }
3746 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003747 }
3748 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003749 // Shrink iftable in case duplicates were found
3750 if (idx < ifcount) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003751 iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003752 if (UNLIKELY(iftable.get() == NULL)) {
3753 CHECK(self->IsExceptionPending()); // OOME.
3754 return false;
3755 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08003756 ifcount = idx;
3757 } else {
3758 CHECK_EQ(idx, ifcount);
3759 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003760 klass->SetIfTable(iftable.get());
Elliott Hughes4681c802011-09-25 18:04:37 -07003761
3762 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07003763 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003764 return true;
3765 }
Jeff Hao88474b42013-10-23 16:24:40 -07003766 // Allocate imtable
3767 bool imtable_changed = false;
3768 SirtRef<mirror::ObjectArray<mirror::ArtMethod> > imtable(self, AllocArtMethodArray(self, kImtSize));
3769 if (UNLIKELY(imtable.get() == NULL)) {
3770 CHECK(self->IsExceptionPending()); // OOME.
3771 return false;
3772 }
Brian Carlstromea46f952013-07-30 01:26:50 -07003773 std::vector<mirror::ArtMethod*> miranda_list;
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07003774 for (size_t i = 0; i < ifcount; ++i) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003775 size_t num_methods = iftable->GetInterface(i)->NumVirtualMethods();
Ian Rogers9bc81912012-10-11 21:43:36 -07003776 if (num_methods > 0) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003777 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
3778 method_array(self, AllocArtMethodArray(self, num_methods));
3779 if (UNLIKELY(method_array.get() == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003780 CHECK(self->IsExceptionPending()); // OOME.
3781 return false;
3782 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003783 iftable->SetMethodArray(i, method_array.get());
3784 SirtRef<mirror::ObjectArray<mirror::ArtMethod> > vtable(self,
3785 klass->GetVTableDuringLinking());
Ian Rogers62d6c772013-02-27 08:32:07 -08003786 for (size_t j = 0; j < num_methods; ++j) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003787 mirror::ArtMethod* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j);
3788 MethodHelper interface_mh(interface_method);
Ian Rogers9bc81912012-10-11 21:43:36 -07003789 int32_t k;
3790 // For each method listed in the interface's method list, find the
3791 // matching method in our class's method list. We want to favor the
3792 // subclass over the superclass, which just requires walking
3793 // back from the end of the vtable. (This only matters if the
3794 // superclass defines a private method and this class redefines
3795 // it -- otherwise it would use the same vtable slot. In .dex files
3796 // those don't end up in the virtual method table, so it shouldn't
3797 // matter which direction we go. We walk it backward anyway.)
3798 for (k = vtable->GetLength() - 1; k >= 0; --k) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003799 mirror::ArtMethod* vtable_method = vtable->Get(k);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003800 MethodHelper vtable_mh(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003801 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Elliott Hughes68243612013-02-22 17:16:07 -08003802 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003803 ThrowIllegalAccessError(klass.get(),
3804 "Method '%s' implementing interface method '%s' is not public",
3805 PrettyMethod(vtable_method).c_str(),
3806 PrettyMethod(interface_method).c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07003807 return false;
3808 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003809 method_array->Set<false>(j, vtable_method);
Jeff Hao88474b42013-10-23 16:24:40 -07003810 // Place method in imt if entry is empty, place conflict otherwise.
3811 uint32_t imt_index = interface_method->GetDexMethodIndex() % kImtSize;
3812 if (imtable->Get(imt_index) == NULL) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003813 imtable->Set<false>(imt_index, vtable_method);
Jeff Hao88474b42013-10-23 16:24:40 -07003814 imtable_changed = true;
3815 } else {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003816 imtable->Set<false>(imt_index, Runtime::Current()->GetImtConflictMethod());
Jeff Hao88474b42013-10-23 16:24:40 -07003817 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003818 break;
3819 }
3820 }
Ian Rogers9bc81912012-10-11 21:43:36 -07003821 if (k < 0) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003822 SirtRef<mirror::ArtMethod> miranda_method(self, NULL);
Ian Rogers9bc81912012-10-11 21:43:36 -07003823 for (size_t mir = 0; mir < miranda_list.size(); mir++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003824 mirror::ArtMethod* mir_method = miranda_list[mir];
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003825 MethodHelper vtable_mh(mir_method);
Ian Rogers9bc81912012-10-11 21:43:36 -07003826 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
3827 miranda_method.reset(miranda_list[mir]);
3828 break;
3829 }
3830 }
3831 if (miranda_method.get() == NULL) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003832 // Point the interface table at a phantom slot.
Brian Carlstromea46f952013-07-30 01:26:50 -07003833 miranda_method.reset(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003834 if (UNLIKELY(miranda_method.get() == NULL)) {
3835 CHECK(self->IsExceptionPending()); // OOME.
3836 return false;
3837 }
Ian Rogersa436fde2013-08-27 23:34:06 -07003838 // TODO: If a methods move then the miranda_list may hold stale references.
Ian Rogers9bc81912012-10-11 21:43:36 -07003839 miranda_list.push_back(miranda_method.get());
3840 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003841 method_array->Set<false>(j, miranda_method.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003842 }
3843 }
3844 }
3845 }
Jeff Hao88474b42013-10-23 16:24:40 -07003846 if (imtable_changed) {
3847 // Fill in empty entries in interface method table with conflict.
3848 mirror::ArtMethod* imt_conflict_method = Runtime::Current()->GetImtConflictMethod();
3849 for (size_t i = 0; i < kImtSize; i++) {
3850 if (imtable->Get(i) == NULL) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003851 imtable->Set<false>(i, imt_conflict_method);
Jeff Hao88474b42013-10-23 16:24:40 -07003852 }
3853 }
3854 klass->SetImTable(imtable.get());
3855 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003856 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07003857 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07003858 int new_method_count = old_method_count + miranda_list.size();
Ian Rogersa436fde2013-08-27 23:34:06 -07003859 mirror::ObjectArray<mirror::ArtMethod>* virtuals;
3860 if (old_method_count == 0) {
3861 virtuals = AllocArtMethodArray(self, new_method_count);
3862 } else {
3863 virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count);
3864 }
3865 if (UNLIKELY(virtuals == NULL)) {
3866 CHECK(self->IsExceptionPending()); // OOME.
3867 return false;
3868 }
3869 klass->SetVirtualMethods(virtuals);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003870
Brian Carlstromea46f952013-07-30 01:26:50 -07003871 SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003872 vtable(self, klass->GetVTableDuringLinking());
Ian Rogers30fab402012-01-23 15:43:46 -08003873 CHECK(vtable.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003874 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07003875 int new_vtable_count = old_vtable_count + miranda_list.size();
Ian Rogers50b35e22012-10-04 10:09:15 -07003876 vtable.reset(vtable->CopyOf(self, new_vtable_count));
Ian Rogersa436fde2013-08-27 23:34:06 -07003877 if (UNLIKELY(vtable.get() == NULL)) {
3878 CHECK(self->IsExceptionPending()); // OOME.
3879 return false;
3880 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003881 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003882 mirror::ArtMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07003883 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07003884 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
3885 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
3886 klass->SetVirtualMethod(old_method_count + i, method);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003887 vtable->Set<false>(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003888 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003889 // TODO: do not assign to the vtable field until it is fully constructed.
Ian Rogers30fab402012-01-23 15:43:46 -08003890 klass->SetVTable(vtable.get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003891 }
Elliott Hughes4681c802011-09-25 18:04:37 -07003892
Brian Carlstromea46f952013-07-30 01:26:50 -07003893 mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07003894 for (int i = 0; i < vtable->GetLength(); ++i) {
3895 CHECK(vtable->Get(i) != NULL);
3896 }
3897
3898// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
3899
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003900 return true;
3901}
3902
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003903bool ClassLinker::LinkInstanceFields(const SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003904 CHECK(klass.get() != NULL);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003905 return LinkFields(klass, false);
Brian Carlstrom4873d462011-08-21 15:23:39 -07003906}
3907
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003908bool ClassLinker::LinkStaticFields(const SirtRef<mirror::Class>& klass) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003909 CHECK(klass.get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003910 size_t allocated_class_size = klass->GetClassSize();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003911 bool success = LinkFields(klass, true);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003912 CHECK_EQ(allocated_class_size, klass->GetClassSize());
Brian Carlstrom4873d462011-08-21 15:23:39 -07003913 return success;
3914}
3915
Brian Carlstromdbc05252011-09-09 01:59:59 -07003916struct LinkFieldsComparator {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003917 explicit LinkFieldsComparator() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
3918 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003919 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Ian Rogersef7d42f2014-01-06 12:55:46 -08003920 bool operator()(mirror::ArtField* field1, mirror::ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003921 NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07003922 // First come reference fields, then 64-bit, and finally 32-bit
Mathieu Chartier590fee92013-09-13 13:46:47 -07003923 FieldHelper fh1(field1);
3924 Primitive::Type type1 = fh1.GetTypeAsPrimitiveType();
3925 FieldHelper fh2(field2);
3926 Primitive::Type type2 = fh2.GetTypeAsPrimitiveType();
Ian Rogersef7d42f2014-01-06 12:55:46 -08003927 if (type1 != type2) {
3928 bool is_primitive1 = type1 != Primitive::kPrimNot;
3929 bool is_primitive2 = type2 != Primitive::kPrimNot;
3930 bool is64bit1 = is_primitive1 && (type1 == Primitive::kPrimLong || type1 == Primitive::kPrimDouble);
3931 bool is64bit2 = is_primitive2 && (type2 == Primitive::kPrimLong || type2 == Primitive::kPrimDouble);
3932 int order1 = !is_primitive1 ? 0 : (is64bit1 ? 1 : 2);
3933 int order2 = !is_primitive2 ? 0 : (is64bit2 ? 1 : 2);
3934 if (order1 != order2) {
3935 return order1 < order2;
3936 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003937 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003938 // same basic group? then sort by string.
Mathieu Chartier590fee92013-09-13 13:46:47 -07003939 const char* name1 = fh1.GetName();
3940 const char* name2 = fh2.GetName();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003941 return strcmp(name1, name2) < 0;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003942 }
3943};
3944
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003945bool ClassLinker::LinkFields(const SirtRef<mirror::Class>& klass, bool is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003946 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003947 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003948
Brian Carlstromea46f952013-07-30 01:26:50 -07003949 mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003950 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003951
3952 // Initialize size and field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07003953 size_t size;
3954 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003955 if (is_static) {
3956 size = klass->GetClassSize();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003957 field_offset = mirror::Class::FieldsOffset();
Brian Carlstrom3320cf42011-10-04 14:58:28 -07003958 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003959 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003960 if (super_class != NULL) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07003961 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003962 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003963 }
3964 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003965 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003966
Brian Carlstromdbc05252011-09-09 01:59:59 -07003967 CHECK_EQ(num_fields == 0, fields == NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003968
Brian Carlstromdbc05252011-09-09 01:59:59 -07003969 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07003970 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromea46f952013-07-30 01:26:50 -07003971 std::deque<mirror::ArtField*> grouped_and_sorted_fields;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003972 for (size_t i = 0; i < num_fields; i++) {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003973 mirror::ArtField* f = fields->Get(i);
3974 CHECK(f != NULL);
3975 grouped_and_sorted_fields.push_back(f);
Brian Carlstromdbc05252011-09-09 01:59:59 -07003976 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07003977 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
3978 LinkFieldsComparator());
Brian Carlstromdbc05252011-09-09 01:59:59 -07003979
3980 // References should be at the front.
3981 size_t current_field = 0;
3982 size_t num_reference_fields = 0;
3983 for (; current_field < num_fields; current_field++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07003984 mirror::ArtField* field = grouped_and_sorted_fields.front();
Mathieu Chartier590fee92013-09-13 13:46:47 -07003985 FieldHelper fh(field);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003986 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003987 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07003988 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003989 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003990 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07003991 grouped_and_sorted_fields.pop_front();
3992 num_reference_fields++;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003993 fields->Set<false>(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003994 field->SetOffset(field_offset);
3995 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003996 }
3997
3998 // Now we want to pack all of the double-wide fields together. If
3999 // we're not aligned, though, we want to shuffle one 32-bit field
4000 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07004001 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07004002 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004003 mirror::ArtField* field = grouped_and_sorted_fields[i];
Mathieu Chartier590fee92013-09-13 13:46:47 -07004004 FieldHelper fh(field);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004005 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07004006 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
4007 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07004008 continue;
4009 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004010 fields->Set<false>(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004011 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004012 // drop the consumed field
4013 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
4014 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004015 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07004016 // whether we found a 32-bit field for padding or not, we advance
4017 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004018 }
4019
4020 // Alignment is good, shuffle any double-wide fields forward, and
4021 // finish assigning field offsets to all fields.
Elliott Hughes06b37d92011-10-16 11:51:29 -07004022 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
Brian Carlstromdbc05252011-09-09 01:59:59 -07004023 while (!grouped_and_sorted_fields.empty()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004024 mirror::ArtField* field = grouped_and_sorted_fields.front();
Brian Carlstromdbc05252011-09-09 01:59:59 -07004025 grouped_and_sorted_fields.pop_front();
Mathieu Chartier590fee92013-09-13 13:46:47 -07004026 FieldHelper fh(field);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004027 Primitive::Type type = fh.GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07004028 CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004029 fields->Set<false>(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004030 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004031 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07004032 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07004033 ? sizeof(uint64_t)
4034 : sizeof(uint32_t)));
4035 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004036 }
4037
Elliott Hughesadb460d2011-10-05 17:02:34 -07004038 // 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 -07004039 if (!is_static &&
Mathieu Chartier590fee92013-09-13 13:46:47 -07004040 (strcmp("Ljava/lang/ref/Reference;", ClassHelper(klass.get()).GetDescriptor()) == 0)) {
Elliott Hughesadb460d2011-10-05 17:02:34 -07004041 // We know there are no non-reference fields in the Reference classes, and we know
4042 // that 'referent' is alphabetically last, so this is easy...
4043 CHECK_EQ(num_reference_fields, num_fields);
Mathieu Chartier590fee92013-09-13 13:46:47 -07004044 FieldHelper fh(fields->Get(num_fields - 1));
Elliott Hughesba8eee12012-01-24 20:25:24 -08004045 CHECK_STREQ(fh.GetName(), "referent");
Elliott Hughesadb460d2011-10-05 17:02:34 -07004046 --num_reference_fields;
4047 }
4048
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004049 if (kIsDebugBuild) {
4050 // Make sure that all reference fields appear before
4051 // non-reference fields, and all double-wide fields are aligned.
4052 bool seen_non_ref = false;
4053 for (size_t i = 0; i < num_fields; i++) {
4054 mirror::ArtField* field = fields->Get(i);
4055 if (false) { // enable to debug field layout
4056 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
4057 << " class=" << PrettyClass(klass.get())
4058 << " field=" << PrettyField(field)
Ian Rogersb0fa5dc2014-04-28 16:47:08 -07004059 << " offset="
4060 << field->GetField32(MemberOffset(mirror::ArtField::OffsetOffset()));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004061 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07004062 FieldHelper fh(field);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004063 Primitive::Type type = fh.GetTypeAsPrimitiveType();
4064 bool is_primitive = type != Primitive::kPrimNot;
Mathieu Chartier590fee92013-09-13 13:46:47 -07004065 if ((strcmp("Ljava/lang/ref/Reference;", ClassHelper(klass.get()).GetDescriptor()) == 0)
Ian Rogersdfb325e2013-10-30 01:00:44 -07004066 && (strcmp("referent", fh.GetName()) == 0)) {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004067 is_primitive = true; // We lied above, so we have to expect a lie here.
4068 }
4069 if (is_primitive) {
4070 if (!seen_non_ref) {
4071 seen_non_ref = true;
4072 DCHECK_EQ(num_reference_fields, i);
4073 }
4074 } else {
4075 DCHECK(!seen_non_ref);
4076 }
4077 }
4078 if (!seen_non_ref) {
4079 DCHECK_EQ(num_fields, num_reference_fields);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004080 }
4081 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004082 size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004083 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004084 if (is_static) {
4085 klass->SetNumReferenceStaticFields(num_reference_fields);
4086 klass->SetClassSize(size);
4087 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004088 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004089 if (!klass->IsVariableSize()) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004090 DCHECK_GE(size, sizeof(mirror::Object)) << ClassHelper(klass.get()).GetDescriptor();
Mathieu Chartier79b4f382013-10-23 15:21:37 -07004091 size_t previous_size = klass->GetObjectSize();
4092 if (previous_size != 0) {
4093 // Make sure that we didn't originally have an incorrect size.
4094 CHECK_EQ(previous_size, size);
4095 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004096 klass->SetObjectSize(size);
4097 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004098 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004099 return true;
4100}
4101
4102// Set the bitmap of reference offsets, refOffsets, from the ifields
4103// list.
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004104void ClassLinker::CreateReferenceInstanceOffsets(const SirtRef<mirror::Class>& klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004105 uint32_t reference_offsets = 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004106 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004107 if (super_class != NULL) {
4108 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07004109 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004110 if (reference_offsets == CLASS_WALK_SUPER) {
4111 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004112 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004113 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004114 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004115 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004116}
4117
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004118void ClassLinker::CreateReferenceStaticOffsets(const SirtRef<mirror::Class>& klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004119 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004120}
4121
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004122void ClassLinker::CreateReferenceOffsets(const SirtRef<mirror::Class>& klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004123 uint32_t reference_offsets) {
4124 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004125 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
4126 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogersef7d42f2014-01-06 12:55:46 -08004127 mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004128 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07004129 // All of the fields that contain object references are guaranteed
4130 // to be at the beginning of the fields list.
4131 for (size_t i = 0; i < num_reference_fields; ++i) {
4132 // Note that byte_offset is the offset from the beginning of
4133 // object, not the offset into instance data
Ian Rogersef7d42f2014-01-06 12:55:46 -08004134 mirror::ArtField* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004135 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004136 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
4137 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
4138 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07004139 CHECK_NE(new_bit, 0U);
4140 reference_offsets |= new_bit;
4141 } else {
4142 reference_offsets = CLASS_WALK_SUPER;
4143 break;
4144 }
4145 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004146 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004147 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004148 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004149 } else {
4150 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004151 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004152}
4153
Mathieu Chartier590fee92013-09-13 13:46:47 -07004154mirror::String* ClassLinker::ResolveString(const DexFile& dex_file, uint32_t string_idx,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004155 const SirtRef<mirror::DexCache>& dex_cache) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004156 DCHECK(dex_cache.get() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004157 mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004158 if (resolved != NULL) {
4159 return resolved;
4160 }
Ian Rogersdfb325e2013-10-30 01:00:44 -07004161 uint32_t utf16_length;
4162 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004163 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004164 dex_cache->SetResolvedString(string_idx, string);
4165 return string;
4166}
4167
Mathieu Chartier590fee92013-09-13 13:46:47 -07004168mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
Ian Rogersef7d42f2014-01-06 12:55:46 -08004169 mirror::Class* referrer) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004170 Thread* self = Thread::Current();
4171 SirtRef<mirror::DexCache> dex_cache(self, referrer->GetDexCache());
4172 SirtRef<mirror::ClassLoader> class_loader(self, referrer->GetClassLoader());
4173 return ResolveType(dex_file, type_idx, dex_cache, class_loader);
4174}
4175
4176mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004177 const SirtRef<mirror::DexCache>& dex_cache,
4178 const SirtRef<mirror::ClassLoader>& class_loader) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004179 DCHECK(dex_cache.get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004180 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004181 if (resolved == NULL) {
Ian Rogers98379392014-02-24 16:53:16 -08004182 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07004183 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Ian Rogers98379392014-02-24 16:53:16 -08004184 resolved = FindClass(self, descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004185 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05004186 // TODO: we used to throw here if resolved's class loader was not the
4187 // boot class loader. This was to permit different classes with the
4188 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004189 dex_cache->SetResolvedType(type_idx, resolved);
4190 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004191 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08004192 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08004193 // Convert a ClassNotFoundException to a NoClassDefFoundError.
4194 SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
4195 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
Vladimir Marko801a8112014-01-06 14:28:16 +00004196 DCHECK(resolved == NULL); // No SirtRef needed to preserve resolved.
Ian Rogers98379392014-02-24 16:53:16 -08004197 self->ClearException();
jeffhao8cd6dda2012-02-22 10:15:34 -08004198 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Ian Rogers62d6c772013-02-27 08:32:07 -08004199 self->GetException(NULL)->SetCause(cause.get());
jeffhao8cd6dda2012-02-22 10:15:34 -08004200 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004201 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004202 }
Brian Carlstromabcf7ae2013-09-23 22:19:52 -07004203 DCHECK((resolved == NULL) || resolved->IsResolved() || resolved->IsErroneous())
4204 << PrettyDescriptor(resolved) << " " << resolved->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004205 return resolved;
4206}
4207
Brian Carlstromea46f952013-07-30 01:26:50 -07004208mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
Ian Rogersd91d6d62013-09-25 20:26:14 -07004209 uint32_t method_idx,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004210 const SirtRef<mirror::DexCache>& dex_cache,
4211 const SirtRef<mirror::ClassLoader>& class_loader,
Ian Rogersef7d42f2014-01-06 12:55:46 -08004212 mirror::ArtMethod* referrer,
Ian Rogersd91d6d62013-09-25 20:26:14 -07004213 InvokeType type) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004214 DCHECK(dex_cache.get() != NULL);
Ian Rogers08f753d2012-08-24 14:35:25 -07004215 // Check for hit in the dex cache.
Brian Carlstromea46f952013-07-30 01:26:50 -07004216 mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07004217 if (resolved != NULL && !resolved->IsRuntimeMethod()) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004218 return resolved;
4219 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004220 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004221 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004222 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004223 if (klass == NULL) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07004224 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004225 return NULL;
4226 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004227 // Scan using method_idx, this saves string compares but will only hit for matching dex
4228 // caches/files.
4229 switch (type) {
4230 case kDirect: // Fall-through.
4231 case kStatic:
Mathieu Chartier590fee92013-09-13 13:46:47 -07004232 resolved = klass->FindDirectMethod(dex_cache.get(), method_idx);
Ian Rogers08f753d2012-08-24 14:35:25 -07004233 break;
4234 case kInterface:
Mathieu Chartier590fee92013-09-13 13:46:47 -07004235 resolved = klass->FindInterfaceMethod(dex_cache.get(), method_idx);
Ian Rogers4c5b2652012-12-15 21:36:16 -08004236 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07004237 break;
4238 case kSuper: // Fall-through.
4239 case kVirtual:
Mathieu Chartier590fee92013-09-13 13:46:47 -07004240 resolved = klass->FindVirtualMethod(dex_cache.get(), method_idx);
Ian Rogers08f753d2012-08-24 14:35:25 -07004241 break;
4242 default:
4243 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004244 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004245 if (resolved == NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -07004246 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004247 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07004248 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07004249 switch (type) {
4250 case kDirect: // Fall-through.
4251 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08004252 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004253 break;
4254 case kInterface:
4255 resolved = klass->FindInterfaceMethod(name, signature);
Ian Rogers4c5b2652012-12-15 21:36:16 -08004256 DCHECK(resolved == NULL || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07004257 break;
4258 case kSuper: // Fall-through.
4259 case kVirtual:
4260 resolved = klass->FindVirtualMethod(name, signature);
4261 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004262 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004263 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004264 if (resolved != NULL) {
4265 // We found a method, check for incompatible class changes.
Ian Rogers87e552d2012-08-31 15:54:48 -07004266 if (resolved->CheckIncompatibleClassChange(type)) {
4267 resolved = NULL;
Ian Rogers08f753d2012-08-24 14:35:25 -07004268 }
4269 }
4270 if (resolved != NULL) {
4271 // Be a good citizen and update the dex cache to speed subsequent calls.
4272 dex_cache->SetResolvedMethod(method_idx, resolved);
4273 return resolved;
4274 } else {
jeffhaoc0228b82012-08-29 18:15:05 -07004275 // We failed to find the method which means either an access error, an incompatible class
4276 // change, or no such method. First try to find the method among direct and virtual methods.
Ian Rogers08f753d2012-08-24 14:35:25 -07004277 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07004278 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07004279 switch (type) {
4280 case kDirect:
4281 case kStatic:
4282 resolved = klass->FindVirtualMethod(name, signature);
jeffhaoc0228b82012-08-29 18:15:05 -07004283 break;
4284 case kInterface:
4285 case kVirtual:
4286 case kSuper:
4287 resolved = klass->FindDirectMethod(name, signature);
4288 break;
4289 }
4290
4291 // If we found something, check that it can be accessed by the referrer.
4292 if (resolved != NULL && referrer != NULL) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004293 mirror::Class* methods_class = resolved->GetDeclaringClass();
4294 mirror::Class* referring_class = referrer->GetDeclaringClass();
jeffhaoc0228b82012-08-29 18:15:05 -07004295 if (!referring_class->CanAccess(methods_class)) {
Ian Rogers87e552d2012-08-31 15:54:48 -07004296 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
Vladimir Marko23a28212014-01-09 19:24:37 +00004297 resolved, type);
jeffhaoc0228b82012-08-29 18:15:05 -07004298 return NULL;
4299 } else if (!referring_class->CanAccessMember(methods_class,
4300 resolved->GetAccessFlags())) {
Ian Rogers87e552d2012-08-31 15:54:48 -07004301 ThrowIllegalAccessErrorMethod(referring_class, resolved);
jeffhaoc0228b82012-08-29 18:15:05 -07004302 return NULL;
4303 }
4304 }
4305
4306 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
4307 // methods and throw if we find the method there. If we find nothing, throw a NoSuchMethodError.
4308 switch (type) {
4309 case kDirect:
4310 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07004311 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004312 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004313 } else {
4314 resolved = klass->FindInterfaceMethod(name, signature);
4315 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004316 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004317 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004318 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004319 }
4320 }
4321 break;
4322 case kInterface:
Ian Rogers08f753d2012-08-24 14:35:25 -07004323 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004324 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004325 } else {
4326 resolved = klass->FindVirtualMethod(name, signature);
4327 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004328 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004329 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004330 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004331 }
4332 }
4333 break;
4334 case kSuper:
Ian Rogers62d6c772013-02-27 08:32:07 -08004335 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004336 break;
4337 case kVirtual:
Ian Rogers08f753d2012-08-24 14:35:25 -07004338 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004339 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004340 } else {
4341 resolved = klass->FindInterfaceMethod(name, signature);
4342 if (resolved != NULL) {
Ian Rogers2fc14272012-08-30 10:56:57 -07004343 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogers08f753d2012-08-24 14:35:25 -07004344 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004345 ThrowNoSuchMethodError(type, klass, name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07004346 }
4347 }
4348 break;
4349 }
4350 DCHECK(Thread::Current()->IsExceptionPending());
4351 return NULL;
4352 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004353}
4354
Mathieu Chartier590fee92013-09-13 13:46:47 -07004355mirror::ArtField* ClassLinker::ResolveField(const DexFile& dex_file, uint32_t field_idx,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004356 const SirtRef<mirror::DexCache>& dex_cache,
4357 const SirtRef<mirror::ClassLoader>& class_loader,
Brian Carlstrome8104522013-10-15 21:56:36 -07004358 bool is_static) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004359 DCHECK(dex_cache.get() != nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -07004360 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004361 if (resolved != NULL) {
4362 return resolved;
4363 }
4364 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004365 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004366 if (klass == NULL) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08004367 DCHECK(Thread::Current()->IsExceptionPending());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004368 return NULL;
4369 }
4370
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004371 if (is_static) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004372 resolved = klass->FindStaticField(dex_cache.get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004373 } else {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004374 resolved = klass->FindInstanceField(dex_cache.get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07004375 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004376
4377 if (resolved == NULL) {
4378 const char* name = dex_file.GetFieldName(field_id);
4379 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
4380 if (is_static) {
4381 resolved = klass->FindStaticField(name, type);
4382 } else {
4383 resolved = klass->FindInstanceField(name, type);
4384 }
4385 if (resolved == NULL) {
4386 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
4387 return NULL;
4388 }
Ian Rogersb067ac22011-12-13 18:05:09 -08004389 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004390 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08004391 return resolved;
4392}
4393
Brian Carlstromea46f952013-07-30 01:26:50 -07004394mirror::ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004395 uint32_t field_idx,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004396 const SirtRef<mirror::DexCache>& dex_cache,
4397 const SirtRef<mirror::ClassLoader>& class_loader) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004398 DCHECK(dex_cache.get() != nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -07004399 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Ian Rogersb067ac22011-12-13 18:05:09 -08004400 if (resolved != NULL) {
4401 return resolved;
4402 }
4403 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004404 mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
Ian Rogersb067ac22011-12-13 18:05:09 -08004405 if (klass == NULL) {
4406 DCHECK(Thread::Current()->IsExceptionPending());
4407 return NULL;
4408 }
4409
Ian Rogersdfb325e2013-10-30 01:00:44 -07004410 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
4411 StringPiece type(dex_file.StringDataByIdx(
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004412 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
Ian Rogersb067ac22011-12-13 18:05:09 -08004413 resolved = klass->FindField(name, type);
4414 if (resolved != NULL) {
4415 dex_cache->SetResolvedField(field_idx, resolved);
4416 } else {
4417 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004418 }
4419 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07004420}
4421
Brian Carlstromea46f952013-07-30 01:26:50 -07004422const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004423 uint32_t* length) {
4424 mirror::Class* declaring_class = referrer->GetDeclaringClass();
4425 mirror::DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07004426 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07004427 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08004428 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07004429}
4430
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004431void ClassLinker::DumpAllClasses(int flags) {
4432 if (dex_cache_image_class_lookup_required_) {
4433 MoveImageClassesToClassTable();
4434 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004435 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
4436 // 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 -08004437 std::vector<mirror::Class*> all_classes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004438 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004439 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004440 for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07004441 all_classes.push_back(it.second);
Ian Rogers5d76c432011-10-31 21:42:49 -07004442 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07004443 }
4444
4445 for (size_t i = 0; i < all_classes.size(); ++i) {
4446 all_classes[i]->DumpClass(std::cerr, flags);
4447 }
4448}
4449
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004450void ClassLinker::DumpForSigQuit(std::ostream& os) {
4451 if (dex_cache_image_class_lookup_required_) {
4452 MoveImageClassesToClassTable();
4453 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004454 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004455 os << "Loaded classes: " << class_table_.size() << " allocated classes\n";
Elliott Hughescac6cc72011-11-03 20:31:21 -07004456}
4457
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004458size_t ClassLinker::NumLoadedClasses() {
4459 if (dex_cache_image_class_lookup_required_) {
4460 MoveImageClassesToClassTable();
4461 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07004462 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004463 return class_table_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07004464}
4465
Brian Carlstrom47d237a2011-10-18 15:08:33 -07004466pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07004467 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07004468}
4469
4470pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004471 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07004472}
4473
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004474void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004475 DCHECK(!init_done_);
4476
4477 DCHECK(klass != NULL);
4478 DCHECK(klass->GetClassLoader() == NULL);
4479
4480 DCHECK(class_roots_ != NULL);
4481 DCHECK(class_roots_->Get(class_root) == NULL);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004482 class_roots_->Set<false>(class_root, klass);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004483}
4484
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004485} // namespace art