blob: ea59805f4d995141305294628ee8c8576d998b97 [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 Carlstromdbc05252011-09-09 01:59:59 -070022#include <deque>
Ian Rogers700a4022014-05-19 16:49:03 -070023#include <memory>
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"
Narayan Kamathd1c606f2014-06-09 16:50:19 +010030#include "base/scoped_flock.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080031#include "base/stl_util.h"
Elliott Hughes76160052012-12-12 16:31:20 -080032#include "base/unix_file/fd_file.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080033#include "class_linker-inl.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000034#include "compiler_callbacks.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080035#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070036#include "dex_file-inl.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070037#include "gc_root-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070038#include "gc/accounting/card_table-inl.h"
39#include "gc/accounting/heap_bitmap.h"
40#include "gc/heap.h"
41#include "gc/space/image_space.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070042#include "handle_scope.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070043#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070044#include "interpreter/interpreter.h"
Ian Rogers0571d352011-11-03 19:51:38 -070045#include "leb128.h"
Ian Rogerscb6b0f32014-08-12 02:30:58 -070046#include "method_helper-inl.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080047#include "oat.h"
Brian Carlstrom58ae9412011-10-04 00:56:06 -070048#include "oat_file.h"
Ian Rogers22d5e732014-07-15 22:23:51 -070049#include "object_lock.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070050#include "mirror/art_field-inl.h"
51#include "mirror/art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080052#include "mirror/class.h"
53#include "mirror/class-inl.h"
54#include "mirror/class_loader.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070055#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080056#include "mirror/iftable-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080057#include "mirror/object-inl.h"
58#include "mirror/object_array-inl.h"
59#include "mirror/proxy.h"
Fred Shih4ee7a662014-07-11 09:59:27 -070060#include "mirror/reference-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080061#include "mirror/stack_trace_element.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070062#include "mirror/string-inl.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080063#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070064#include "runtime.h"
Ian Rogers7655f292013-07-29 11:07:13 -070065#include "entrypoints/entrypoint_utils.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -070066#include "ScopedLocalRef.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070067#include "scoped_thread_state_change.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070068#include "handle_scope-inl.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070069#include "thread.h"
70#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080071#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070072#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070073
74namespace art {
75
Ian Rogers00f7d0e2012-07-19 15:28:27 -070076static void ThrowNoClassDefFoundError(const char* fmt, ...)
77 __attribute__((__format__(__printf__, 1, 2)))
Ian Rogersb726dcb2012-09-05 08:57:23 -070078 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -070079static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -070080 va_list args;
81 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -080082 Thread* self = Thread::Current();
83 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
84 self->ThrowNewExceptionV(throw_location, "Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -080085 va_end(args);
86}
87
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080088static void ThrowEarlierClassFailure(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -070089 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes5c599942012-06-13 16:45:05 -070090 // The class failed to initialize on a previous attempt, so we want to throw
91 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
92 // failed in verification, in which case v2 5.4.1 says we need to re-throw
93 // the previous error.
Ian Rogers87e552d2012-08-31 15:54:48 -070094 if (!Runtime::Current()->IsCompiler()) { // Give info if this occurs at runtime.
95 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
96 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -070097
Elliott Hughes5c599942012-06-13 16:45:05 -070098 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -080099 Thread* self = Thread::Current();
100 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700101 if (c->GetVerifyErrorClass() != NULL) {
102 // TODO: change the verifier to store an _instance_, with a useful detail message?
Ian Rogerscb6b0f32014-08-12 02:30:58 -0700103 std::string temp;
104 self->ThrowNewException(throw_location, c->GetVerifyErrorClass()->GetDescriptor(&temp),
Mathieu Chartierf8322842014-05-16 10:59:25 -0700105 PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700106 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -0800107 self->ThrowNewException(throw_location, "Ljava/lang/NoClassDefFoundError;",
108 PrettyDescriptor(c).c_str());
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700109 }
110}
111
Ian Rogers62d6c772013-02-27 08:32:07 -0800112static void WrapExceptionInInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700113 Thread* self = Thread::Current();
114 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700115
116 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
117 CHECK(cause.get() != NULL);
118
119 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700120 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
121 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700122
Elliott Hughesa4f94742012-05-29 16:28:38 -0700123 // We only wrap non-Error exceptions; an Error can just be used as-is.
124 if (!is_error) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800125 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
126 self->ThrowNewWrappedException(throw_location, "Ljava/lang/ExceptionInInitializerError;", NULL);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700127 }
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700128}
129
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800130static size_t Hash(const char* s) {
131 // This is the java.lang.String hashcode for convenience, not interoperability.
132 size_t hash = 0;
133 for (; *s != '\0'; ++s) {
134 hash = hash * 31 + *s;
135 }
136 return hash;
137}
138
Elliott Hughes418d20f2011-09-22 14:00:39 -0700139const char* ClassLinker::class_roots_descriptors_[] = {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700140 "Ljava/lang/Class;",
141 "Ljava/lang/Object;",
Elliott Hughes418d20f2011-09-22 14:00:39 -0700142 "[Ljava/lang/Class;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700143 "[Ljava/lang/Object;",
144 "Ljava/lang/String;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700145 "Ljava/lang/DexCache;",
Elliott Hughesbf61ba32011-10-11 10:53:09 -0700146 "Ljava/lang/ref/Reference;",
Brian Carlstromea46f952013-07-30 01:26:50 -0700147 "Ljava/lang/reflect/ArtField;",
148 "Ljava/lang/reflect/ArtMethod;",
Ian Rogers466bb252011-10-14 03:29:56 -0700149 "Ljava/lang/reflect/Proxy;",
Mathieu Chartier66f19252012-09-18 08:57:04 -0700150 "[Ljava/lang/String;",
Brian Carlstromea46f952013-07-30 01:26:50 -0700151 "[Ljava/lang/reflect/ArtField;",
152 "[Ljava/lang/reflect/ArtMethod;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700153 "Ljava/lang/ClassLoader;",
Ian Rogers5167c972012-02-03 10:41:20 -0800154 "Ljava/lang/Throwable;",
jeffhao8cd6dda2012-02-22 10:15:34 -0800155 "Ljava/lang/ClassNotFoundException;",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700156 "Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700157 "Z",
158 "B",
159 "C",
160 "D",
161 "F",
162 "I",
163 "J",
164 "S",
165 "V",
166 "[Z",
167 "[B",
168 "[C",
169 "[D",
170 "[F",
171 "[I",
172 "[J",
173 "[S",
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700174 "[Ljava/lang/StackTraceElement;",
Brian Carlstroma663ea52011-08-19 23:33:41 -0700175};
176
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800177ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700178 // dex_lock_ is recursive as it may be used in stack dumping.
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700179 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700180 dex_cache_image_class_lookup_required_(false),
181 failed_dex_cache_class_lookups_(0),
Ian Rogers98379392014-02-24 16:53:16 -0800182 class_roots_(nullptr),
183 array_iftable_(nullptr),
184 find_array_class_cache_next_victim_(0),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700185 init_done_(false),
Mathieu Chartier893263b2014-03-04 11:07:42 -0800186 log_new_dex_caches_roots_(false),
187 log_new_class_table_roots_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700188 intern_table_(intern_table),
Ian Rogers98379392014-02-24 16:53:16 -0800189 portable_resolution_trampoline_(nullptr),
190 quick_resolution_trampoline_(nullptr),
191 portable_imt_conflict_trampoline_(nullptr),
Andreas Gampe2da88232014-02-27 12:26:20 -0800192 quick_imt_conflict_trampoline_(nullptr),
Vladimir Marko8a630572014-04-09 18:45:35 +0100193 quick_generic_jni_trampoline_(nullptr),
194 quick_to_interpreter_bridge_trampoline_(nullptr) {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700195 CHECK_EQ(arraysize(class_roots_descriptors_), size_t(kClassRootsMax));
Ian Rogers98379392014-02-24 16:53:16 -0800196 memset(find_array_class_cache_, 0, kFindArrayCacheSize * sizeof(mirror::Class*));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700197}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700198
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700199// To set a value for generic JNI. May be necessary in compiler tests.
200extern "C" void art_quick_generic_jni_trampoline(mirror::ArtMethod*);
Alex Light507e6182014-08-19 14:23:13 -0700201extern "C" void art_quick_resolution_trampoline(mirror::ArtMethod*);
202extern "C" void art_quick_imt_conflict_trampoline(mirror::ArtMethod*);
203extern "C" void art_quick_to_interpreter_bridge(mirror::ArtMethod*);
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700204
Alex Light507e6182014-08-19 14:23:13 -0700205void ClassLinker::InitWithoutImage(const std::vector<const DexFile*>& boot_class_path) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800206 VLOG(startup) << "ClassLinker::Init";
Alex Light507e6182014-08-19 14:23:13 -0700207 CHECK(!Runtime::Current()->GetHeap()->HasImageSpace()) << "Runtime has image. We should use it.";
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700208
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700209 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700210
Elliott Hughes30646832011-10-13 16:59:46 -0700211 // java_lang_Class comes first, it's needed for AllocClass
Ian Rogers1f539342012-10-03 21:09:42 -0700212 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -0700213 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700214 // 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 -0800215 heap->IncrementDisableMovingGC(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700216 StackHandleScope<64> hs(self); // 64 is picked arbitrarily.
217 Handle<mirror::Class> java_lang_Class(hs.NewHandle(down_cast<mirror::Class*>(
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700218 heap->AllocNonMovableObject<true>(self, nullptr,
219 mirror::Class::ClassClassSize(),
Brian Carlstromf3632832014-05-20 15:36:53 -0700220 VoidFunctor()))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700221 CHECK(java_lang_Class.Get() != NULL);
222 mirror::Class::SetClassClass(java_lang_Class.Get());
223 java_lang_Class->SetClass(java_lang_Class.Get());
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -0700224 if (kUseBakerOrBrooksReadBarrier) {
225 java_lang_Class->AssertReadBarrierPointer();
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800226 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700227 java_lang_Class->SetClassSize(mirror::Class::ClassClassSize());
Mathieu Chartier1d27b342014-01-28 12:51:09 -0800228 heap->DecrementDisableMovingGC(self);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800229 // AllocClass(mirror::Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700230
Elliott Hughes418d20f2011-09-22 14:00:39 -0700231 // Class[] is used for reflection support.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700232 Handle<mirror::Class> class_array_class(hs.NewHandle(
233 AllocClass(self, java_lang_Class.Get(), mirror::ObjectArray<mirror::Class>::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700234 class_array_class->SetComponentType(java_lang_Class.Get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700235
Ian Rogers23435d02012-09-24 11:23:12 -0700236 // java_lang_Object comes next so that object_array_class can be created.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700237 Handle<mirror::Class> java_lang_Object(hs.NewHandle(
238 AllocClass(self, java_lang_Class.Get(), mirror::Object::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700239 CHECK(java_lang_Object.Get() != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700240 // backfill Object as the super class of Class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700241 java_lang_Class->SetSuperClass(java_lang_Object.Get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700242 java_lang_Object->SetStatus(mirror::Class::kStatusLoaded, self);
Brian Carlstroma0808032011-07-18 00:39:23 -0700243
Ian Rogers23435d02012-09-24 11:23:12 -0700244 // Object[] next to hold class roots.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700245 Handle<mirror::Class> object_array_class(hs.NewHandle(
246 AllocClass(self, java_lang_Class.Get(), mirror::ObjectArray<mirror::Object>::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700247 object_array_class->SetComponentType(java_lang_Object.Get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700248
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700249 // Setup the char (primitive) class to be used for char[].
250 Handle<mirror::Class> char_class(hs.NewHandle(
251 AllocClass(self, java_lang_Class.Get(), mirror::Class::PrimitiveClassSize())));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700252
Ian Rogers23435d02012-09-24 11:23:12 -0700253 // Setup the char[] class to be used for String.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700254 Handle<mirror::Class> char_array_class(hs.NewHandle(
255 AllocClass(self, java_lang_Class.Get(),
256 mirror::Array::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700257 char_array_class->SetComponentType(char_class.Get());
258 mirror::CharArray::SetArrayClass(char_array_class.Get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700259
Ian Rogers23435d02012-09-24 11:23:12 -0700260 // Setup String.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700261 Handle<mirror::Class> java_lang_String(hs.NewHandle(
262 AllocClass(self, java_lang_Class.Get(), mirror::String::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700263 mirror::String::SetClass(java_lang_String.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700264 java_lang_String->SetObjectSize(mirror::String::InstanceSize());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700265 java_lang_String->SetStatus(mirror::Class::kStatusResolved, self);
Jesse Wilson14150742011-07-29 19:04:44 -0400266
Fred Shih4ee7a662014-07-11 09:59:27 -0700267 // Setup Reference.
268 Handle<mirror::Class> java_lang_ref_Reference(hs.NewHandle(
269 AllocClass(self, java_lang_Class.Get(), mirror::Reference::ClassSize())));
270 mirror::Reference::SetClass(java_lang_ref_Reference.Get());
271 java_lang_ref_Reference->SetObjectSize(mirror::Reference::InstanceSize());
272 java_lang_ref_Reference->SetStatus(mirror::Class::kStatusResolved, self);
273
Ian Rogers23435d02012-09-24 11:23:12 -0700274 // Create storage for root classes, save away our work so far (requires descriptors).
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700275 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class> >(
276 mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.Get(),
277 kClassRootsMax));
278 CHECK(!class_roots_.IsNull());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700279 SetClassRoot(kJavaLangClass, java_lang_Class.Get());
280 SetClassRoot(kJavaLangObject, java_lang_Object.Get());
281 SetClassRoot(kClassArrayClass, class_array_class.Get());
282 SetClassRoot(kObjectArrayClass, object_array_class.Get());
283 SetClassRoot(kCharArrayClass, char_array_class.Get());
284 SetClassRoot(kJavaLangString, java_lang_String.Get());
Fred Shih4ee7a662014-07-11 09:59:27 -0700285 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700286
287 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700288 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
289 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
290 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
291 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
292 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
293 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
294 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
295 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700296
Ian Rogers23435d02012-09-24 11:23:12 -0700297 // Create array interface entries to populate once we can load system classes.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700298 array_iftable_ = GcRoot<mirror::IfTable>(AllocIfTable(self, 2));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700299
Ian Rogers23435d02012-09-24 11:23:12 -0700300 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700301 Handle<mirror::Class> int_array_class(hs.NewHandle(
302 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize())));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700303 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700304 mirror::IntArray::SetArrayClass(int_array_class.Get());
305 SetClassRoot(kIntArrayClass, int_array_class.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700306
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700307 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700308
Ian Rogers52813c92012-10-11 11:50:38 -0700309 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700310 Handle<mirror::Class> java_lang_DexCache(hs.NewHandle(
311 AllocClass(self, java_lang_Class.Get(), mirror::DexCache::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700312 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700313 java_lang_DexCache->SetObjectSize(mirror::DexCache::InstanceSize());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700314 java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700315
Brian Carlstromf3632832014-05-20 15:36:53 -0700316 // Constructor, Field, Method, and AbstractMethod are necessary so
317 // that FindClass can link members.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700318 Handle<mirror::Class> java_lang_reflect_ArtField(hs.NewHandle(
319 AllocClass(self, java_lang_Class.Get(), mirror::ArtField::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700320 CHECK(java_lang_reflect_ArtField.Get() != NULL);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700321 java_lang_reflect_ArtField->SetObjectSize(mirror::ArtField::InstanceSize());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700322 SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.Get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700323 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved, self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700324 mirror::ArtField::SetClass(java_lang_reflect_ArtField.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700325
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700326 Handle<mirror::Class> java_lang_reflect_ArtMethod(hs.NewHandle(
327 AllocClass(self, java_lang_Class.Get(), mirror::ArtMethod::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700328 CHECK(java_lang_reflect_ArtMethod.Get() != NULL);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700329 java_lang_reflect_ArtMethod->SetObjectSize(mirror::ArtMethod::InstanceSize());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700330 SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.Get());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700331 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved, self);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700332
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700333 mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.Get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700334
335 // Set up array classes for string, field, method
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700336 Handle<mirror::Class> object_array_string(hs.NewHandle(
337 AllocClass(self, java_lang_Class.Get(),
338 mirror::ObjectArray<mirror::String>::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700339 object_array_string->SetComponentType(java_lang_String.Get());
340 SetClassRoot(kJavaLangStringArrayClass, object_array_string.Get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700341
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700342 Handle<mirror::Class> object_array_art_method(hs.NewHandle(
343 AllocClass(self, java_lang_Class.Get(),
344 mirror::ObjectArray<mirror::ArtMethod>::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700345 object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.Get());
346 SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.Get());
Ian Rogers4445a7e2012-10-05 17:19:13 -0700347
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700348 Handle<mirror::Class> object_array_art_field(hs.NewHandle(
349 AllocClass(self, java_lang_Class.Get(),
350 mirror::ObjectArray<mirror::ArtField>::ClassSize())));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700351 object_array_art_field->SetComponentType(java_lang_reflect_ArtField.Get());
352 SetClassRoot(kJavaLangReflectArtFieldArrayClass, object_array_art_field.Get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700353
Ian Rogers23435d02012-09-24 11:23:12 -0700354 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
355 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
356 // these roots.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700357 CHECK_NE(0U, boot_class_path.size());
358 for (size_t i = 0; i != boot_class_path.size(); ++i) {
359 const DexFile* dex_file = boot_class_path[i];
360 CHECK(dex_file != NULL);
361 AppendToBootClassPath(*dex_file);
362 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700363
364 // now we can use FindSystemClass
365
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700366 // run char class through InitializePrimitiveClass to finish init
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700367 InitializePrimitiveClass(char_class.Get(), Primitive::kPrimChar);
368 SetClassRoot(kPrimitiveChar, char_class.Get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700369
Jeff Hao88474b42013-10-23 16:24:40 -0700370 // Create runtime resolution and imt conflict methods. Also setup the default imt.
371 Runtime* runtime = Runtime::Current();
372 runtime->SetResolutionMethod(runtime->CreateResolutionMethod());
373 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod());
374 runtime->SetDefaultImt(runtime->CreateDefaultImt(this));
375
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700376 // Set up GenericJNI entrypoint. That is mainly a hack for common_compiler_test.h so that
377 // we do not need friend classes or a publicly exposed setter.
378 quick_generic_jni_trampoline_ = reinterpret_cast<void*>(art_quick_generic_jni_trampoline);
Alex Light507e6182014-08-19 14:23:13 -0700379 if (!runtime->IsCompiler()) {
380 // We need to set up the generic trampolines since we don't have an image.
381 quick_resolution_trampoline_ = reinterpret_cast<void*>(art_quick_resolution_trampoline);
382 quick_imt_conflict_trampoline_ = reinterpret_cast<void*>(art_quick_imt_conflict_trampoline);
383 quick_to_interpreter_bridge_trampoline_ = reinterpret_cast<void*>(art_quick_to_interpreter_bridge);
384 }
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700385
Mathieu Chartier66f19252012-09-18 08:57:04 -0700386 // Object, String and DexCache need to be rerun through FindSystemClass to finish init
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700387 java_lang_Object->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800388 mirror::Class* Object_class = FindSystemClass(self, "Ljava/lang/Object;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700389 CHECK_EQ(java_lang_Object.Get(), Object_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700390 CHECK_EQ(java_lang_Object->GetObjectSize(), mirror::Object::InstanceSize());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700391 java_lang_String->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800392 mirror::Class* String_class = FindSystemClass(self, "Ljava/lang/String;");
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700393 std::ostringstream os1, os2;
394 java_lang_String->DumpClass(os1, mirror::Class::kDumpClassFullDetail);
395 String_class->DumpClass(os2, mirror::Class::kDumpClassFullDetail);
396 CHECK_EQ(java_lang_String.Get(), String_class) << os1.str() << "\n\n" << os2.str();
397 CHECK_EQ(java_lang_String->GetObjectSize(), mirror::String::InstanceSize());
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700398 java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800399 mirror::Class* DexCache_class = FindSystemClass(self, "Ljava/lang/DexCache;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700400 CHECK_EQ(java_lang_String.Get(), String_class);
401 CHECK_EQ(java_lang_DexCache.Get(), DexCache_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700402 CHECK_EQ(java_lang_DexCache->GetObjectSize(), mirror::DexCache::InstanceSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700403
Ian Rogers23435d02012-09-24 11:23:12 -0700404 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers98379392014-02-24 16:53:16 -0800405 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800406 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700407
Ian Rogers98379392014-02-24 16:53:16 -0800408 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800409 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700410
Ian Rogers98379392014-02-24 16:53:16 -0800411 mirror::Class* found_char_array_class = FindSystemClass(self, "[C");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700412 CHECK_EQ(char_array_class.Get(), found_char_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700413
Ian Rogers98379392014-02-24 16:53:16 -0800414 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800415 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700416
Ian Rogers98379392014-02-24 16:53:16 -0800417 mirror::Class* found_int_array_class = FindSystemClass(self, "[I");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700418 CHECK_EQ(int_array_class.Get(), found_int_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700419
Ian Rogers98379392014-02-24 16:53:16 -0800420 SetClassRoot(kLongArrayClass, FindSystemClass(self, "[J"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800421 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700422
Ian Rogers98379392014-02-24 16:53:16 -0800423 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800424 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700425
Ian Rogers98379392014-02-24 16:53:16 -0800426 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800427 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700428
Ian Rogers98379392014-02-24 16:53:16 -0800429 mirror::Class* found_class_array_class = FindSystemClass(self, "[Ljava/lang/Class;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700430 CHECK_EQ(class_array_class.Get(), found_class_array_class);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700431
Ian Rogers98379392014-02-24 16:53:16 -0800432 mirror::Class* found_object_array_class = FindSystemClass(self, "[Ljava/lang/Object;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700433 CHECK_EQ(object_array_class.Get(), found_object_array_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700434
Ian Rogers23435d02012-09-24 11:23:12 -0700435 // Setup the single, global copy of "iftable".
Ian Rogers98379392014-02-24 16:53:16 -0800436 mirror::Class* java_lang_Cloneable = FindSystemClass(self, "Ljava/lang/Cloneable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700437 CHECK(java_lang_Cloneable != NULL);
Ian Rogers98379392014-02-24 16:53:16 -0800438 mirror::Class* java_io_Serializable = FindSystemClass(self, "Ljava/io/Serializable;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700439 CHECK(java_io_Serializable != NULL);
Ian Rogers23435d02012-09-24 11:23:12 -0700440 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
441 // crawl up and explicitly list all of the supers as well.
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700442 {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700443 mirror::IfTable* array_iftable = array_iftable_.Read();
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700444 array_iftable->SetInterface(0, java_lang_Cloneable);
445 array_iftable->SetInterface(1, java_io_Serializable);
446 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700447
Ian Rogers23435d02012-09-24 11:23:12 -0700448 // Sanity check Class[] and Object[]'s interfaces.
Mathieu Chartierf8322842014-05-16 10:59:25 -0700449 CHECK_EQ(java_lang_Cloneable, mirror::Class::GetDirectInterface(self, class_array_class, 0));
450 CHECK_EQ(java_io_Serializable, mirror::Class::GetDirectInterface(self, class_array_class, 1));
451 CHECK_EQ(java_lang_Cloneable, mirror::Class::GetDirectInterface(self, object_array_class, 0));
452 CHECK_EQ(java_io_Serializable, mirror::Class::GetDirectInterface(self, object_array_class, 1));
Brian Carlstromea46f952013-07-30 01:26:50 -0700453 // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700454 // dex_cache_ fields and register them in class_table_.
Ian Rogers98379392014-02-24 16:53:16 -0800455 mirror::Class* Class_class = FindSystemClass(self, "Ljava/lang/Class;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700456 CHECK_EQ(java_lang_Class.Get(), Class_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700457
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700458 java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800459 mirror::Class* Art_method_class = FindSystemClass(self, "Ljava/lang/reflect/ArtMethod;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700460 CHECK_EQ(java_lang_reflect_ArtMethod.Get(), Art_method_class);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700461
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700462 java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady, self);
Ian Rogers98379392014-02-24 16:53:16 -0800463 mirror::Class* Art_field_class = FindSystemClass(self, "Ljava/lang/reflect/ArtField;");
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700464 CHECK_EQ(java_lang_reflect_ArtField.Get(), Art_field_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700465
Brian Carlstromf3632832014-05-20 15:36:53 -0700466 mirror::Class* String_array_class =
467 FindSystemClass(self, class_roots_descriptors_[kJavaLangStringArrayClass]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700468 CHECK_EQ(object_array_string.Get(), String_array_class);
Mathieu Chartier66f19252012-09-18 08:57:04 -0700469
Brian Carlstromea46f952013-07-30 01:26:50 -0700470 mirror::Class* Art_method_array_class =
Ian Rogers98379392014-02-24 16:53:16 -0800471 FindSystemClass(self, class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700472 CHECK_EQ(object_array_art_method.Get(), Art_method_array_class);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700473
Brian Carlstromea46f952013-07-30 01:26:50 -0700474 mirror::Class* Art_field_array_class =
Ian Rogers98379392014-02-24 16:53:16 -0800475 FindSystemClass(self, class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700476 CHECK_EQ(object_array_art_field.Get(), Art_field_array_class);
Ian Rogers4445a7e2012-10-05 17:19:13 -0700477
Ian Rogers23435d02012-09-24 11:23:12 -0700478 // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700479
Ian Rogers23435d02012-09-24 11:23:12 -0700480 // Create java.lang.reflect.Proxy root.
Ian Rogers98379392014-02-24 16:53:16 -0800481 mirror::Class* java_lang_reflect_Proxy = FindSystemClass(self, "Ljava/lang/reflect/Proxy;");
Ian Rogers466bb252011-10-14 03:29:56 -0700482 SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
483
Brian Carlstrom1f870082011-08-23 16:02:11 -0700484 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Fred Shih4ee7a662014-07-11 09:59:27 -0700485 // finish initializing Reference class
486 java_lang_ref_Reference->SetStatus(mirror::Class::kStatusNotReady, self);
487 mirror::Class* Reference_class = FindSystemClass(self, "Ljava/lang/ref/Reference;");
488 CHECK_EQ(java_lang_ref_Reference.Get(), Reference_class);
489 CHECK_EQ(java_lang_ref_Reference->GetObjectSize(), mirror::Reference::InstanceSize());
490 CHECK_EQ(java_lang_ref_Reference->GetClassSize(), mirror::Reference::ClassSize());
Brian Carlstromf3632832014-05-20 15:36:53 -0700491 mirror::Class* java_lang_ref_FinalizerReference =
492 FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700493 java_lang_ref_FinalizerReference->SetAccessFlags(
494 java_lang_ref_FinalizerReference->GetAccessFlags() |
495 kAccClassIsReference | kAccClassIsFinalizerReference);
Brian Carlstromf3632832014-05-20 15:36:53 -0700496 mirror::Class* java_lang_ref_PhantomReference =
497 FindSystemClass(self, "Ljava/lang/ref/PhantomReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700498 java_lang_ref_PhantomReference->SetAccessFlags(
499 java_lang_ref_PhantomReference->GetAccessFlags() |
500 kAccClassIsReference | kAccClassIsPhantomReference);
Brian Carlstromf3632832014-05-20 15:36:53 -0700501 mirror::Class* java_lang_ref_SoftReference =
502 FindSystemClass(self, "Ljava/lang/ref/SoftReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700503 java_lang_ref_SoftReference->SetAccessFlags(
504 java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
Brian Carlstromf3632832014-05-20 15:36:53 -0700505 mirror::Class* java_lang_ref_WeakReference =
506 FindSystemClass(self, "Ljava/lang/ref/WeakReference;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700507 java_lang_ref_WeakReference->SetAccessFlags(
508 java_lang_ref_WeakReference->GetAccessFlags() |
509 kAccClassIsReference | kAccClassIsWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700510
Ian Rogers23435d02012-09-24 11:23:12 -0700511 // Setup the ClassLoader, verifying the object_size_.
Ian Rogers98379392014-02-24 16:53:16 -0800512 mirror::Class* java_lang_ClassLoader = FindSystemClass(self, "Ljava/lang/ClassLoader;");
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700513 CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), mirror::ClassLoader::InstanceSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700514 SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
515
jeffhao8cd6dda2012-02-22 10:15:34 -0800516 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700517 // java.lang.StackTraceElement as a convenience.
Ian Rogers98379392014-02-24 16:53:16 -0800518 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800519 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Brian Carlstromf3632832014-05-20 15:36:53 -0700520 SetClassRoot(kJavaLangClassNotFoundException,
521 FindSystemClass(self, "Ljava/lang/ClassNotFoundException;"));
Ian Rogers98379392014-02-24 16:53:16 -0800522 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;"));
Brian Carlstromf3632832014-05-20 15:36:53 -0700523 SetClassRoot(kJavaLangStackTraceElementArrayClass,
524 FindSystemClass(self, "[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800525 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700526
Ian Rogers98379392014-02-24 16:53:16 -0800527 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700528
Brian Carlstroma004aa92012-02-08 18:05:09 -0800529 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700530}
531
Ian Rogers98379392014-02-24 16:53:16 -0800532void ClassLinker::FinishInit(Thread* self) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800533 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700534
535 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700536 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700537 // as the types of the field can't be resolved prior to the runtime being
538 // fully initialized
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800539 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700540 mirror::Class* java_lang_ref_FinalizerReference =
Ian Rogers98379392014-02-24 16:53:16 -0800541 FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800542
Brian Carlstromea46f952013-07-30 01:26:50 -0700543 mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700544 CHECK_STREQ(pendingNext->GetName(), "pendingNext");
545 CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700546
Brian Carlstromea46f952013-07-30 01:26:50 -0700547 mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700548 CHECK_STREQ(queue->GetName(), "queue");
549 CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700550
Brian Carlstromea46f952013-07-30 01:26:50 -0700551 mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700552 CHECK_STREQ(queueNext->GetName(), "queueNext");
553 CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700554
Brian Carlstromea46f952013-07-30 01:26:50 -0700555 mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700556 CHECK_STREQ(referent->GetName(), "referent");
557 CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700558
Brian Carlstromea46f952013-07-30 01:26:50 -0700559 mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700560 CHECK_STREQ(zombie->GetName(), "zombie");
561 CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700562
Brian Carlstroma663ea52011-08-19 23:33:41 -0700563 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700564 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700565 ClassRoot class_root = static_cast<ClassRoot>(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800566 mirror::Class* klass = GetClassRoot(class_root);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700567 CHECK(klass != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700568 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700569 // note SetClassRoot does additional validation.
570 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700571 }
572
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700573 CHECK(!array_iftable_.IsNull());
Elliott Hughes92f14b22011-10-06 12:29:54 -0700574
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700575 // disable the slow paths in FindClass and CreatePrimitiveClass now
576 // that Object, Class, and Object[] are setup
577 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700578
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800579 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700580}
581
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700582void ClassLinker::RunRootClinits() {
583 Thread* self = Thread::Current();
584 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800585 mirror::Class* c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700586 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700587 StackHandleScope<1> hs(self);
588 Handle<mirror::Class> h_class(hs.NewHandle(GetClassRoot(ClassRoot(i))));
589 EnsureInitialized(h_class, true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700590 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700591 }
592 }
593}
594
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700595bool ClassLinker::GenerateOatFile(const char* dex_filename,
Brian Carlstromd601af82012-01-06 10:15:19 -0800596 int oat_fd,
Vladimir Marko60836d52014-01-16 15:53:38 +0000597 const char* oat_cache_filename,
598 std::string* error_msg) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700599 Locks::mutator_lock_->AssertNotHeld(Thread::Current()); // Avoid starving GC.
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700600 std::string dex2oat(Runtime::Current()->GetCompilerExecutable());
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800601
Ian Rogers1d54e732013-05-02 21:10:01 -0700602 gc::Heap* heap = Runtime::Current()->GetHeap();
Brian Carlstrom6449c622014-02-10 23:48:36 -0800603 std::string boot_image_option("--boot-image=");
Alex Light507e6182014-08-19 14:23:13 -0700604 if (heap->GetImageSpace() == nullptr) {
605 // TODO If we get a dex2dex compiler working we could maybe use that, OTOH since we are likely
606 // out of space anyway it might not matter.
607 *error_msg = StringPrintf("Cannot create oat file for '%s' because we are running "
608 "without an image.", dex_filename);
609 return false;
610 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700611 boot_image_option += heap->GetImageSpace()->GetImageLocation();
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800612
Brian Carlstrom6449c622014-02-10 23:48:36 -0800613 std::string dex_file_option("--dex-file=");
614 dex_file_option += dex_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800615
Brian Carlstrom6449c622014-02-10 23:48:36 -0800616 std::string oat_fd_option("--oat-fd=");
617 StringAppendF(&oat_fd_option, "%d", oat_fd);
Brian Carlstromd601af82012-01-06 10:15:19 -0800618
Brian Carlstrom6449c622014-02-10 23:48:36 -0800619 std::string oat_location_option("--oat-location=");
620 oat_location_option += oat_cache_filename;
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800621
Brian Carlstrom6449c622014-02-10 23:48:36 -0800622 std::vector<std::string> argv;
623 argv.push_back(dex2oat);
624 argv.push_back("--runtime-arg");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800625 argv.push_back("-classpath");
626 argv.push_back("--runtime-arg");
Brian Carlstrom35d8b8e2014-02-25 10:51:11 -0800627 argv.push_back(Runtime::Current()->GetClassPathString());
Dave Allisonb373e092014-02-20 16:06:36 -0800628
Ian Rogers8afeb852014-04-02 14:55:49 -0700629 Runtime::Current()->AddCurrentRuntimeFeaturesAsDex2OatArguments(&argv);
Dave Allisonb373e092014-02-20 16:06:36 -0800630
Jeff Hao4a200f52014-04-01 14:58:49 -0700631 if (!Runtime::Current()->IsVerificationEnabled()) {
632 argv.push_back("--compiler-filter=verify-none");
633 }
634
Alex Light345c4b12014-07-18 14:57:04 -0700635 if (Runtime::Current()->MustRelocateIfPossible()) {
636 argv.push_back("--runtime-arg");
637 argv.push_back("-Xrelocate");
638 } else {
639 argv.push_back("--runtime-arg");
640 argv.push_back("-Xnorelocate");
641 }
642
Brian Carlstrom6449c622014-02-10 23:48:36 -0800643 if (!kIsTargetBuild) {
644 argv.push_back("--host");
buzbeea024a062013-07-31 10:47:37 -0700645 }
Ian Rogers8afeb852014-04-02 14:55:49 -0700646
Brian Carlstrom6449c622014-02-10 23:48:36 -0800647 argv.push_back(boot_image_option);
648 argv.push_back(dex_file_option);
649 argv.push_back(oat_fd_option);
650 argv.push_back(oat_location_option);
651 const std::vector<std::string>& compiler_options = Runtime::Current()->GetCompilerOptions();
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800652 for (size_t i = 0; i < compiler_options.size(); ++i) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800653 argv.push_back(compiler_options[i].c_str());
jeffhao262bf462011-10-20 18:36:32 -0700654 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800655
656 return Exec(argv, error_msg);
jeffhao262bf462011-10-20 18:36:32 -0700657}
658
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700659const OatFile* ClassLinker::RegisterOatFile(const OatFile* oat_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700660 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800661 if (kIsDebugBuild) {
662 for (size_t i = 0; i < oat_files_.size(); ++i) {
663 CHECK_NE(oat_file, oat_files_[i]) << oat_file->GetLocation();
Ian Rogers1bf8d4d2013-05-30 00:18:49 -0700664 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800665 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700666 VLOG(class_linker) << "Registering " << oat_file->GetLocation();
667 oat_files_.push_back(oat_file);
668 return oat_file;
Brian Carlstrom866c8622012-01-06 16:35:13 -0800669}
670
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700671OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
672 VLOG(startup) << "ClassLinker::GetImageOatFile entering";
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700673 OatFile* oat_file = space->ReleaseOatFile();
674 CHECK_EQ(RegisterOatFile(oat_file), oat_file);
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700675 VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700676 return *oat_file;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700677}
678
Brian Carlstromae826982011-11-09 01:33:42 -0800679const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800680 const char* dex_location = dex_file.GetLocation().c_str();
681 uint32_t dex_location_checksum = dex_file.GetLocationChecksum();
Andreas Gampe833a4852014-05-21 18:46:59 -0700682 return FindOpenedOatFile(nullptr, dex_location, &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800683}
684
Andreas Gampe833a4852014-05-21 18:46:59 -0700685const OatFile* ClassLinker::FindOpenedOatFile(const char* oat_location, const char* dex_location,
686 const uint32_t* const dex_location_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700687 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -0800688 for (size_t i = 0; i < oat_files_.size(); i++) {
689 const OatFile* oat_file = oat_files_[i];
690 DCHECK(oat_file != NULL);
Andreas Gampe833a4852014-05-21 18:46:59 -0700691
692 if (oat_location != nullptr) {
693 if (oat_file->GetLocation() != oat_location) {
694 continue;
695 }
696 }
697
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700698 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
Brian Carlstrom08cbf662013-12-10 16:52:57 -0800699 dex_location_checksum,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700700 false);
Brian Carlstroma004aa92012-02-08 18:05:09 -0800701 if (oat_dex_file != NULL) {
Brian Carlstromae826982011-11-09 01:33:42 -0800702 return oat_file;
703 }
704 }
705 return NULL;
706}
707
Calin Juravleca345932014-09-02 15:53:55 +0100708
709// Loads all multi dex files from the given oat file returning true on success.
710//
711// Parameters:
712// oat_file - the oat file to load from
713// dex_location - the dex location used to generate the oat file
714// dex_location_checksum - the checksum of the dex_location (may be null for pre-opted files)
715// generated - whether or not the oat_file existed before or was just (re)generated
716// error_msgs - any error messages will be appended here
717// dex_files - the loaded dex_files will be appended here (only if the loading succeeds)
718static bool LoadMultiDexFilesFromOatFile(const OatFile* oat_file,
719 const char* dex_location,
720 const uint32_t* dex_location_checksum,
Andreas Gampe833a4852014-05-21 18:46:59 -0700721 bool generated,
722 std::vector<std::string>* error_msgs,
723 std::vector<const DexFile*>* dex_files) {
724 if (oat_file == nullptr) {
725 return false;
726 }
727
728 size_t old_size = dex_files->size(); // To rollback on error.
729
730 bool success = true;
731 for (size_t i = 0; success; ++i) {
Calin Juravle4e1d5792014-07-15 23:56:47 +0100732 std::string next_name_str = DexFile::GetMultiDexClassesDexName(i, dex_location);
Andreas Gampe833a4852014-05-21 18:46:59 -0700733 const char* next_name = next_name_str.c_str();
734
Calin Juravleca345932014-09-02 15:53:55 +0100735 uint32_t next_location_checksum;
736 uint32_t* next_location_checksum_pointer = &next_location_checksum;
Andreas Gampe833a4852014-05-21 18:46:59 -0700737 std::string error_msg;
Calin Juravleca345932014-09-02 15:53:55 +0100738 if ((i == 0) && (strcmp(next_name, dex_location) == 0)) {
739 // When i=0 the multidex name should be the same as the location name. We already have the
740 // checksum it so we don't need to recompute it.
741 if (dex_location_checksum == nullptr) {
742 next_location_checksum_pointer = nullptr;
743 } else {
744 next_location_checksum = *dex_location_checksum;
745 }
746 } else if (!DexFile::GetChecksum(next_name, next_location_checksum_pointer, &error_msg)) {
Andreas Gampe833a4852014-05-21 18:46:59 -0700747 DCHECK_EQ(false, i == 0 && generated);
Calin Juravleca345932014-09-02 15:53:55 +0100748 next_location_checksum_pointer = nullptr;
Andreas Gampe833a4852014-05-21 18:46:59 -0700749 }
750
751 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(next_name, nullptr, false);
752
753 if (oat_dex_file == nullptr) {
754 if (i == 0 && generated) {
755 std::string error_msg;
756 error_msg = StringPrintf("\nFailed to find dex file '%s' (checksum 0x%x) in generated out "
Calin Juravleca345932014-09-02 15:53:55 +0100757 " file'%s'", dex_location, next_location_checksum,
Andreas Gampe833a4852014-05-21 18:46:59 -0700758 oat_file->GetLocation().c_str());
759 error_msgs->push_back(error_msg);
760 }
761 break; // Not found, done.
762 }
763
764 // Checksum test. Test must succeed when generated.
765 success = !generated;
Calin Juravleca345932014-09-02 15:53:55 +0100766 if (next_location_checksum_pointer != nullptr) {
767 success = next_location_checksum == oat_dex_file->GetDexFileLocationChecksum();
Andreas Gampe833a4852014-05-21 18:46:59 -0700768 }
769
770 if (success) {
771 const DexFile* dex_file = oat_dex_file->OpenDexFile(&error_msg);
772 if (dex_file == nullptr) {
773 success = false;
774 error_msgs->push_back(error_msg);
775 } else {
776 dex_files->push_back(dex_file);
777 }
778 }
779
780 // When we generated the file, we expect success, or something is terribly wrong.
781 CHECK_EQ(false, generated && !success)
782 << "dex_location=" << next_name << " oat_location=" << oat_file->GetLocation().c_str()
Calin Juravleca345932014-09-02 15:53:55 +0100783 << std::hex << " dex_location_checksum=" << next_location_checksum
Andreas Gampe833a4852014-05-21 18:46:59 -0700784 << " OatDexFile::GetLocationChecksum()=" << oat_dex_file->GetDexFileLocationChecksum();
785 }
786
787 if (dex_files->size() == old_size) {
788 success = false; // We did not even find classes.dex
789 }
790
791 if (success) {
792 return true;
793 } else {
794 // Free all the dex files we have loaded.
795 auto it = dex_files->begin() + old_size;
796 auto it_end = dex_files->end();
797 for (; it != it_end; it++) {
798 delete *it;
799 }
800 dex_files->erase(dex_files->begin() + old_size, it_end);
801
802 return false;
803 }
804}
805
806// Multidex files make it possible that some, but not all, dex files can be broken/outdated. This
807// complicates the loading process, as we should not use an iterative loading process, because that
808// would register the oat file and dex files that come before the broken one. Instead, check all
809// multidex ahead of time.
810bool ClassLinker::OpenDexFilesFromOat(const char* dex_location, const char* oat_location,
811 std::vector<std::string>* error_msgs,
812 std::vector<const DexFile*>* dex_files) {
813 // 1) Check whether we have an open oat file.
814 // This requires a dex checksum, use the "primary" one.
815 uint32_t dex_location_checksum;
816 uint32_t* dex_location_checksum_pointer = &dex_location_checksum;
817 bool have_checksum = true;
818 std::string checksum_error_msg;
819 if (!DexFile::GetChecksum(dex_location, dex_location_checksum_pointer, &checksum_error_msg)) {
Calin Juravleca345932014-09-02 15:53:55 +0100820 // This happens for pre-opted files since the corresponding dex files are no longer on disk.
Andreas Gampe833a4852014-05-21 18:46:59 -0700821 dex_location_checksum_pointer = nullptr;
822 have_checksum = false;
823 }
824
825 bool needs_registering = false;
826
827 std::unique_ptr<const OatFile> open_oat_file(FindOpenedOatFile(oat_location, dex_location,
828 dex_location_checksum_pointer));
829
830 // 2) If we do not have an open one, maybe there's one on disk already.
831
832 // In case the oat file is not open, we play a locking game here so
833 // that if two different processes race to load and register or generate
834 // (or worse, one tries to open a partial generated file) we will be okay.
835 // This is actually common with apps that use DexClassLoader to work
836 // around the dex method reference limit and that have a background
837 // service running in a separate process.
838 ScopedFlock scoped_flock;
839
840 if (open_oat_file.get() == nullptr) {
841 if (oat_location != nullptr) {
842 // Can only do this if we have a checksum, else error.
843 if (!have_checksum) {
844 error_msgs->push_back(checksum_error_msg);
845 return false;
846 }
847
848 std::string error_msg;
849
850 // We are loading or creating one in the future. Time to set up the file lock.
851 if (!scoped_flock.Init(oat_location, &error_msg)) {
852 error_msgs->push_back(error_msg);
853 return false;
854 }
855
Alex Lighta59dd802014-07-02 16:28:08 -0700856 // TODO Caller specifically asks for this oat_location. We should honor it. Probably?
Andreas Gampe833a4852014-05-21 18:46:59 -0700857 open_oat_file.reset(FindOatFileInOatLocationForDexFile(dex_location, dex_location_checksum,
858 oat_location, &error_msg));
859
860 if (open_oat_file.get() == nullptr) {
861 std::string compound_msg = StringPrintf("Failed to find dex file '%s' in oat location '%s': %s",
862 dex_location, oat_location, error_msg.c_str());
863 VLOG(class_linker) << compound_msg;
864 error_msgs->push_back(compound_msg);
865 }
866 } else {
867 // TODO: What to lock here?
Calin Juravlec54aea72014-07-16 14:45:03 +0100868 bool obsolete_file_cleanup_failed;
Andreas Gampe833a4852014-05-21 18:46:59 -0700869 open_oat_file.reset(FindOatFileContainingDexFileFromDexLocation(dex_location,
870 dex_location_checksum_pointer,
Calin Juravlec54aea72014-07-16 14:45:03 +0100871 kRuntimeISA, error_msgs,
872 &obsolete_file_cleanup_failed));
873 // There's no point in going forward and eventually try to regenerate the
874 // file if we couldn't remove the obsolete one. Mostly likely we will fail
875 // with the same error when trying to write the new file.
Calin Juravlec54aea72014-07-16 14:45:03 +0100876 // TODO: should we maybe do this only when we get permission issues? (i.e. EACCESS).
877 if (obsolete_file_cleanup_failed) {
878 return false;
879 }
Andreas Gampe833a4852014-05-21 18:46:59 -0700880 }
881 needs_registering = true;
882 }
883
884 // 3) If we have an oat file, check all contained multidex files for our dex_location.
885 // Note: LoadMultiDexFilesFromOatFile will check for nullptr in the first argument.
Calin Juravleca345932014-09-02 15:53:55 +0100886 bool success = LoadMultiDexFilesFromOatFile(open_oat_file.get(), dex_location,
887 dex_location_checksum_pointer,
888 false, error_msgs, dex_files);
Andreas Gampe833a4852014-05-21 18:46:59 -0700889 if (success) {
890 const OatFile* oat_file = open_oat_file.release(); // Avoid deleting it.
891 if (needs_registering) {
892 // We opened the oat file, so we must register it.
893 RegisterOatFile(oat_file);
894 }
Alex Light0a112bb2014-08-14 14:16:26 -0700895 // If the file isn't executable we failed patchoat but did manage to get the dex files.
896 return oat_file->IsExecutable();
Andreas Gampe833a4852014-05-21 18:46:59 -0700897 } else {
898 if (needs_registering) {
899 // We opened it, delete it.
900 open_oat_file.reset();
901 } else {
902 open_oat_file.release(); // Do not delete open oat files.
903 }
904 }
905
906 // 4) If it's not the case (either no oat file or mismatches), regenerate and load.
907
908 // Need a checksum, fail else.
909 if (!have_checksum) {
910 error_msgs->push_back(checksum_error_msg);
911 return false;
912 }
913
914 // Look in cache location if no oat_location is given.
915 std::string cache_location;
916 if (oat_location == nullptr) {
917 // Use the dalvik cache.
918 const std::string dalvik_cache(GetDalvikCacheOrDie(GetInstructionSetString(kRuntimeISA)));
919 cache_location = GetDalvikCacheFilenameOrDie(dex_location, dalvik_cache.c_str());
920 oat_location = cache_location.c_str();
921 }
922
Alex Light507e6182014-08-19 14:23:13 -0700923 bool has_flock = true;
Andreas Gampe833a4852014-05-21 18:46:59 -0700924 // Definitely need to lock now.
925 if (!scoped_flock.HasFile()) {
926 std::string error_msg;
927 if (!scoped_flock.Init(oat_location, &error_msg)) {
928 error_msgs->push_back(error_msg);
Alex Light507e6182014-08-19 14:23:13 -0700929 has_flock = false;
Andreas Gampe833a4852014-05-21 18:46:59 -0700930 }
931 }
932
Alex Light507e6182014-08-19 14:23:13 -0700933 if (Runtime::Current()->IsDex2OatEnabled() && has_flock && scoped_flock.HasFile()) {
Nicolas Geoffray9c290012014-07-22 10:48:00 +0100934 // Create the oat file.
935 open_oat_file.reset(CreateOatFileForDexLocation(dex_location, scoped_flock.GetFile()->Fd(),
936 oat_location, error_msgs));
937 }
Andreas Gampe833a4852014-05-21 18:46:59 -0700938
939 // Failed, bail.
940 if (open_oat_file.get() == nullptr) {
Nicolas Geoffray9c290012014-07-22 10:48:00 +0100941 std::string error_msg;
942 // dex2oat was disabled or crashed. Add the dex file in the list of dex_files to make progress.
943 DexFile::Open(dex_location, dex_location, &error_msg, dex_files);
944 error_msgs->push_back(error_msg);
Andreas Gampe833a4852014-05-21 18:46:59 -0700945 return false;
946 }
947
948 // Try to load again, but stronger checks.
Calin Juravleca345932014-09-02 15:53:55 +0100949 success = LoadMultiDexFilesFromOatFile(open_oat_file.get(), dex_location, dex_location_checksum_pointer,
950 true, error_msgs, dex_files);
Andreas Gampe833a4852014-05-21 18:46:59 -0700951 if (success) {
952 RegisterOatFile(open_oat_file.release());
953 return true;
954 } else {
955 return false;
956 }
957}
958
959const OatFile* ClassLinker::FindOatFileInOatLocationForDexFile(const char* dex_location,
960 uint32_t dex_location_checksum,
961 const char* oat_location,
962 std::string* error_msg) {
Ian Rogers700a4022014-05-19 16:49:03 -0700963 std::unique_ptr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700964 !Runtime::Current()->IsCompiler(),
965 error_msg));
966 if (oat_file.get() == nullptr) {
967 *error_msg = StringPrintf("Failed to find existing oat file at %s: %s", oat_location,
968 error_msg->c_str());
969 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800970 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700971 Runtime* runtime = Runtime::Current();
Alex Light496cd332014-08-29 10:28:25 -0700972 const gc::space::ImageSpace* image_space = runtime->GetHeap()->GetImageSpace();
973 if (image_space != nullptr) {
974 const ImageHeader& image_header = image_space->GetImageHeader();
975 uint32_t expected_image_oat_checksum = image_header.GetOatChecksum();
976 uint32_t actual_image_oat_checksum = oat_file->GetOatHeader().GetImageFileLocationOatChecksum();
977 if (expected_image_oat_checksum != actual_image_oat_checksum) {
978 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat checksum of "
979 "0x%x, found 0x%x", oat_location, expected_image_oat_checksum,
980 actual_image_oat_checksum);
981 return nullptr;
982 }
983
984 uintptr_t expected_image_oat_offset = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
985 uint32_t actual_image_oat_offset = oat_file->GetOatHeader().GetImageFileLocationOatDataBegin();
986 if (expected_image_oat_offset != actual_image_oat_offset) {
987 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected image oat offset %"
988 PRIuPTR ", found %ud", oat_location, expected_image_oat_offset,
989 actual_image_oat_offset);
990 return nullptr;
991 }
992 int32_t expected_patch_delta = image_header.GetPatchDelta();
993 int32_t actual_patch_delta = oat_file->GetOatHeader().GetImagePatchDelta();
994 if (expected_patch_delta != actual_patch_delta) {
995 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected patch delta %d, "
996 " found %d", oat_location, expected_patch_delta, actual_patch_delta);
997 return nullptr;
998 }
Brian Carlstrom28db0122012-10-18 16:20:41 -0700999 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001000
Vladimir Marko64e7ac02014-05-01 15:43:47 +01001001 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
1002 &dex_location_checksum);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001003 if (oat_dex_file == nullptr) {
1004 *error_msg = StringPrintf("Failed to find oat file at '%s' containing '%s'", oat_location,
1005 dex_location);
1006 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001007 }
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001008 uint32_t expected_dex_checksum = dex_location_checksum;
1009 uint32_t actual_dex_checksum = oat_dex_file->GetDexFileLocationChecksum();
1010 if (expected_dex_checksum != actual_dex_checksum) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001011 *error_msg = StringPrintf("Failed to find oat file at '%s' with expected dex checksum of 0x%x, "
1012 "found 0x%x", oat_location, expected_dex_checksum,
1013 actual_dex_checksum);
1014 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001015 }
Andreas Gampe833a4852014-05-21 18:46:59 -07001016 std::unique_ptr<const DexFile> dex_file(oat_dex_file->OpenDexFile(error_msg));
1017 if (dex_file.get() != nullptr) {
1018 return oat_file.release();
1019 } else {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001020 return nullptr;
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001021 }
Andreas Gampe833a4852014-05-21 18:46:59 -07001022}
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001023
Andreas Gampe833a4852014-05-21 18:46:59 -07001024const OatFile* ClassLinker::CreateOatFileForDexLocation(const char* dex_location,
1025 int fd, const char* oat_location,
1026 std::vector<std::string>* error_msgs) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001027 // Generate the output oat file for the dex file
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001028 VLOG(class_linker) << "Generating oat file " << oat_location << " for " << dex_location;
Andreas Gampe833a4852014-05-21 18:46:59 -07001029 std::string error_msg;
1030 if (!GenerateOatFile(dex_location, fd, oat_location, &error_msg)) {
Andreas Gampe329d1882014-04-08 10:32:19 -07001031 CHECK(!error_msg.empty());
1032 error_msgs->push_back(error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001033 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001034 }
Ian Rogers700a4022014-05-19 16:49:03 -07001035 std::unique_ptr<OatFile> oat_file(OatFile::Open(oat_location, oat_location, NULL,
Vladimir Marko64e7ac02014-05-01 15:43:47 +01001036 !Runtime::Current()->IsCompiler(),
1037 &error_msg));
1038 if (oat_file.get() == nullptr) {
Andreas Gampe833a4852014-05-21 18:46:59 -07001039 std::string compound_msg = StringPrintf("\nFailed to open generated oat file '%s': %s",
1040 oat_location, error_msg.c_str());
Andreas Gampe329d1882014-04-08 10:32:19 -07001041 error_msgs->push_back(compound_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001042 return nullptr;
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001043 }
Andreas Gampe833a4852014-05-21 18:46:59 -07001044
1045 return oat_file.release();
Brian Carlstrom5b332c82012-02-01 15:02:31 -08001046}
1047
Alex Light345c4b12014-07-18 14:57:04 -07001048bool ClassLinker::VerifyOatImageChecksum(const OatFile* oat_file,
1049 const InstructionSet instruction_set) {
1050 Runtime* runtime = Runtime::Current();
1051 const gc::space::ImageSpace* image_space = runtime->GetHeap()->GetImageSpace();
Alex Light507e6182014-08-19 14:23:13 -07001052 if (image_space == nullptr) {
1053 return false;
1054 }
Alex Light345c4b12014-07-18 14:57:04 -07001055 uint32_t image_oat_checksum = 0;
1056 if (instruction_set == kRuntimeISA) {
1057 const ImageHeader& image_header = image_space->GetImageHeader();
1058 image_oat_checksum = image_header.GetOatChecksum();
1059 } else {
1060 std::unique_ptr<ImageHeader> image_header(gc::space::ImageSpace::ReadImageHeaderOrDie(
1061 image_space->GetImageLocation().c_str(), instruction_set));
1062 image_oat_checksum = image_header->GetOatChecksum();
1063 }
1064 return oat_file->GetOatHeader().GetImageFileLocationOatChecksum() == image_oat_checksum;
1065}
1066
1067bool ClassLinker::VerifyOatChecksums(const OatFile* oat_file,
1068 const InstructionSet instruction_set,
1069 std::string* error_msg) {
Brian Carlstromafe25512012-06-27 17:02:58 -07001070 Runtime* runtime = Runtime::Current();
Narayan Kamath52f84882014-05-02 10:10:39 +01001071 const gc::space::ImageSpace* image_space = runtime->GetHeap()->GetImageSpace();
Alex Light507e6182014-08-19 14:23:13 -07001072 if (image_space == nullptr) {
1073 *error_msg = "No image space for verification against";
1074 return false;
1075 }
Narayan Kamath52f84882014-05-02 10:10:39 +01001076
1077 // If the requested instruction set is the same as the current runtime,
1078 // we can use the checksums directly. If it isn't, we'll have to read the
1079 // image header from the image for the right instruction set.
1080 uint32_t image_oat_checksum = 0;
1081 uintptr_t image_oat_data_begin = 0;
Alex Lighta59dd802014-07-02 16:28:08 -07001082 int32_t image_patch_delta = 0;
1083 if (instruction_set == Runtime::Current()->GetInstructionSet()) {
Narayan Kamath52f84882014-05-02 10:10:39 +01001084 const ImageHeader& image_header = image_space->GetImageHeader();
1085 image_oat_checksum = image_header.GetOatChecksum();
1086 image_oat_data_begin = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
Alex Lighta59dd802014-07-02 16:28:08 -07001087 image_patch_delta = image_header.GetPatchDelta();
Narayan Kamath52f84882014-05-02 10:10:39 +01001088 } else {
Ian Rogers700a4022014-05-19 16:49:03 -07001089 std::unique_ptr<ImageHeader> image_header(gc::space::ImageSpace::ReadImageHeaderOrDie(
Narayan Kamath52f84882014-05-02 10:10:39 +01001090 image_space->GetImageLocation().c_str(), instruction_set));
1091 image_oat_checksum = image_header->GetOatChecksum();
1092 image_oat_data_begin = reinterpret_cast<uintptr_t>(image_header->GetOatDataBegin());
Alex Lighta59dd802014-07-02 16:28:08 -07001093 image_patch_delta = image_header->GetPatchDelta();
Narayan Kamath52f84882014-05-02 10:10:39 +01001094 }
1095 const OatHeader& oat_header = oat_file->GetOatHeader();
Alex Light345c4b12014-07-18 14:57:04 -07001096 bool ret = ((oat_header.GetImageFileLocationOatChecksum() == image_oat_checksum)
1097 && (oat_header.GetImagePatchDelta() == image_patch_delta)
1098 && (oat_header.GetImageFileLocationOatDataBegin() == image_oat_data_begin));
1099 if (!ret) {
1100 *error_msg = StringPrintf("oat file '%s' mismatch (0x%x, %d, %d) with (0x%x, %" PRIdPTR ", %d)",
1101 oat_file->GetLocation().c_str(),
1102 oat_file->GetOatHeader().GetImageFileLocationOatChecksum(),
1103 oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(),
1104 oat_file->GetOatHeader().GetImagePatchDelta(),
1105 image_oat_checksum, image_oat_data_begin, image_patch_delta);
1106 }
1107 return ret;
1108}
1109
1110bool ClassLinker::VerifyOatAndDexFileChecksums(const OatFile* oat_file,
1111 const char* dex_location,
1112 uint32_t dex_location_checksum,
1113 const InstructionSet instruction_set,
1114 std::string* error_msg) {
1115 if (!VerifyOatChecksums(oat_file, instruction_set, error_msg)) {
1116 return false;
1117 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -07001118
Brian Carlstromf3632832014-05-20 15:36:53 -07001119 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location,
1120 &dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -07001121 if (oat_dex_file == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001122 *error_msg = StringPrintf("oat file '%s' does not contain contents for '%s' with checksum 0x%x",
1123 oat_file->GetLocation().c_str(), dex_location, dex_location_checksum);
Brian Carlstromafe25512012-06-27 17:02:58 -07001124 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
1125 for (size_t i = 0; i < oat_dex_files.size(); i++) {
1126 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001127 *error_msg += StringPrintf("\noat file '%s' contains contents for '%s'",
1128 oat_file->GetLocation().c_str(),
1129 oat_dex_file->GetDexFileLocation().c_str());
Brian Carlstromafe25512012-06-27 17:02:58 -07001130 }
1131 return false;
1132 }
Brian Carlstrom46b8a622012-06-19 23:13:22 -07001133
Alex Light345c4b12014-07-18 14:57:04 -07001134 if (dex_location_checksum != oat_dex_file->GetDexFileLocationChecksum()) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001135 *error_msg = StringPrintf("oat file '%s' mismatch (0x%x) with '%s' (0x%x)",
1136 oat_file->GetLocation().c_str(),
1137 oat_dex_file->GetDexFileLocationChecksum(),
1138 dex_location, dex_location_checksum);
Alex Light345c4b12014-07-18 14:57:04 -07001139 return false;
Brian Carlstromafe25512012-06-27 17:02:58 -07001140 }
Alex Light345c4b12014-07-18 14:57:04 -07001141 return true;
Brian Carlstromafe25512012-06-27 17:02:58 -07001142}
1143
Alex Lighta59dd802014-07-02 16:28:08 -07001144bool ClassLinker::VerifyOatWithDexFile(const OatFile* oat_file,
1145 const char* dex_location,
Calin Juravleca345932014-09-02 15:53:55 +01001146 const uint32_t* dex_location_checksum,
Alex Lighta59dd802014-07-02 16:28:08 -07001147 std::string* error_msg) {
1148 CHECK(oat_file != nullptr);
1149 CHECK(dex_location != nullptr);
Andreas Gampe833a4852014-05-21 18:46:59 -07001150 std::unique_ptr<const DexFile> dex_file;
Calin Juravleca345932014-09-02 15:53:55 +01001151 if (dex_location_checksum == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001152 // If no classes.dex found in dex_location, it has been stripped or is corrupt, assume oat is
1153 // up-to-date. This is the common case in user builds for jar's and apk's in the /system
1154 // directory.
Vladimir Marko64e7ac02014-05-01 15:43:47 +01001155 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location, NULL);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001156 if (oat_dex_file == nullptr) {
1157 *error_msg = StringPrintf("Dex checksum mismatch for location '%s' and failed to find oat "
Alex Lighta59dd802014-07-02 16:28:08 -07001158 "dex file '%s': %s", oat_file->GetLocation().c_str(), dex_location,
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001159 error_msg->c_str());
Alex Lighta59dd802014-07-02 16:28:08 -07001160 return false;
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001161 }
Andreas Gampe833a4852014-05-21 18:46:59 -07001162 dex_file.reset(oat_dex_file->OpenDexFile(error_msg));
Vladimir Marko64e7ac02014-05-01 15:43:47 +01001163 } else {
Calin Juravleca345932014-09-02 15:53:55 +01001164 bool verified = VerifyOatAndDexFileChecksums(oat_file, dex_location, *dex_location_checksum,
Alex Light345c4b12014-07-18 14:57:04 -07001165 kRuntimeISA, error_msg);
Vladimir Marko64e7ac02014-05-01 15:43:47 +01001166 if (!verified) {
Alex Lighta59dd802014-07-02 16:28:08 -07001167 return false;
Vladimir Marko64e7ac02014-05-01 15:43:47 +01001168 }
Andreas Gampe833a4852014-05-21 18:46:59 -07001169 dex_file.reset(oat_file->GetOatDexFile(dex_location,
Calin Juravleca345932014-09-02 15:53:55 +01001170 dex_location_checksum)->OpenDexFile(error_msg));
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001171 }
Alex Lighta59dd802014-07-02 16:28:08 -07001172 return dex_file.get() != nullptr;
Brian Carlstrom46b8a622012-06-19 23:13:22 -07001173}
1174
Andreas Gampe833a4852014-05-21 18:46:59 -07001175const OatFile* ClassLinker::FindOatFileContainingDexFileFromDexLocation(
Brian Carlstromf3632832014-05-20 15:36:53 -07001176 const char* dex_location,
1177 const uint32_t* const dex_location_checksum,
1178 InstructionSet isa,
Calin Juravlec54aea72014-07-16 14:45:03 +01001179 std::vector<std::string>* error_msgs,
1180 bool* obsolete_file_cleanup_failed) {
1181 *obsolete_file_cleanup_failed = false;
Alex Lighta59dd802014-07-02 16:28:08 -07001182 bool already_opened = false;
1183 std::string dex_location_str(dex_location);
1184 std::unique_ptr<const OatFile> oat_file(OpenOatFileFromDexLocation(dex_location_str, isa,
1185 &already_opened,
1186 obsolete_file_cleanup_failed,
1187 error_msgs));
Andreas Gampe329d1882014-04-08 10:32:19 -07001188 std::string error_msg;
Alex Lighta59dd802014-07-02 16:28:08 -07001189 if (oat_file.get() == nullptr) {
1190 error_msgs->push_back(StringPrintf("Failed to open oat file from dex location '%s'",
1191 dex_location));
1192 return nullptr;
Alex Light0a112bb2014-08-14 14:16:26 -07001193 } else if (oat_file->IsExecutable() &&
Calin Juravleca345932014-09-02 15:53:55 +01001194 !VerifyOatWithDexFile(oat_file.get(), dex_location,
1195 dex_location_checksum, &error_msg)) {
Alex Lighta59dd802014-07-02 16:28:08 -07001196 error_msgs->push_back(StringPrintf("Failed to verify oat file '%s' found for dex location "
1197 "'%s': %s", oat_file->GetLocation().c_str(), dex_location,
Andreas Gampe329d1882014-04-08 10:32:19 -07001198 error_msg.c_str()));
Brian Carlstrom08cbf662013-12-10 16:52:57 -08001199 return nullptr;
Alex Light0a112bb2014-08-14 14:16:26 -07001200 } else if (!oat_file->IsExecutable() &&
Alex Lightfb777592014-08-22 17:49:35 -07001201 Runtime::Current()->GetHeap()->HasImageSpace() &&
Alex Light0a112bb2014-08-14 14:16:26 -07001202 !VerifyOatImageChecksum(oat_file.get(), isa)) {
1203 error_msgs->push_back(StringPrintf("Failed to verify non-executable oat file '%s' found for "
1204 "dex location '%s'. Image checksum incorrect.",
1205 oat_file->GetLocation().c_str(), dex_location));
1206 return nullptr;
Alex Lighta59dd802014-07-02 16:28:08 -07001207 } else {
1208 return oat_file.release();
Brian Carlstrom08cbf662013-12-10 16:52:57 -08001209 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001210}
1211
Brian Carlstromae826982011-11-09 01:33:42 -08001212const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001213 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001214 for (size_t i = 0; i < oat_files_.size(); i++) {
1215 const OatFile* oat_file = oat_files_[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001216 DCHECK(oat_file != nullptr);
Brian Carlstromae826982011-11-09 01:33:42 -08001217 if (oat_file->GetLocation() == oat_location) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001218 return oat_file;
1219 }
1220 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001221 return nullptr;
Brian Carlstromfad71432011-10-16 20:25:10 -07001222}
Brian Carlstromaded5f72011-10-07 17:15:04 -07001223
Alex Lighta59dd802014-07-02 16:28:08 -07001224const OatFile* ClassLinker::OpenOatFileFromDexLocation(const std::string& dex_location,
1225 InstructionSet isa,
1226 bool *already_opened,
1227 bool *obsolete_file_cleanup_failed,
1228 std::vector<std::string>* error_msgs) {
1229 // Find out if we've already opened the file
1230 const OatFile* ret = nullptr;
1231 std::string odex_filename(DexFilenameToOdexFilename(dex_location, isa));
1232 ret = FindOpenedOatFileFromOatLocation(odex_filename);
1233 if (ret != nullptr) {
1234 *already_opened = true;
1235 return ret;
1236 }
1237
1238 std::string dalvik_cache;
1239 bool have_android_data = false;
1240 bool have_dalvik_cache = false;
1241 GetDalvikCache(GetInstructionSetString(kRuntimeISA), false, &dalvik_cache,
1242 &have_android_data, &have_dalvik_cache);
1243 std::string cache_filename;
1244 if (have_dalvik_cache) {
1245 cache_filename = GetDalvikCacheFilenameOrDie(dex_location.c_str(), dalvik_cache.c_str());
1246 ret = FindOpenedOatFileFromOatLocation(cache_filename);
1247 if (ret != nullptr) {
1248 *already_opened = true;
1249 return ret;
1250 }
1251 } else {
1252 // If we need to relocate we should just place odex back where it started.
1253 cache_filename = odex_filename;
1254 }
1255
1256 ret = nullptr;
1257
1258 // We know that neither the odex nor the cache'd version is already in use, if it even exists.
1259 //
1260 // Now we do the following:
1261 // 1) Try and open the odex version
1262 // 2) If present, checksum-verified & relocated correctly return it
1263 // 3) Close the odex version to free up its address space.
1264 // 4) Try and open the cache version
1265 // 5) If present, checksum-verified & relocated correctly return it
1266 // 6) Close the cache version to free up its address space.
1267 // 7) If we should relocate:
1268 // a) If we have opened and checksum-verified the odex version relocate it to
1269 // 'cache_filename' and return it
1270 // b) If we have opened and checksum-verified the cache version relocate it in place and return
1271 // it. This should not happen often (I think only the run-test's will hit this case).
1272 // 8) If the cache-version was present we should delete it since it must be obsolete if we get to
1273 // this point.
1274 // 9) Return nullptr
1275
1276 *already_opened = false;
1277 const Runtime* runtime = Runtime::Current();
1278 CHECK(runtime != nullptr);
1279 bool executable = !runtime->IsCompiler();
1280
1281 std::string odex_error_msg;
1282 bool should_patch_system = false;
1283 bool odex_checksum_verified = false;
Alex Lightfb777592014-08-22 17:49:35 -07001284 bool have_system_odex = false;
Alex Lighta59dd802014-07-02 16:28:08 -07001285 {
1286 // There is a high probability that these both these oat files map similar/the same address
1287 // spaces so we must scope them like this so they each gets its turn.
1288 std::unique_ptr<OatFile> odex_oat_file(OatFile::Open(odex_filename, odex_filename, NULL,
1289 executable, &odex_error_msg));
1290 if (odex_oat_file.get() != nullptr && CheckOatFile(odex_oat_file.get(), isa,
1291 &odex_checksum_verified,
1292 &odex_error_msg)) {
1293 error_msgs->push_back(odex_error_msg);
1294 return odex_oat_file.release();
Alex Lightfb777592014-08-22 17:49:35 -07001295 } else {
1296 if (odex_checksum_verified) {
1297 // We can just relocate
1298 should_patch_system = true;
1299 odex_error_msg = "Image Patches are incorrect";
1300 }
1301 if (odex_oat_file.get() != nullptr) {
1302 have_system_odex = true;
1303 }
Alex Lighta59dd802014-07-02 16:28:08 -07001304 }
1305 }
1306
Alex Lighta59dd802014-07-02 16:28:08 -07001307 std::string cache_error_msg;
1308 bool should_patch_cache = false;
1309 bool cache_checksum_verified = false;
1310 if (have_dalvik_cache) {
1311 std::unique_ptr<OatFile> cache_oat_file(OatFile::Open(cache_filename, cache_filename, NULL,
1312 executable, &cache_error_msg));
1313 if (cache_oat_file.get() != nullptr && CheckOatFile(cache_oat_file.get(), isa,
1314 &cache_checksum_verified,
1315 &cache_error_msg)) {
1316 error_msgs->push_back(cache_error_msg);
1317 return cache_oat_file.release();
1318 } else if (cache_checksum_verified) {
1319 // We can just relocate
1320 should_patch_cache = true;
1321 cache_error_msg = "Image Patches are incorrect";
1322 }
1323 } else if (have_android_data) {
1324 // dalvik_cache does not exist but android data does. This means we should be able to create
1325 // it, so we should try.
1326 GetDalvikCacheOrDie(GetInstructionSetString(kRuntimeISA), true);
1327 }
1328
1329 ret = nullptr;
1330 std::string error_msg;
1331 if (runtime->CanRelocate()) {
1332 // Run relocation
Alex Light507e6182014-08-19 14:23:13 -07001333 gc::space::ImageSpace* space = Runtime::Current()->GetHeap()->GetImageSpace();
1334 if (space != nullptr) {
1335 const std::string& image_location = space->GetImageLocation();
1336 if (odex_checksum_verified && should_patch_system) {
1337 ret = PatchAndRetrieveOat(odex_filename, cache_filename, image_location, isa, &error_msg);
1338 } else if (cache_checksum_verified && should_patch_cache) {
1339 CHECK(have_dalvik_cache);
1340 ret = PatchAndRetrieveOat(cache_filename, cache_filename, image_location, isa, &error_msg);
1341 }
Alex Lightfb777592014-08-22 17:49:35 -07001342 } else if (have_system_odex) {
1343 ret = GetInterpretedOnlyOat(odex_filename, isa, &error_msg);
Alex Lighta59dd802014-07-02 16:28:08 -07001344 }
1345 }
1346 if (ret == nullptr && have_dalvik_cache && OS::FileExists(cache_filename.c_str())) {
1347 // implicitly: were able to fine where the cached version is but we were unable to use it,
1348 // either as a destination for relocation or to open a file. We should delete it if it is
1349 // there.
1350 if (TEMP_FAILURE_RETRY(unlink(cache_filename.c_str())) != 0) {
1351 std::string rm_error_msg = StringPrintf("Failed to remove obsolete file from %s when "
1352 "searching for dex file %s: %s",
1353 cache_filename.c_str(), dex_location.c_str(),
1354 strerror(errno));
1355 error_msgs->push_back(rm_error_msg);
1356 VLOG(class_linker) << rm_error_msg;
1357 // Let the caller know that we couldn't remove the obsolete file.
1358 // This is a good indication that further writes may fail as well.
1359 *obsolete_file_cleanup_failed = true;
1360 }
1361 }
1362 if (ret == nullptr) {
1363 VLOG(class_linker) << error_msg;
1364 error_msgs->push_back(error_msg);
1365 std::string relocation_msg;
1366 if (runtime->CanRelocate()) {
1367 relocation_msg = StringPrintf(" and relocation failed");
1368 }
1369 if (have_dalvik_cache && cache_checksum_verified) {
1370 error_msg = StringPrintf("Failed to open oat file from %s (error %s) or %s "
1371 "(error %s)%s.", odex_filename.c_str(), odex_error_msg.c_str(),
1372 cache_filename.c_str(), cache_error_msg.c_str(),
1373 relocation_msg.c_str());
1374 } else {
1375 error_msg = StringPrintf("Failed to open oat file from %s (error %s) (no "
1376 "dalvik_cache availible)%s.", odex_filename.c_str(),
1377 odex_error_msg.c_str(), relocation_msg.c_str());
1378 }
1379 VLOG(class_linker) << error_msg;
1380 error_msgs->push_back(error_msg);
1381 }
1382 return ret;
1383}
1384
Alex Light0a112bb2014-08-14 14:16:26 -07001385const OatFile* ClassLinker::GetInterpretedOnlyOat(const std::string& oat_path,
1386 InstructionSet isa,
1387 std::string* error_msg) {
1388 // We open it non-executable
1389 std::unique_ptr<OatFile> output(OatFile::Open(oat_path, oat_path, NULL, false, error_msg));
1390 if (output.get() == nullptr) {
1391 return nullptr;
1392 }
Alex Lightfb777592014-08-22 17:49:35 -07001393 if (!Runtime::Current()->GetHeap()->HasImageSpace() ||
1394 VerifyOatImageChecksum(output.get(), isa)) {
Alex Light0a112bb2014-08-14 14:16:26 -07001395 return output.release();
1396 } else {
1397 *error_msg = StringPrintf("Could not use oat file '%s', image checksum failed to verify.",
1398 oat_path.c_str());
1399 return nullptr;
1400 }
1401}
1402
Alex Lighta59dd802014-07-02 16:28:08 -07001403const OatFile* ClassLinker::PatchAndRetrieveOat(const std::string& input_oat,
1404 const std::string& output_oat,
1405 const std::string& image_location,
1406 InstructionSet isa,
1407 std::string* error_msg) {
Alex Light507e6182014-08-19 14:23:13 -07001408 if (!Runtime::Current()->GetHeap()->HasImageSpace()) {
1409 // We don't have an image space so there is no point in trying to patchoat.
1410 LOG(WARNING) << "Patching of oat file '" << input_oat << "' not attempted because we are "
1411 << "running without an image. Attempting to use oat file for interpretation.";
1412 return GetInterpretedOnlyOat(input_oat, isa, error_msg);
1413 }
Alex Light0a112bb2014-08-14 14:16:26 -07001414 if (!Runtime::Current()->IsDex2OatEnabled()) {
1415 // We don't have dex2oat so we can assume we don't have patchoat either. We should just use the
1416 // input_oat but make sure we only do interpretation on it's dex files.
1417 LOG(WARNING) << "Patching of oat file '" << input_oat << "' not attempted due to dex2oat being "
1418 << "disabled. Attempting to use oat file for interpretation";
1419 return GetInterpretedOnlyOat(input_oat, isa, error_msg);
1420 }
Alex Lighta59dd802014-07-02 16:28:08 -07001421 Locks::mutator_lock_->AssertNotHeld(Thread::Current()); // Avoid starving GC.
1422 std::string patchoat(Runtime::Current()->GetPatchoatExecutable());
1423
1424 std::string isa_arg("--instruction-set=");
1425 isa_arg += GetInstructionSetString(isa);
1426 std::string input_oat_filename_arg("--input-oat-file=");
1427 input_oat_filename_arg += input_oat;
1428 std::string output_oat_filename_arg("--output-oat-file=");
1429 output_oat_filename_arg += output_oat;
1430 std::string patched_image_arg("--patched-image-location=");
1431 patched_image_arg += image_location;
1432
1433 std::vector<std::string> argv;
1434 argv.push_back(patchoat);
1435 argv.push_back(isa_arg);
1436 argv.push_back(input_oat_filename_arg);
1437 argv.push_back(output_oat_filename_arg);
1438 argv.push_back(patched_image_arg);
1439
1440 std::string command_line(Join(argv, ' '));
1441 LOG(INFO) << "Relocate Oat File: " << command_line;
1442 bool success = Exec(argv, error_msg);
1443 if (success) {
1444 std::unique_ptr<OatFile> output(OatFile::Open(output_oat, output_oat, NULL,
1445 !Runtime::Current()->IsCompiler(), error_msg));
1446 bool checksum_verified = false;
1447 if (output.get() != nullptr && CheckOatFile(output.get(), isa, &checksum_verified, error_msg)) {
1448 return output.release();
1449 } else if (output.get() != nullptr) {
1450 *error_msg = StringPrintf("Patching of oat file '%s' succeeded "
1451 "but output file '%s' failed verifcation: %s",
1452 input_oat.c_str(), output_oat.c_str(), error_msg->c_str());
1453 } else {
1454 *error_msg = StringPrintf("Patching of oat file '%s' succeeded "
1455 "but was unable to open output file '%s': %s",
1456 input_oat.c_str(), output_oat.c_str(), error_msg->c_str());
1457 }
Alex Light0a112bb2014-08-14 14:16:26 -07001458 } else if (!Runtime::Current()->IsCompiler()) {
1459 // patchoat failed which means we probably don't have enough room to place the output oat file,
1460 // instead of failing we should just run the interpreter from the dex files in the input oat.
1461 LOG(WARNING) << "Patching of oat file '" << input_oat << "' failed. Attempting to use oat file "
1462 << "for interpretation. patchoat failure was: " << *error_msg;
1463 return GetInterpretedOnlyOat(input_oat, isa, error_msg);
Alex Lighta59dd802014-07-02 16:28:08 -07001464 } else {
1465 *error_msg = StringPrintf("Patching of oat file '%s to '%s' "
1466 "failed: %s", input_oat.c_str(), output_oat.c_str(),
1467 error_msg->c_str());
1468 }
1469 return nullptr;
1470}
1471
1472int32_t ClassLinker::GetRequiredDelta(const OatFile* oat_file, InstructionSet isa) {
1473 Runtime* runtime = Runtime::Current();
1474 int32_t real_patch_delta;
1475 const gc::space::ImageSpace* image_space = runtime->GetHeap()->GetImageSpace();
Alex Light507e6182014-08-19 14:23:13 -07001476 CHECK(image_space != nullptr);
Alex Lighta59dd802014-07-02 16:28:08 -07001477 if (isa == Runtime::Current()->GetInstructionSet()) {
1478 const ImageHeader& image_header = image_space->GetImageHeader();
1479 real_patch_delta = image_header.GetPatchDelta();
1480 } else {
1481 std::unique_ptr<ImageHeader> image_header(gc::space::ImageSpace::ReadImageHeaderOrDie(
1482 image_space->GetImageLocation().c_str(), isa));
1483 real_patch_delta = image_header->GetPatchDelta();
1484 }
1485 const OatHeader& oat_header = oat_file->GetOatHeader();
1486 return real_patch_delta - oat_header.GetImagePatchDelta();
1487}
1488
1489bool ClassLinker::CheckOatFile(const OatFile* oat_file, InstructionSet isa,
1490 bool* checksum_verified,
1491 std::string* error_msg) {
1492 std::string compound_msg("Oat file failed to verify: ");
1493 Runtime* runtime = Runtime::Current();
1494 uint32_t real_image_checksum;
1495 void* real_image_oat_offset;
1496 int32_t real_patch_delta;
1497 const gc::space::ImageSpace* image_space = runtime->GetHeap()->GetImageSpace();
Alex Light507e6182014-08-19 14:23:13 -07001498 if (image_space == nullptr) {
1499 *error_msg = "No image space present";
1500 return false;
1501 }
Alex Lighta59dd802014-07-02 16:28:08 -07001502 if (isa == Runtime::Current()->GetInstructionSet()) {
1503 const ImageHeader& image_header = image_space->GetImageHeader();
1504 real_image_checksum = image_header.GetOatChecksum();
1505 real_image_oat_offset = image_header.GetOatDataBegin();
1506 real_patch_delta = image_header.GetPatchDelta();
1507 } else {
1508 std::unique_ptr<ImageHeader> image_header(gc::space::ImageSpace::ReadImageHeaderOrDie(
1509 image_space->GetImageLocation().c_str(), isa));
1510 real_image_checksum = image_header->GetOatChecksum();
1511 real_image_oat_offset = image_header->GetOatDataBegin();
1512 real_patch_delta = image_header->GetPatchDelta();
1513 }
1514
1515 const OatHeader& oat_header = oat_file->GetOatHeader();
1516
1517 uint32_t oat_image_checksum = oat_header.GetImageFileLocationOatChecksum();
1518 *checksum_verified = oat_image_checksum == real_image_checksum;
1519 if (!*checksum_verified) {
1520 compound_msg += StringPrintf(" Oat Image Checksum Incorrect (expected 0x%x, recieved 0x%x)",
1521 real_image_checksum, oat_image_checksum);
1522 }
1523
1524 void* oat_image_oat_offset =
1525 reinterpret_cast<void*>(oat_header.GetImageFileLocationOatDataBegin());
1526 bool offset_verified = oat_image_oat_offset == real_image_oat_offset;
1527 if (!offset_verified) {
1528 compound_msg += StringPrintf(" Oat Image oat offset incorrect (expected 0x%p, recieved 0x%p)",
1529 real_image_oat_offset, oat_image_oat_offset);
1530 }
1531
1532 int32_t oat_patch_delta = oat_header.GetImagePatchDelta();
1533 bool patch_delta_verified = oat_patch_delta == real_patch_delta;
1534 if (!patch_delta_verified) {
1535 compound_msg += StringPrintf(" Oat image patch delta incorrect (expected 0x%x, recieved 0x%x)",
1536 real_patch_delta, oat_patch_delta);
1537 }
1538
1539 bool ret = (*checksum_verified && offset_verified && patch_delta_verified);
1540 if (ret) {
1541 *error_msg = compound_msg;
1542 }
1543 return ret;
1544}
1545
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001546const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location,
1547 std::string* error_msg) {
jeffhaof6174e82012-01-31 16:14:17 -08001548 const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001549 if (oat_file != nullptr) {
jeffhaof6174e82012-01-31 16:14:17 -08001550 return oat_file;
1551 }
1552
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001553 oat_file = OatFile::Open(oat_location, oat_location, NULL, !Runtime::Current()->IsCompiler(),
1554 error_msg);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001555 if (oat_file == NULL) {
Brian Carlstroma004aa92012-02-08 18:05:09 -08001556 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001557 }
1558 return oat_file;
1559}
1560
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001561static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
Ian Rogers848871b2013-08-05 10:56:33 -07001562 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001563 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
1564
Ian Rogers848871b2013-08-05 10:56:33 -07001565 DCHECK(obj != NULL);
1566 DCHECK(class_linker != NULL);
1567
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001568 if (obj->IsArtMethod()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001569 mirror::ArtMethod* method = obj->AsArtMethod();
Ian Rogers848871b2013-08-05 10:56:33 -07001570 if (!method->IsNative()) {
1571 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
1572 if (method != Runtime::Current()->GetResolutionMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001573 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
1574 method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
Ian Rogers848871b2013-08-05 10:56:33 -07001575 }
1576 }
1577 }
1578}
1579
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001580void ClassLinker::InitFromImage() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001581 VLOG(startup) << "ClassLinker::InitFromImage entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001582 CHECK(!init_done_);
1583
Mathieu Chartier590fee92013-09-13 13:46:47 -07001584 Thread* self = Thread::Current();
Ian Rogers1d54e732013-05-02 21:10:01 -07001585 gc::Heap* heap = Runtime::Current()->GetHeap();
1586 gc::space::ImageSpace* space = heap->GetImageSpace();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001587 dex_cache_image_class_lookup_required_ = true;
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001588 CHECK(space != NULL);
1589 OatFile& oat_file = GetImageOatFile(space);
1590 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
1591 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
Andreas Gampe22f8e5c2014-07-09 11:38:21 -07001592 const char* image_file_location = oat_file.GetOatHeader().
1593 GetStoreValueByKey(OatHeader::kImageLocationKey);
1594 CHECK(image_file_location == nullptr || *image_file_location == 0);
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001595 portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
1596 quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
Jeff Hao88474b42013-10-23 16:24:40 -07001597 portable_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetPortableImtConflictTrampoline();
1598 quick_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetQuickImtConflictTrampoline();
Andreas Gampe2da88232014-02-27 12:26:20 -08001599 quick_generic_jni_trampoline_ = oat_file.GetOatHeader().GetQuickGenericJniTrampoline();
Vladimir Marko8a630572014-04-09 18:45:35 +01001600 quick_to_interpreter_bridge_trampoline_ = oat_file.GetOatHeader().GetQuickToInterpreterBridge();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001601 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
1602 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1603 dex_caches_object->AsObjectArray<mirror::DexCache>();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001604
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001605 StackHandleScope<1> hs(self);
1606 Handle<mirror::ObjectArray<mirror::Class>> class_roots(hs.NewHandle(
1607 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->
1608 AsObjectArray<mirror::Class>()));
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001609 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(class_roots.Get());
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001610
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001611 // Special case of setting up the String class early so that we can test arbitrary objects
1612 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001613 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001614
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001615 CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001616 static_cast<uint32_t>(dex_caches->GetLength()));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001617 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001618 StackHandleScope<1> hs(self);
1619 Handle<mirror::DexCache> dex_cache(hs.NewHandle(dex_caches->Get(i)));
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001620 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001621 const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location.c_str(),
1622 nullptr);
Brian Carlstrom56d947f2013-07-15 13:14:23 -07001623 CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001624 std::string error_msg;
1625 const DexFile* dex_file = oat_dex_file->OpenDexFile(&error_msg);
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001626 if (dex_file == NULL) {
1627 LOG(FATAL) << "Failed to open dex file " << dex_file_location
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001628 << " from within oat file " << oat_file.GetLocation()
1629 << " error '" << error_msg << "'";
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001630 }
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001631
1632 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
1633
1634 AppendToBootClassPath(*dex_file, dex_cache);
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001635 }
1636
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001637 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
1638 // bitmap walk.
Brian Carlstromea46f952013-07-30 01:26:50 -07001639 mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001640
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001641 // Set entry point to interpreter if in InterpretOnly mode.
1642 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001643 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001644 heap->VisitObjects(InitFromImageInterpretOnlyCallback, this);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001645 }
Brian Carlstroma663ea52011-08-19 23:33:41 -07001646
1647 // reinit class_roots_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001648 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001649 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(class_roots.Get());
Brian Carlstroma663ea52011-08-19 23:33:41 -07001650
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001651 // reinit array_iftable_ from any array class instance, they should be ==
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001652 array_iftable_ = GcRoot<mirror::IfTable>(GetClassRoot(kObjectArrayClass)->GetIfTable());
1653 DCHECK(array_iftable_.Read() == GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001654 // String class root was set above
Fred Shih4ee7a662014-07-11 09:59:27 -07001655 mirror::Reference::SetClass(GetClassRoot(kJavaLangRefReference));
Brian Carlstromea46f952013-07-30 01:26:50 -07001656 mirror::ArtField::SetClass(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001657 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1658 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1659 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1660 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1661 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1662 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1663 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1664 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1665 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1666 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001667
Ian Rogers98379392014-02-24 16:53:16 -08001668 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001669
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001670 VLOG(startup) << "ClassLinker::InitFromImage exiting";
Brian Carlstroma663ea52011-08-19 23:33:41 -07001671}
1672
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001673void ClassLinker::VisitClassRoots(RootCallback* callback, void* arg, VisitRootFlags flags) {
1674 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
1675 if ((flags & kVisitRootFlagAllRoots) != 0) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001676 for (std::pair<const size_t, GcRoot<mirror::Class> >& it : class_table_) {
1677 it.second.VisitRoot(callback, arg, 0, kRootStickyClass);
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001678 }
1679 } else if ((flags & kVisitRootFlagNewRoots) != 0) {
1680 for (auto& pair : new_class_roots_) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001681 mirror::Class* old_ref = pair.second.Read<kWithoutReadBarrier>();
1682 pair.second.VisitRoot(callback, arg, 0, kRootStickyClass);
1683 mirror::Class* new_ref = pair.second.Read<kWithoutReadBarrier>();
1684 if (UNLIKELY(new_ref != old_ref)) {
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001685 // Uh ohes, GC moved a root in the log. Need to search the class_table and update the
1686 // corresponding object. This is slow, but luckily for us, this may only happen with a
1687 // concurrent moving GC.
1688 for (auto it = class_table_.lower_bound(pair.first), end = class_table_.end();
1689 it != end && it->first == pair.first; ++it) {
1690 // If the class stored matches the old class, update it to the new value.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001691 if (old_ref == it->second.Read<kWithoutReadBarrier>()) {
1692 it->second = GcRoot<mirror::Class>(new_ref);
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001693 }
1694 }
1695 }
1696 }
1697 }
1698 if ((flags & kVisitRootFlagClearRootLog) != 0) {
1699 new_class_roots_.clear();
1700 }
1701 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
1702 log_new_class_table_roots_ = true;
1703 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
1704 log_new_class_table_roots_ = false;
1705 }
1706 // We deliberately ignore the class roots in the image since we
1707 // handle image roots by using the MS/CMS rescanning of dirty cards.
1708}
1709
Brian Carlstroma663ea52011-08-19 23:33:41 -07001710// Keep in sync with InitCallback. Anything we visit, we need to
1711// reinit references to when reinitializing a ClassLinker from a
1712// mapped image.
Mathieu Chartier893263b2014-03-04 11:07:42 -08001713void ClassLinker::VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001714 class_roots_.VisitRoot(callback, arg, 0, kRootVMInternal);
Ian Rogers50b35e22012-10-04 10:09:15 -07001715 Thread* self = Thread::Current();
Elliott Hughesf8349362012-06-18 15:00:06 -07001716 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07001717 ReaderMutexLock mu(self, dex_lock_);
Mathieu Chartier893263b2014-03-04 11:07:42 -08001718 if ((flags & kVisitRootFlagAllRoots) != 0) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001719 for (GcRoot<mirror::DexCache>& dex_cache : dex_caches_) {
1720 dex_cache.VisitRoot(callback, arg, 0, kRootVMInternal);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001721 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001722 } else if ((flags & kVisitRootFlagNewRoots) != 0) {
1723 for (size_t index : new_dex_cache_roots_) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001724 dex_caches_[index].VisitRoot(callback, arg, 0, kRootVMInternal);
Mathieu Chartierc4621982013-09-16 19:43:47 -07001725 }
Elliott Hughesf8349362012-06-18 15:00:06 -07001726 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001727 if ((flags & kVisitRootFlagClearRootLog) != 0) {
1728 new_dex_cache_roots_.clear();
1729 }
1730 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
1731 log_new_dex_caches_roots_ = true;
1732 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
1733 log_new_dex_caches_roots_ = false;
1734 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001735 }
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001736 VisitClassRoots(callback, arg, flags);
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001737 array_iftable_.VisitRoot(callback, arg, 0, kRootVMInternal);
1738 DCHECK(!array_iftable_.IsNull());
Ian Rogers98379392014-02-24 16:53:16 -08001739 for (size_t i = 0; i < kFindArrayCacheSize; ++i) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001740 if (!find_array_class_cache_[i].IsNull()) {
1741 find_array_class_cache_[i].VisitRoot(callback, arg, 0, kRootVMInternal);
Ian Rogers98379392014-02-24 16:53:16 -08001742 }
1743 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001744}
1745
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001746void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) {
1747 if (dex_cache_image_class_lookup_required_) {
1748 MoveImageClassesToClassTable();
Elliott Hughesa2155262011-11-16 16:26:58 -08001749 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001750 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001751 for (std::pair<const size_t, GcRoot<mirror::Class> >& it : class_table_) {
1752 mirror::Class* c = it.second.Read();
Hiroshi Yamauchia91a4bc2014-06-13 16:44:55 -07001753 if (!visitor(c, arg)) {
Elliott Hughesa2155262011-11-16 16:26:58 -08001754 return;
1755 }
1756 }
1757}
1758
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001759static bool GetClassesVisitor(mirror::Class* c, void* arg) {
1760 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001761 classes->insert(c);
1762 return true;
1763}
1764
Ian Rogers7dfb28c2013-08-22 08:18:36 -07001765void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001766 std::set<mirror::Class*> classes;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001767 VisitClasses(GetClassesVisitor, &classes);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001768 for (mirror::Class* klass : classes) {
1769 if (!visitor(klass, arg)) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001770 return;
1771 }
1772 }
1773}
1774
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001775ClassLinker::~ClassLinker() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001776 mirror::Class::ResetClass();
1777 mirror::String::ResetClass();
Fred Shih4ee7a662014-07-11 09:59:27 -07001778 mirror::Reference::ResetClass();
Brian Carlstromea46f952013-07-30 01:26:50 -07001779 mirror::ArtField::ResetClass();
1780 mirror::ArtMethod::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001781 mirror::BooleanArray::ResetArrayClass();
1782 mirror::ByteArray::ResetArrayClass();
1783 mirror::CharArray::ResetArrayClass();
1784 mirror::DoubleArray::ResetArrayClass();
1785 mirror::FloatArray::ResetArrayClass();
1786 mirror::IntArray::ResetArrayClass();
1787 mirror::LongArray::ResetArrayClass();
1788 mirror::ShortArray::ResetArrayClass();
1789 mirror::Throwable::ResetClass();
1790 mirror::StackTraceElement::ResetClass();
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001791 STLDeleteElements(&boot_class_path_);
1792 STLDeleteElements(&oat_files_);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001793}
1794
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001795mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001796 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001797 StackHandleScope<16> hs(self);
1798 Handle<mirror::Class> dex_cache_class(hs.NewHandle(GetClassRoot(kJavaLangDexCache)));
1799 Handle<mirror::DexCache> dex_cache(
1800 hs.NewHandle(down_cast<mirror::DexCache*>(
1801 heap->AllocObject<true>(self, dex_cache_class.Get(), dex_cache_class->GetObjectSize(),
1802 VoidFunctor()))));
1803 if (dex_cache.Get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001804 return NULL;
1805 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001806 Handle<mirror::String>
1807 location(hs.NewHandle(intern_table_->InternStrong(dex_file.GetLocation().c_str())));
1808 if (location.Get() == NULL) {
Elliott Hughes30646832011-10-13 16:59:46 -07001809 return NULL;
1810 }
Ian Rogers700a4022014-05-19 16:49:03 -07001811 Handle<mirror::ObjectArray<mirror::String>>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001812 strings(hs.NewHandle(AllocStringArray(self, dex_file.NumStringIds())));
1813 if (strings.Get() == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001814 return NULL;
1815 }
Ian Rogers700a4022014-05-19 16:49:03 -07001816 Handle<mirror::ObjectArray<mirror::Class>>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001817 types(hs.NewHandle(AllocClassArray(self, dex_file.NumTypeIds())));
1818 if (types.Get() == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001819 return NULL;
1820 }
Ian Rogers700a4022014-05-19 16:49:03 -07001821 Handle<mirror::ObjectArray<mirror::ArtMethod>>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001822 methods(hs.NewHandle(AllocArtMethodArray(self, dex_file.NumMethodIds())));
1823 if (methods.Get() == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001824 return NULL;
1825 }
Ian Rogers700a4022014-05-19 16:49:03 -07001826 Handle<mirror::ObjectArray<mirror::ArtField>>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001827 fields(hs.NewHandle(AllocArtFieldArray(self, dex_file.NumFieldIds())));
1828 if (fields.Get() == NULL) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001829 return NULL;
1830 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001831 dex_cache->Init(&dex_file, location.Get(), strings.Get(), types.Get(), methods.Get(),
1832 fields.Get());
1833 return dex_cache.Get();
Brian Carlstroma0808032011-07-18 00:39:23 -07001834}
1835
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001836mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
Ian Rogers6fac4472014-02-25 17:01:10 -08001837 uint32_t class_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001838 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07001839 gc::Heap* heap = Runtime::Current()->GetHeap();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001840 mirror::Class::InitializeClassVisitor visitor(class_size);
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001841 mirror::Object* k = kMovingClasses ?
Brian Carlstromf3632832014-05-20 15:36:53 -07001842 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) :
1843 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
Ian Rogers6fac4472014-02-25 17:01:10 -08001844 if (UNLIKELY(k == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001845 CHECK(self->IsExceptionPending()); // OOME.
Ian Rogers6fac4472014-02-25 17:01:10 -08001846 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07001847 }
Ian Rogers6fac4472014-02-25 17:01:10 -08001848 return k->AsClass();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001849}
1850
Ian Rogers6fac4472014-02-25 17:01:10 -08001851mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001852 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07001853}
1854
Brian Carlstromea46f952013-07-30 01:26:50 -07001855mirror::ArtField* ClassLinker::AllocArtField(Thread* self) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001856 return down_cast<mirror::ArtField*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001857 GetClassRoot(kJavaLangReflectArtField)->AllocNonMovableObject(self));
Brian Carlstroma0808032011-07-18 00:39:23 -07001858}
1859
Brian Carlstromea46f952013-07-30 01:26:50 -07001860mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07001861 return down_cast<mirror::ArtMethod*>(
Mathieu Chartiercbb2d202013-11-14 17:45:16 -08001862 GetClassRoot(kJavaLangReflectArtMethod)->AllocNonMovableObject(self));
Mathieu Chartier66f19252012-09-18 08:57:04 -07001863}
1864
Mathieu Chartier590fee92013-09-13 13:46:47 -07001865mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
1866 Thread* self, size_t length) {
1867 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
1868 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001869}
1870
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001871mirror::Class* ClassLinker::EnsureResolved(Thread* self, const char* descriptor,
1872 mirror::Class* klass) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001873 DCHECK(klass != NULL);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001874
1875 // For temporary classes we must wait for them to be retired.
1876 if (init_done_ && klass->IsTemp()) {
1877 CHECK(!klass->IsResolved());
1878 if (klass->IsErroneous()) {
1879 ThrowEarlierClassFailure(klass);
1880 return nullptr;
1881 }
1882 StackHandleScope<1> hs(self);
1883 Handle<mirror::Class> h_class(hs.NewHandle(klass));
1884 ObjectLock<mirror::Class> lock(self, h_class);
1885 // Loop and wait for the resolving thread to retire this class.
1886 while (!h_class->IsRetired() && !h_class->IsErroneous()) {
1887 lock.WaitIgnoringInterrupts();
1888 }
1889 if (h_class->IsErroneous()) {
1890 ThrowEarlierClassFailure(h_class.Get());
1891 return nullptr;
1892 }
1893 CHECK(h_class->IsRetired());
1894 // Get the updated class from class table.
1895 klass = LookupClass(descriptor, h_class.Get()->GetClassLoader());
1896 }
1897
Brian Carlstromaded5f72011-10-07 17:15:04 -07001898 // Wait for the class if it has not already been linked.
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001899 if (!klass->IsResolved() && !klass->IsErroneous()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001900 StackHandleScope<1> hs(self);
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07001901 HandleWrapper<mirror::Class> h_class(hs.NewHandleWrapper(&klass));
1902 ObjectLock<mirror::Class> lock(self, h_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001903 // Check for circular dependencies between classes.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001904 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) {
1905 ThrowClassCircularityError(h_class.Get());
1906 h_class->SetStatus(mirror::Class::kStatusError, self);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001907 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001908 }
1909 // Wait for the pending initialization to complete.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001910 while (!h_class->IsResolved() && !h_class->IsErroneous()) {
Ian Rogers05f30572013-02-20 12:13:11 -08001911 lock.WaitIgnoringInterrupts();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001912 }
1913 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001914
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001915 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001916 ThrowEarlierClassFailure(klass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001917 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001918 }
1919 // Return the loaded class. No exceptions should be pending.
Brian Carlstromaded5f72011-10-07 17:15:04 -07001920 CHECK(klass->IsResolved()) << PrettyClass(klass);
Ian Rogers62d6c772013-02-27 08:32:07 -08001921 self->AssertNoPendingException();
Brian Carlstromaded5f72011-10-07 17:15:04 -07001922 return klass;
1923}
1924
Ian Rogers98379392014-02-24 16:53:16 -08001925mirror::Class* ClassLinker::FindClass(Thread* self, const char* descriptor,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07001926 Handle<mirror::ClassLoader> class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08001927 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Ian Rogers98379392014-02-24 16:53:16 -08001928 DCHECK(self != nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001929 self->AssertNoPendingException();
Elliott Hughesc3b77c72011-12-15 20:56:48 -08001930 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001931 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
1932 // for primitive classes that aren't backed by dex files.
1933 return FindPrimitiveClass(descriptor[0]);
1934 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001935 // Find the class in the loaded classes table.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001936 mirror::Class* klass = LookupClass(descriptor, class_loader.Get());
Brian Carlstromaded5f72011-10-07 17:15:04 -07001937 if (klass != NULL) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001938 return EnsureResolved(self, descriptor, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001939 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001940 // Class is not yet loaded.
1941 if (descriptor[0] == '[') {
Ian Rogers98379392014-02-24 16:53:16 -08001942 return CreateArrayClass(self, descriptor, class_loader);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001943 } else if (class_loader.Get() == nullptr) {
Jesse Wilson47daf872011-11-23 11:42:45 -05001944 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
1945 if (pair.second != NULL) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001946 StackHandleScope<1> hs(self);
Mathieu Chartier0cd81352014-05-22 16:48:55 -07001947 return DefineClass(descriptor, NullHandle<mirror::ClassLoader>(), *pair.first, *pair.second);
Jesse Wilson47daf872011-11-23 11:42:45 -05001948 }
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001949 } else if (Runtime::Current()->UseCompileTimeClassPath()) {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001950 // First try the boot class path, we check the descriptor first to avoid an unnecessary
1951 // throw of a NoClassDefFoundError.
1952 if (IsInBootClassPath(descriptor)) {
Ian Rogers98379392014-02-24 16:53:16 -08001953 mirror::Class* system_class = FindSystemClass(self, descriptor);
Ian Rogersbe7149f2013-08-20 09:29:39 -07001954 CHECK(system_class != NULL);
Jesse Wilson47daf872011-11-23 11:42:45 -05001955 return system_class;
1956 }
Ian Rogersbe7149f2013-08-20 09:29:39 -07001957 // Next try the compile time class path.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001958 const std::vector<const DexFile*>* class_path;
1959 {
Ian Rogersbe7149f2013-08-20 09:29:39 -07001960 ScopedObjectAccessUnchecked soa(self);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001961 ScopedLocalRef<jobject> jclass_loader(soa.Env(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001962 soa.AddLocalReference<jobject>(class_loader.Get()));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001963 class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
1964 }
1965
1966 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
Jesse Wilson47daf872011-11-23 11:42:45 -05001967 if (pair.second != NULL) {
1968 return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
Brian Carlstromaded5f72011-10-07 17:15:04 -07001969 }
Jesse Wilson47daf872011-11-23 11:42:45 -05001970
1971 } else {
Ian Rogers98379392014-02-24 16:53:16 -08001972 ScopedObjectAccessUnchecked soa(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001973 ScopedLocalRef<jobject> class_loader_object(soa.Env(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001974 soa.AddLocalReference<jobject>(class_loader.Get()));
Elliott Hughes95572412011-12-13 18:14:20 -08001975 std::string class_name_string(DescriptorToDot(descriptor));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001976 ScopedLocalRef<jobject> result(soa.Env(), NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001977 {
1978 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001979 ScopedLocalRef<jobject> class_name_object(soa.Env(),
1980 soa.Env()->NewStringUTF(class_name_string.c_str()));
Ian Rogers365c1022012-06-22 15:05:28 -07001981 if (class_name_object.get() == NULL) {
1982 return NULL;
1983 }
1984 CHECK(class_loader_object.get() != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001985 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
1986 WellKnownClasses::java_lang_ClassLoader_loadClass,
1987 class_name_object.get()));
Jesse Wilson47daf872011-11-23 11:42:45 -05001988 }
Ian Rogers98379392014-02-24 16:53:16 -08001989 if (self->IsExceptionPending()) {
Elliott Hughes748382f2012-01-26 18:07:38 -08001990 // If the ClassLoader threw, pass that exception up.
1991 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001992 } else if (result.get() == NULL) {
Ian Rogerscab01012012-01-10 17:35:46 -08001993 // broken loader - throw NPE to be compatible with Dalvik
Ian Rogers62d6c772013-02-27 08:32:07 -08001994 ThrowNullPointerException(NULL, StringPrintf("ClassLoader.loadClass returned null for %s",
1995 class_name_string.c_str()).c_str());
Ian Rogerscab01012012-01-10 17:35:46 -08001996 return NULL;
Ian Rogers761bfa82012-01-11 10:14:05 -08001997 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001998 // success, return mirror::Class*
1999 return soa.Decode<mirror::Class*>(result.get());
Ian Rogers6b0870d2011-12-15 19:38:12 -08002000 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002001 }
2002
Elliott Hughes82914b62012-04-09 15:56:29 -07002003 ThrowNoClassDefFoundError("Class %s not found", PrintableString(descriptor).c_str());
Jesse Wilson47daf872011-11-23 11:42:45 -05002004 return NULL;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002005}
2006
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002007mirror::Class* ClassLinker::DefineClass(const char* descriptor,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002008 Handle<mirror::ClassLoader> class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002009 const DexFile& dex_file,
2010 const DexFile::ClassDef& dex_class_def) {
Ian Rogers1f539342012-10-03 21:09:42 -07002011 Thread* self = Thread::Current();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002012 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002013 auto klass = hs.NewHandle<mirror::Class>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002014 bool should_allocate = false;
2015
Brian Carlstromaded5f72011-10-07 17:15:04 -07002016 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002017 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002018 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002019 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002020 klass.Assign(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002021 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002022 klass.Assign(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002023 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002024 klass.Assign(GetClassRoot(kJavaLangString));
Fred Shih4ee7a662014-07-11 09:59:27 -07002025 } else if (strcmp(descriptor, "Ljava/lang/ref/Reference;") == 0) {
2026 klass.Assign(GetClassRoot(kJavaLangRefReference));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002027 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002028 klass.Assign(GetClassRoot(kJavaLangDexCache));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002029 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002030 klass.Assign(GetClassRoot(kJavaLangReflectArtField));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002031 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002032 klass.Assign(GetClassRoot(kJavaLangReflectArtMethod));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002033 } else {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002034 should_allocate = true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002035 }
2036 } else {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002037 should_allocate = true;
2038 }
2039
2040 if (should_allocate) {
2041 // Allocate a class with the status of not ready.
2042 // Interface object should get the right size here. Regular class will
2043 // figure out the right size later and be replaced with one of the right
2044 // size when the class becomes resolved.
2045 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002046 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002047 if (UNLIKELY(klass.Get() == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002048 CHECK(self->IsExceptionPending()); // Expect an OOME.
Ian Rogersc114b5f2014-07-21 08:55:01 -07002049 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002050 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002051 klass->SetDexCache(FindDexCache(dex_file));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002052 LoadClass(dex_file, dex_class_def, klass, class_loader.Get());
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07002053 ObjectLock<mirror::Class> lock(self, klass);
Ian Rogersc114b5f2014-07-21 08:55:01 -07002054 if (self->IsExceptionPending()) {
2055 // An exception occured during load, set status to erroneous while holding klass' lock in case
2056 // notification is necessary.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002057 if (!klass->IsErroneous()) {
2058 klass->SetStatus(mirror::Class::kStatusError, self);
2059 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002060 return nullptr;
2061 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002062 klass->SetClinitThreadId(self->GetTid());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002063
Mathieu Chartier590fee92013-09-13 13:46:47 -07002064 // Add the newly loaded class to the loaded classes table.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002065 mirror::Class* existing = InsertClass(descriptor, klass.Get(), Hash(descriptor));
Ian Rogersc114b5f2014-07-21 08:55:01 -07002066 if (existing != nullptr) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002067 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
2068 // this thread to block.
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002069 return EnsureResolved(self, descriptor, existing);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002070 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002071
Brian Carlstromaded5f72011-10-07 17:15:04 -07002072 // Finish loading (if necessary) by finding parents
2073 CHECK(!klass->IsLoaded());
2074 if (!LoadSuperAndInterfaces(klass, dex_file)) {
2075 // Loading failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002076 if (!klass->IsErroneous()) {
2077 klass->SetStatus(mirror::Class::kStatusError, self);
2078 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002079 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002080 }
2081 CHECK(klass->IsLoaded());
2082 // Link the class (if necessary)
2083 CHECK(!klass->IsResolved());
Mathieu Chartier590fee92013-09-13 13:46:47 -07002084 // TODO: Use fast jobjects?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002085 auto interfaces = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002086
2087 mirror::Class* new_class = nullptr;
2088 if (!LinkClass(self, descriptor, klass, interfaces, &new_class)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002089 // Linking failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002090 if (!klass->IsErroneous()) {
2091 klass->SetStatus(mirror::Class::kStatusError, self);
2092 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002093 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002094 }
Mathieu Chartier58c016c2014-08-27 15:28:28 -07002095 self->AssertNoPendingException();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002096 CHECK(new_class != nullptr) << descriptor;
2097 CHECK(new_class->IsResolved()) << descriptor;
2098
2099 Handle<mirror::Class> new_class_h(hs.NewHandle(new_class));
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002100
2101 /*
2102 * We send CLASS_PREPARE events to the debugger from here. The
2103 * definition of "preparation" is creating the static fields for a
2104 * class and initializing them to the standard default values, but not
2105 * executing any code (that comes later, during "initialization").
2106 *
2107 * We did the static preparation in LinkClass.
2108 *
2109 * The class has been prepared and resolved but possibly not yet verified
2110 * at this point.
2111 */
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002112 Dbg::PostClassPrepare(new_class_h.Get());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002113
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002114 return new_class_h.Get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002115}
2116
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002117uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
2118 const DexFile::ClassDef& dex_class_def) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07002119 const byte* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002120 size_t num_ref = 0;
2121 size_t num_32 = 0;
2122 size_t num_64 = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07002123 if (class_data != NULL) {
2124 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
2125 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002126 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002127 char c = descriptor[0];
2128 if (c == 'L' || c == '[') {
2129 num_ref++;
2130 } else if (c == 'J' || c == 'D') {
2131 num_64++;
2132 } else {
2133 num_32++;
2134 }
2135 }
2136 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002137 return mirror::Class::ComputeClassSize(false, 0, num_32, num_64, num_ref);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002138}
2139
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002140bool ClassLinker::FindOatClass(const DexFile& dex_file,
2141 uint16_t class_def_idx,
2142 OatFile::OatClass* oat_class) {
2143 DCHECK(oat_class != nullptr);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002144 DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
Ian Rogers19846512012-02-24 11:42:47 -08002145 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002146 if (oat_file == nullptr) {
2147 return false;
2148 }
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002149 uint dex_location_checksum = dex_file.GetLocationChecksum();
Ian Rogers8d31bbd2013-10-13 10:44:14 -07002150 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07002151 &dex_location_checksum);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002152 CHECK(oat_dex_file != NULL) << dex_file.GetLocation();
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002153 *oat_class = oat_dex_file->GetOatClass(class_def_idx);
2154 return true;
Ian Rogers19846512012-02-24 11:42:47 -08002155}
2156
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002157static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint16_t class_def_idx,
2158 uint32_t method_idx) {
2159 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
2160 const byte* class_data = dex_file.GetClassData(class_def);
Mathieu Chartiere35517a2012-10-30 18:49:55 -07002161 CHECK(class_data != NULL);
2162 ClassDataItemIterator it(dex_file, class_data);
2163 // Skip fields
2164 while (it.HasNextStaticField()) {
2165 it.Next();
2166 }
2167 while (it.HasNextInstanceField()) {
2168 it.Next();
2169 }
2170 // Process methods
2171 size_t class_def_method_index = 0;
2172 while (it.HasNextDirectMethod()) {
2173 if (it.GetMemberIndex() == method_idx) {
2174 return class_def_method_index;
2175 }
2176 class_def_method_index++;
2177 it.Next();
2178 }
2179 while (it.HasNextVirtualMethod()) {
2180 if (it.GetMemberIndex() == method_idx) {
2181 return class_def_method_index;
2182 }
2183 class_def_method_index++;
2184 it.Next();
2185 }
2186 DCHECK(!it.HasNext());
2187 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
2188 return 0;
2189}
2190
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002191bool ClassLinker::FindOatMethodFor(mirror::ArtMethod* method, OatFile::OatMethod* oat_method) {
2192 DCHECK(oat_method != nullptr);
Ian Rogers19846512012-02-24 11:42:47 -08002193 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
Ian Rogersfb6adba2012-03-04 21:51:51 -08002194 // method for direct methods (or virtual methods made direct).
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002195 mirror::Class* declaring_class = method->GetDeclaringClass();
Ian Rogersfb6adba2012-03-04 21:51:51 -08002196 size_t oat_method_index;
2197 if (method->IsStatic() || method->IsDirect()) {
2198 // Simple case where the oat method index was stashed at load time.
2199 oat_method_index = method->GetMethodIndex();
2200 } else {
2201 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
2202 // by search for its position in the declared virtual methods.
2203 oat_method_index = declaring_class->NumDirectMethods();
2204 size_t end = declaring_class->NumVirtualMethods();
2205 bool found = false;
2206 for (size_t i = 0; i < end; i++) {
Ian Rogersfb6adba2012-03-04 21:51:51 -08002207 if (declaring_class->GetVirtualMethod(i) == method) {
2208 found = true;
2209 break;
2210 }
Ian Rogersf320b632012-03-13 18:47:47 -07002211 oat_method_index++;
Ian Rogersfb6adba2012-03-04 21:51:51 -08002212 }
2213 CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
2214 }
Mathieu Chartiere35517a2012-10-30 18:49:55 -07002215 DCHECK_EQ(oat_method_index,
2216 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002217 method->GetDeclaringClass()->GetDexClassDefIndex(),
Mathieu Chartiere35517a2012-10-30 18:49:55 -07002218 method->GetDexMethodIndex()));
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002219 OatFile::OatClass oat_class;
2220 if (!FindOatClass(*declaring_class->GetDexCache()->GetDexFile(),
2221 declaring_class->GetDexClassDefIndex(),
2222 &oat_class)) {
2223 return false;
2224 }
Mathieu Chartiere35517a2012-10-30 18:49:55 -07002225
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002226 *oat_method = oat_class.GetOatMethod(oat_method_index);
2227 return true;
TDYa12785321912012-04-01 15:24:56 -07002228}
2229
2230// Special case to get oat code without overwriting a trampoline.
Ian Rogersef7d42f2014-01-06 12:55:46 -08002231const void* ClassLinker::GetQuickOatCodeFor(mirror::ArtMethod* method) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002232 CHECK(!method->IsAbstract()) << PrettyMethod(method);
Jeff Hao8df6cea2013-07-29 13:54:48 -07002233 if (method->IsProxyMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002234 return GetQuickProxyInvokeHandler();
Jeff Hao8df6cea2013-07-29 13:54:48 -07002235 }
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002236 OatFile::OatMethod oat_method;
2237 const void* result = nullptr;
2238 if (FindOatMethodFor(method, &oat_method)) {
2239 result = oat_method.GetQuickCode();
2240 }
2241
Ian Rogersef7d42f2014-01-06 12:55:46 -08002242 if (result == nullptr) {
Ian Rogers1a570662014-03-12 01:02:21 -07002243 if (method->IsNative()) {
2244 // No code and native? Use generic trampoline.
2245 result = GetQuickGenericJniTrampoline();
2246 } else if (method->IsPortableCompiled()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002247 // No code? Do we expect portable code?
2248 result = GetQuickToPortableBridge();
2249 } else {
2250 // No code? You must mean to go into the interpreter.
2251 result = GetQuickToInterpreterBridge();
2252 }
Ian Rogersf3e98552013-03-20 15:49:49 -07002253 }
2254 return result;
TDYa12785321912012-04-01 15:24:56 -07002255}
2256
Ian Rogersef7d42f2014-01-06 12:55:46 -08002257const void* ClassLinker::GetPortableOatCodeFor(mirror::ArtMethod* method,
2258 bool* have_portable_code) {
2259 CHECK(!method->IsAbstract()) << PrettyMethod(method);
2260 *have_portable_code = false;
2261 if (method->IsProxyMethod()) {
2262 return GetPortableProxyInvokeHandler();
2263 }
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002264 OatFile::OatMethod oat_method;
2265 const void* result = nullptr;
2266 const void* quick_code = nullptr;
2267 if (FindOatMethodFor(method, &oat_method)) {
2268 result = oat_method.GetPortableCode();
2269 quick_code = oat_method.GetQuickCode();
2270 }
2271
Ian Rogersef7d42f2014-01-06 12:55:46 -08002272 if (result == nullptr) {
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002273 if (quick_code == nullptr) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002274 // No code? You must mean to go into the interpreter.
2275 result = GetPortableToInterpreterBridge();
2276 } else {
2277 // No code? But there's quick code, so use a bridge.
2278 result = GetPortableToQuickBridge();
2279 }
2280 } else {
2281 *have_portable_code = true;
2282 }
2283 return result;
2284}
2285
2286const void* ClassLinker::GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
2287 uint32_t method_idx) {
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002288 OatFile::OatClass oat_class;
2289 if (!FindOatClass(dex_file, class_def_idx, &oat_class)) {
2290 return nullptr;
2291 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002292 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01002293 return oat_class.GetOatMethod(oat_method_idx).GetQuickCode();
Ian Rogersef7d42f2014-01-06 12:55:46 -08002294}
2295
2296const void* ClassLinker::GetPortableOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
2297 uint32_t method_idx) {
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002298 OatFile::OatClass oat_class;
2299 if (!FindOatClass(dex_file, class_def_idx, &oat_class)) {
2300 return nullptr;
2301 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08002302 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01002303 return oat_class.GetOatMethod(oat_method_idx).GetPortableCode();
Mathieu Chartiere35517a2012-10-30 18:49:55 -07002304}
2305
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002306// Returns true if the method must run with interpreter, false otherwise.
Brian Carlstromf3632832014-05-20 15:36:53 -07002307static bool NeedsInterpreter(
2308 mirror::ArtMethod* method, const void* quick_code, const void* portable_code)
2309 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002310 if ((quick_code == nullptr) && (portable_code == nullptr)) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002311 // No code: need interpreter.
Andreas Gampe2da88232014-02-27 12:26:20 -08002312 // May return true for native code, in the case of generic JNI
2313 // DCHECK(!method->IsNative());
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002314 return true;
2315 }
Dragos Sbirlea90af14d2013-08-15 17:50:16 -07002316#ifdef ART_SEA_IR_MODE
2317 ScopedObjectAccess soa(Thread::Current());
2318 if (std::string::npos != PrettyMethod(method).find("fibonacci")) {
2319 LOG(INFO) << "Found " << PrettyMethod(method);
2320 return false;
2321 }
2322#endif
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002323 // If interpreter mode is enabled, every method (except native and proxy) must
2324 // be run with interpreter.
2325 return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
2326 !method->IsNative() && !method->IsProxyMethod();
2327}
2328
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002329void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
Brian Carlstrom073278c2014-02-19 15:21:21 -08002330 DCHECK(klass->IsInitialized()) << PrettyDescriptor(klass);
Ian Rogers1c829822013-09-30 18:18:50 -07002331 if (klass->NumDirectMethods() == 0) {
2332 return; // No direct methods => no static methods.
Ian Rogers19846512012-02-24 11:42:47 -08002333 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002334 Runtime* runtime = Runtime::Current();
2335 if (!runtime->IsStarted() || runtime->UseCompileTimeClassPath()) {
Alex Light507e6182014-08-19 14:23:13 -07002336 if (runtime->IsCompiler() || runtime->GetHeap()->HasImageSpace()) {
2337 return; // OAT file unavailable.
2338 }
Ian Rogers19846512012-02-24 11:42:47 -08002339 }
Alex Light507e6182014-08-19 14:23:13 -07002340
Mathieu Chartierf8322842014-05-16 10:59:25 -07002341 const DexFile& dex_file = klass->GetDexFile();
2342 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Ian Rogers1c829822013-09-30 18:18:50 -07002343 CHECK(dex_class_def != nullptr);
2344 const byte* class_data = dex_file.GetClassData(*dex_class_def);
2345 // There should always be class data if there were direct methods.
2346 CHECK(class_data != nullptr) << PrettyDescriptor(klass);
Ian Rogers19846512012-02-24 11:42:47 -08002347 ClassDataItemIterator it(dex_file, class_data);
2348 // Skip fields
2349 while (it.HasNextStaticField()) {
2350 it.Next();
2351 }
2352 while (it.HasNextInstanceField()) {
2353 it.Next();
2354 }
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002355 OatFile::OatClass oat_class;
2356 bool has_oat_class = FindOatClass(dex_file, klass->GetDexClassDefIndex(), &oat_class);
Ian Rogers1c829822013-09-30 18:18:50 -07002357 // Link the code of methods skipped by LinkCode.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002358 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07002359 mirror::ArtMethod* method = klass->GetDirectMethod(method_index);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002360 if (!method->IsStatic()) {
2361 // Only update static methods.
2362 continue;
Ian Rogers19846512012-02-24 11:42:47 -08002363 }
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002364 const void* portable_code = nullptr;
2365 const void* quick_code = nullptr;
2366 if (has_oat_class) {
2367 OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
2368 portable_code = oat_method.GetPortableCode();
2369 quick_code = oat_method.GetQuickCode();
2370 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08002371 const bool enter_interpreter = NeedsInterpreter(method, quick_code, portable_code);
2372 bool have_portable_code = false;
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002373 if (enter_interpreter) {
2374 // Use interpreter entry point.
Ian Rogers1a570662014-03-12 01:02:21 -07002375 // Check whether the method is native, in which case it's generic JNI.
Andreas Gampe2da88232014-02-27 12:26:20 -08002376 if (quick_code == nullptr && portable_code == nullptr && method->IsNative()) {
2377 quick_code = GetQuickGenericJniTrampoline();
Ian Rogers1a570662014-03-12 01:02:21 -07002378 portable_code = GetPortableToQuickBridge();
Andreas Gampe2da88232014-02-27 12:26:20 -08002379 } else {
Ian Rogers1a570662014-03-12 01:02:21 -07002380 portable_code = GetPortableToInterpreterBridge();
Andreas Gampe2da88232014-02-27 12:26:20 -08002381 quick_code = GetQuickToInterpreterBridge();
2382 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08002383 } else {
2384 if (portable_code == nullptr) {
2385 portable_code = GetPortableToQuickBridge();
2386 } else {
2387 have_portable_code = true;
2388 }
2389 if (quick_code == nullptr) {
2390 quick_code = GetQuickToPortableBridge();
2391 }
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002392 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08002393 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code, portable_code,
2394 have_portable_code);
Ian Rogers19846512012-02-24 11:42:47 -08002395 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002396 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08002397}
2398
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002399void ClassLinker::LinkCode(Handle<mirror::ArtMethod> method, const OatFile::OatClass* oat_class,
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +07002400 const DexFile& dex_file, uint32_t dex_method_index,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002401 uint32_t method_index) {
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002402 if (Runtime::Current()->IsCompiler()) {
2403 // The following code only applies to a non-compiler runtime.
2404 return;
2405 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002406 // Method shouldn't have already been linked.
Ian Rogersef7d42f2014-01-06 12:55:46 -08002407 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
2408 DCHECK(method->GetEntryPointFromPortableCompiledCode() == nullptr);
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002409 if (oat_class != nullptr) {
2410 // Every kind of method should at least get an invoke stub from the oat_method.
2411 // non-abstract methods also get their code pointers.
2412 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
2413 oat_method.LinkMethod(method.Get());
2414 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07002415
Jeff Hao16743632013-05-08 10:59:04 -07002416 // Install entry point from interpreter.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002417 bool enter_interpreter = NeedsInterpreter(method.Get(),
Ian Rogersef7d42f2014-01-06 12:55:46 -08002418 method->GetEntryPointFromQuickCompiledCode(),
2419 method->GetEntryPointFromPortableCompiledCode());
Andreas Gampebf6b92a2014-03-05 16:11:04 -08002420 if (enter_interpreter && !method->IsNative()) {
Ian Rogers848871b2013-08-05 10:56:33 -07002421 method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
Jeff Hao16743632013-05-08 10:59:04 -07002422 } else {
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07002423 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Jeff Hao16743632013-05-08 10:59:04 -07002424 }
2425
Brian Carlstrom92827a52011-10-10 15:50:01 -07002426 if (method->IsAbstract()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002427 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
2428 method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
Brian Carlstrom92827a52011-10-10 15:50:01 -07002429 return;
2430 }
Ian Rogers19846512012-02-24 11:42:47 -08002431
Ian Rogersef7d42f2014-01-06 12:55:46 -08002432 bool have_portable_code = false;
Ian Rogers19846512012-02-24 11:42:47 -08002433 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08002434 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002435 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
2436 // after initializing class (see ClassLinker::InitializeClass method).
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +07002437 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionTrampoline());
2438 method->SetEntryPointFromPortableCompiledCode(GetPortableResolutionTrampoline());
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002439 } else if (enter_interpreter) {
Andreas Gampebf6b92a2014-03-05 16:11:04 -08002440 if (!method->IsNative()) {
2441 // Set entry point from compiled code if there's no code or in interpreter only mode.
2442 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
2443 method->SetEntryPointFromPortableCompiledCode(GetPortableToInterpreterBridge());
2444 } else {
2445 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniTrampoline());
2446 method->SetEntryPointFromPortableCompiledCode(GetPortableToQuickBridge());
2447 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08002448 } else if (method->GetEntryPointFromPortableCompiledCode() != nullptr) {
2449 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
2450 have_portable_code = true;
2451 method->SetEntryPointFromQuickCompiledCode(GetQuickToPortableBridge());
2452 } else {
2453 DCHECK(method->GetEntryPointFromQuickCompiledCode() != nullptr);
2454 method->SetEntryPointFromPortableCompiledCode(GetPortableToQuickBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08002455 }
jeffhao26c0a1a2012-01-17 16:28:33 -08002456
Ian Rogers62d6c772013-02-27 08:32:07 -08002457 if (method->IsNative()) {
2458 // Unregistering restores the dlsym lookup stub.
2459 method->UnregisterNative(Thread::Current());
Andreas Gampe90546832014-03-12 18:07:19 -07002460
2461 if (enter_interpreter) {
2462 // We have a native method here without code. Then it should have either the GenericJni
2463 // trampoline as entrypoint (non-static), or the Resolution trampoline (static).
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +07002464 DCHECK(method->GetEntryPointFromQuickCompiledCode() == GetQuickResolutionTrampoline()
Andreas Gampe9a6a99a2014-03-14 07:52:20 -07002465 || method->GetEntryPointFromQuickCompiledCode() == GetQuickGenericJniTrampoline());
Andreas Gampe90546832014-03-12 18:07:19 -07002466 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07002467 }
Ian Rogersf3e98552013-03-20 15:49:49 -07002468
Ian Rogers62d6c772013-02-27 08:32:07 -08002469 // Allow instrumentation its chance to hijack code.
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002470 Runtime* runtime = Runtime::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002471 runtime->GetInstrumentation()->UpdateMethodsCode(method.Get(),
Ian Rogersef7d42f2014-01-06 12:55:46 -08002472 method->GetEntryPointFromQuickCompiledCode(),
2473 method->GetEntryPointFromPortableCompiledCode(),
2474 have_portable_code);
Brian Carlstrom92827a52011-10-10 15:50:01 -07002475}
2476
Brian Carlstromf615a612011-07-23 12:50:34 -07002477void ClassLinker::LoadClass(const DexFile& dex_file,
2478 const DexFile::ClassDef& dex_class_def,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002479 Handle<mirror::Class> klass,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002480 mirror::ClassLoader* class_loader) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002481 CHECK(klass.Get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002482 CHECK(klass->GetDexCache() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002483 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07002484 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -07002485 CHECK(descriptor != NULL);
2486
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002487 klass->SetClass(GetClassRoot(kJavaLangClass));
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -07002488 if (kUseBakerOrBrooksReadBarrier) {
2489 klass->AssertReadBarrierPointer();
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -08002490 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002491 uint32_t access_flags = dex_class_def.access_flags_;
Elliott Hughes582a7d12011-10-10 18:38:42 -07002492 // Make sure that none of our runtime-only flags are set.
Brian Carlstrom8e3fb142013-10-09 21:00:27 -07002493 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002494 klass->SetAccessFlags(access_flags);
2495 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08002496 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002497 klass->SetStatus(mirror::Class::kStatusIdx, NULL);
Brian Carlstrom934486c2011-07-12 23:42:50 -07002498
Ian Rogers8b2c0b92013-09-19 02:56:49 -07002499 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002500 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -07002501
Ian Rogers0571d352011-11-03 19:51:38 -07002502 const byte* class_data = dex_file.GetClassData(dex_class_def);
2503 if (class_data == NULL) {
2504 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07002505 }
Vladimir Markod3c5beb2014-04-11 16:32:51 +01002506
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002507 OatFile::OatClass oat_class;
2508 if (Runtime::Current()->IsStarted()
2509 && !Runtime::Current()->UseCompileTimeClassPath()
2510 && FindOatClass(dex_file, klass->GetDexClassDefIndex(), &oat_class)) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +01002511 LoadClassMembers(dex_file, class_data, klass, class_loader, &oat_class);
2512 } else {
2513 LoadClassMembers(dex_file, class_data, klass, class_loader, nullptr);
2514 }
2515}
2516
2517void ClassLinker::LoadClassMembers(const DexFile& dex_file,
2518 const byte* class_data,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002519 Handle<mirror::Class> klass,
Vladimir Markod3c5beb2014-04-11 16:32:51 +01002520 mirror::ClassLoader* class_loader,
2521 const OatFile::OatClass* oat_class) {
2522 // Load fields.
Ian Rogers0571d352011-11-03 19:51:38 -07002523 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers50b35e22012-10-04 10:09:15 -07002524 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07002525 if (it.NumStaticFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002526 mirror::ObjectArray<mirror::ArtField>* statics = AllocArtFieldArray(self, it.NumStaticFields());
2527 if (UNLIKELY(statics == NULL)) {
2528 CHECK(self->IsExceptionPending()); // OOME.
2529 return;
2530 }
2531 klass->SetSFields(statics);
Ian Rogers0571d352011-11-03 19:51:38 -07002532 }
2533 if (it.NumInstanceFields() != 0) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002534 mirror::ObjectArray<mirror::ArtField>* fields =
2535 AllocArtFieldArray(self, it.NumInstanceFields());
2536 if (UNLIKELY(fields == NULL)) {
2537 CHECK(self->IsExceptionPending()); // OOME.
2538 return;
2539 }
2540 klass->SetIFields(fields);
Ian Rogers0571d352011-11-03 19:51:38 -07002541 }
2542 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002543 StackHandleScope<1> hs(self);
2544 Handle<mirror::ArtField> sfield(hs.NewHandle(AllocArtField(self)));
2545 if (UNLIKELY(sfield.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002546 CHECK(self->IsExceptionPending()); // OOME.
2547 return;
2548 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002549 klass->SetStaticField(i, sfield.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07002550 LoadField(dex_file, it, klass, sfield);
2551 }
2552 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002553 StackHandleScope<1> hs(self);
2554 Handle<mirror::ArtField> ifield(hs.NewHandle(AllocArtField(self)));
2555 if (UNLIKELY(ifield.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002556 CHECK(self->IsExceptionPending()); // OOME.
2557 return;
2558 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002559 klass->SetInstanceField(i, ifield.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07002560 LoadField(dex_file, it, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -07002561 }
2562
Ian Rogers0571d352011-11-03 19:51:38 -07002563 // Load methods.
2564 if (it.NumDirectMethods() != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -07002565 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07002566 mirror::ObjectArray<mirror::ArtMethod>* directs =
2567 AllocArtMethodArray(self, it.NumDirectMethods());
2568 if (UNLIKELY(directs == NULL)) {
2569 CHECK(self->IsExceptionPending()); // OOME.
2570 return;
2571 }
2572 klass->SetDirectMethods(directs);
Brian Carlstrom934486c2011-07-12 23:42:50 -07002573 }
Ian Rogers0571d352011-11-03 19:51:38 -07002574 if (it.NumVirtualMethods() != 0) {
2575 // TODO: append direct methods to class object
Ian Rogersa436fde2013-08-27 23:34:06 -07002576 mirror::ObjectArray<mirror::ArtMethod>* virtuals =
2577 AllocArtMethodArray(self, it.NumVirtualMethods());
2578 if (UNLIKELY(virtuals == NULL)) {
2579 CHECK(self->IsExceptionPending()); // OOME.
2580 return;
2581 }
2582 klass->SetVirtualMethods(virtuals);
Brian Carlstrom934486c2011-07-12 23:42:50 -07002583 }
Ian Rogersfb6adba2012-03-04 21:51:51 -08002584 size_t class_def_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07002585 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002586 StackHandleScope<1> hs(self);
2587 Handle<mirror::ArtMethod> method(hs.NewHandle(LoadMethod(self, dex_file, it, klass)));
2588 if (UNLIKELY(method.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002589 CHECK(self->IsExceptionPending()); // OOME.
2590 return;
2591 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002592 klass->SetDirectMethod(i, method.Get());
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002593 LinkCode(method, oat_class, dex_file, it.GetMemberIndex(), class_def_method_index);
Ian Rogersfb6adba2012-03-04 21:51:51 -08002594 method->SetMethodIndex(class_def_method_index);
2595 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07002596 }
2597 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002598 StackHandleScope<1> hs(self);
2599 Handle<mirror::ArtMethod> method(hs.NewHandle(LoadMethod(self, dex_file, it, klass)));
2600 if (UNLIKELY(method.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07002601 CHECK(self->IsExceptionPending()); // OOME.
2602 return;
2603 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002604 klass->SetVirtualMethod(i, method.Get());
Ian Rogersfb6adba2012-03-04 21:51:51 -08002605 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Nicolas Geoffray9c290012014-07-22 10:48:00 +01002606 LinkCode(method, oat_class, dex_file, it.GetMemberIndex(), class_def_method_index);
Ian Rogersfb6adba2012-03-04 21:51:51 -08002607 class_def_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -07002608 }
2609 DCHECK(!it.HasNext());
Brian Carlstrom934486c2011-07-12 23:42:50 -07002610}
2611
Elliott Hughes1bac54f2012-03-16 12:48:31 -07002612void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002613 Handle<mirror::Class> klass, Handle<mirror::ArtField> dst) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002614 uint32_t field_idx = it.GetMemberIndex();
2615 dst->SetDexFieldIndex(field_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002616 dst->SetDeclaringClass(klass.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07002617 dst->SetAccessFlags(it.GetMemberAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07002618}
2619
Brian Carlstromea46f952013-07-30 01:26:50 -07002620mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
Ian Rogersa436fde2013-08-27 23:34:06 -07002621 const ClassDataItemIterator& it,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002622 Handle<mirror::Class> klass) {
Ian Rogers19846512012-02-24 11:42:47 -08002623 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08002624 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002625 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002626
Brian Carlstromea46f952013-07-30 01:26:50 -07002627 mirror::ArtMethod* dst = AllocArtMethod(self);
Ian Rogersa436fde2013-08-27 23:34:06 -07002628 if (UNLIKELY(dst == NULL)) {
2629 CHECK(self->IsExceptionPending()); // OOME.
2630 return NULL;
2631 }
Brian Carlstromea46f952013-07-30 01:26:50 -07002632 DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002633
Ian Rogers50b35e22012-10-04 10:09:15 -07002634 const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07002635 dst->SetDexMethodIndex(dex_method_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002636 dst->SetDeclaringClass(klass.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07002637 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Brian Carlstrom934486c2011-07-12 23:42:50 -07002638
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002639 dst->SetDexCacheStrings(klass->GetDexCache()->GetStrings());
Ian Rogers19846512012-02-24 11:42:47 -08002640 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002641 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002642
Ian Rogers241b5de2013-10-09 17:58:57 -07002643 uint32_t access_flags = it.GetMemberAccessFlags();
2644
Ian Rogersdfb325e2013-10-30 01:00:44 -07002645 if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07002646 // Set finalizable flag on declaring class.
Ian Rogersdfb325e2013-10-30 01:00:44 -07002647 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
2648 // Void return type.
Ian Rogerscb6b0f32014-08-12 02:30:58 -07002649 if (klass->GetClassLoader() != NULL) { // All non-boot finalizer methods are flagged.
Ian Rogersdfb325e2013-10-30 01:00:44 -07002650 klass->SetFinalizable();
2651 } else {
Ian Rogerscb6b0f32014-08-12 02:30:58 -07002652 std::string temp;
2653 const char* klass_descriptor = klass->GetDescriptor(&temp);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002654 // The Enum class declares a "final" finalize() method to prevent subclasses from
2655 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
2656 // subclasses, so we exclude it here.
2657 // We also want to avoid setting the flag on Object, where we know that finalize() is
2658 // empty.
Ian Rogerscb6b0f32014-08-12 02:30:58 -07002659 if (strcmp(klass_descriptor, "Ljava/lang/Object;") != 0 &&
2660 strcmp(klass_descriptor, "Ljava/lang/Enum;") != 0) {
Ian Rogers241b5de2013-10-09 17:58:57 -07002661 klass->SetFinalizable();
Ian Rogers241b5de2013-10-09 17:58:57 -07002662 }
2663 }
2664 }
2665 } else if (method_name[0] == '<') {
2666 // Fix broken access flags for initializers. Bug 11157540.
Ian Rogersdfb325e2013-10-30 01:00:44 -07002667 bool is_init = (strcmp("<init>", method_name) == 0);
2668 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
Ian Rogers241b5de2013-10-09 17:58:57 -07002669 if (UNLIKELY(!is_init && !is_clinit)) {
2670 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
2671 } else {
2672 if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
2673 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002674 << PrettyDescriptor(klass.Get()) << " in dex file " << dex_file.GetLocation();
Ian Rogers241b5de2013-10-09 17:58:57 -07002675 access_flags |= kAccConstructor;
2676 }
2677 }
2678 }
2679 dst->SetAccessFlags(access_flags);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002680
Ian Rogers50b35e22012-10-04 10:09:15 -07002681 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002682 return dst;
Brian Carlstrom934486c2011-07-12 23:42:50 -07002683}
2684
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002685void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Ian Rogers50b35e22012-10-04 10:09:15 -07002686 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002687 StackHandleScope<1> hs(self);
2688 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache(self, dex_file)));
2689 CHECK(dex_cache.Get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002690 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07002691}
2692
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002693void ClassLinker::AppendToBootClassPath(const DexFile& dex_file,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002694 Handle<mirror::DexCache> dex_cache) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002695 CHECK(dex_cache.Get() != NULL) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002696 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07002697 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002698}
2699
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002700bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002701 dex_lock_.AssertSharedHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002702 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002703 mirror::DexCache* dex_cache = GetDexCache(i);
2704 if (dex_cache->GetDexFile() == &dex_file) {
Ian Rogers19846512012-02-24 11:42:47 -08002705 return true;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002706 }
2707 }
2708 return false;
Brian Carlstroma663ea52011-08-19 23:33:41 -07002709}
2710
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002711bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002712 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstrom06918512011-10-16 23:39:12 -07002713 return IsDexFileRegisteredLocked(dex_file);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002714}
2715
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002716void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002717 Handle<mirror::DexCache> dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002718 dex_lock_.AssertExclusiveHeld(Thread::Current());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002719 CHECK(dex_cache.Get() != NULL) << dex_file.GetLocation();
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -07002720 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()))
2721 << dex_cache->GetLocation()->ToModifiedUtf8() << " " << dex_file.GetLocation();
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07002722 dex_caches_.push_back(GcRoot<mirror::DexCache>(dex_cache.Get()));
Mathieu Chartier66f19252012-09-18 08:57:04 -07002723 dex_cache->SetDexFile(&dex_file);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002724 if (log_new_dex_caches_roots_) {
2725 // TODO: This is not safe if we can remove dex caches.
2726 new_dex_cache_roots_.push_back(dex_caches_.size() - 1);
2727 }
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002728}
2729
Brian Carlstromaded5f72011-10-07 17:15:04 -07002730void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
Ian Rogers1f539342012-10-03 21:09:42 -07002731 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002732 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002733 ReaderMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002734 if (IsDexFileRegisteredLocked(dex_file)) {
2735 return;
2736 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002737 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002738 // Don't alloc while holding the lock, since allocation may need to
2739 // suspend all threads and another thread may need the dex_lock_ to
2740 // get to a suspend point.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002741 StackHandleScope<1> hs(self);
2742 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache(self, dex_file)));
2743 CHECK(dex_cache.Get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002744 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002745 WriterMutexLock mu(self, dex_lock_);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07002746 if (IsDexFileRegisteredLocked(dex_file)) {
2747 return;
2748 }
2749 RegisterDexFileLocked(dex_file, dex_cache);
2750 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002751}
2752
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002753void ClassLinker::RegisterDexFile(const DexFile& dex_file,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002754 Handle<mirror::DexCache> dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002755 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002756 RegisterDexFileLocked(dex_file, dex_cache);
2757}
2758
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002759mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002760 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002761 // Search assuming unique-ness of dex file.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002762 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002763 mirror::DexCache* dex_cache = GetDexCache(i);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002764 if (dex_cache->GetDexFile() == &dex_file) {
2765 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002766 }
2767 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002768 // Search matching by location name.
2769 std::string location(dex_file.GetLocation());
2770 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002771 mirror::DexCache* dex_cache = GetDexCache(i);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002772 if (dex_cache->GetDexFile()->GetLocation() == location) {
2773 return dex_cache;
2774 }
2775 }
2776 // Failure, dump diagnostic and abort.
2777 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002778 mirror::DexCache* dex_cache = GetDexCache(i);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002779 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
2780 }
2781 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002782 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002783}
2784
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002785void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07002786 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers19846512012-02-24 11:42:47 -08002787 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002788 mirror::DexCache* dex_cache = GetDexCache(i);
2789 dex_cache->Fixup(resolution_method);
Ian Rogers19846512012-02-24 11:42:47 -08002790 }
2791}
2792
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002793mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002794 mirror::Class* klass = AllocClass(self, mirror::Class::PrimitiveClassSize());
Ian Rogersa436fde2013-08-27 23:34:06 -07002795 if (UNLIKELY(klass == NULL)) {
2796 return NULL;
2797 }
2798 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002799}
2800
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002801mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class,
2802 Primitive::Type type) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002803 CHECK(primitive_class != NULL);
Ian Rogers1f539342012-10-03 21:09:42 -07002804 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002805 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002806 StackHandleScope<1> hs(self);
2807 Handle<mirror::Class> h_class(hs.NewHandle(primitive_class));
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07002808 ObjectLock<mirror::Class> lock(self, h_class);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002809 primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002810 primitive_class->SetPrimitiveType(type);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002811 primitive_class->SetStatus(mirror::Class::kStatusInitialized, self);
2812 const char* descriptor = Primitive::Descriptor(type);
2813 mirror::Class* existing = InsertClass(descriptor, primitive_class, Hash(descriptor));
Ian Rogersc8982582012-09-07 16:53:25 -07002814 CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002815 return primitive_class;
Carl Shapiro565f5072011-07-10 13:39:43 -07002816}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002817
Brian Carlstrombe977852011-07-19 14:54:54 -07002818// Create an array class (i.e. the class object for the array, not the
2819// array itself). "descriptor" looks like "[C" or "[[[[B" or
2820// "[Ljava/lang/String;".
2821//
2822// If "descriptor" refers to an array of primitives, look up the
2823// primitive type's internally-generated class object.
2824//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002825// "class_loader" is the class loader of the class that's referring to
2826// us. It's used to ensure that we're looking for the element type in
2827// the right context. It does NOT become the class loader for the
2828// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07002829//
2830// Returns NULL with an exception raised on failure.
Ian Rogers98379392014-02-24 16:53:16 -08002831mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07002832 Handle<mirror::ClassLoader> class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07002833 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002834 CHECK_EQ('[', descriptor[0]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002835 StackHandleScope<2> hs(self);
2836 Handle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1, class_loader)));
2837 if (component_type.Get() == nullptr) {
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002838 DCHECK(self->IsExceptionPending());
Andreas Gampedc13d7d2014-07-23 20:18:36 -07002839 // We need to accept erroneous classes as component types.
2840 component_type.Assign(LookupClass(descriptor + 1, class_loader.Get()));
2841 if (component_type.Get() == nullptr) {
2842 DCHECK(self->IsExceptionPending());
2843 return nullptr;
2844 } else {
2845 self->ClearException();
2846 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002847 }
Ian Rogers2d10b202014-05-12 19:15:18 -07002848 if (UNLIKELY(component_type->IsPrimitiveVoid())) {
2849 ThrowNoClassDefFoundError("Attempt to create array of void primitive type");
2850 return nullptr;
2851 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002852 // See if the component type is already loaded. Array classes are
2853 // always associated with the class loader of their underlying
2854 // element type -- an array of Strings goes with the loader for
2855 // java/lang/String -- so we need to look for it there. (The
2856 // caller should have checked for the existence of the class
2857 // before calling here, but they did so with *their* class loader,
2858 // not the component type's loader.)
2859 //
2860 // If we find it, the caller adds "loader" to the class' initiating
2861 // loader list, which should prevent us from going through this again.
2862 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002863 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002864 // are the same, because our caller (FindClass) just did the
2865 // lookup. (Even if we get this wrong we still have correct behavior,
2866 // because we effectively do this lookup again when we add the new
2867 // class to the hash table --- necessary because of possible races with
2868 // other threads.)
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002869 if (class_loader.Get() != component_type->GetClassLoader()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002870 mirror::Class* new_class = LookupClass(descriptor, component_type->GetClassLoader());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002871 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002872 return new_class;
2873 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002874 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002875
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002876 // Fill out the fields in the Class.
2877 //
2878 // It is possible to execute some methods against arrays, because
2879 // all arrays are subclasses of java_lang_Object_, so we need to set
2880 // up a vtable. We can just point at the one in java_lang_Object_.
2881 //
2882 // Array classes are simple enough that we don't need to do a full
2883 // link step.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002884 auto new_class = hs.NewHandle<mirror::Class>(nullptr);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002885 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002886 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002887 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002888 new_class.Assign(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002889 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002890 new_class.Assign(GetClassRoot(kObjectArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002891 } else if (strcmp(descriptor, class_roots_descriptors_[kJavaLangStringArrayClass]) == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002892 new_class.Assign(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002893 } else if (strcmp(descriptor,
2894 class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002895 new_class.Assign(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002896 } else if (strcmp(descriptor,
2897 class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002898 new_class.Assign(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002899 } else if (strcmp(descriptor, "[C") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002900 new_class.Assign(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002901 } else if (strcmp(descriptor, "[I") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002902 new_class.Assign(GetClassRoot(kIntArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002903 }
2904 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002905 if (new_class.Get() == nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002906 new_class.Assign(AllocClass(self, mirror::Array::ClassSize()));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002907 if (new_class.Get() == nullptr) {
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002908 return nullptr;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002909 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002910 new_class->SetComponentType(component_type.Get());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002911 }
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07002912 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002913 DCHECK(new_class->GetComponentType() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002914 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002915 new_class->SetSuperClass(java_lang_Object);
2916 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002917 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002918 new_class->SetClassLoader(component_type->GetClassLoader());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002919 new_class->SetStatus(mirror::Class::kStatusLoaded, self);
2920 new_class->PopulateEmbeddedImtAndVTable();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002921 new_class->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07002922 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07002923 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002924
2925
2926 // All arrays have java/lang/Cloneable and java/io/Serializable as
2927 // interfaces. We need to set that up here, so that stuff like
2928 // "instanceof" works right.
2929 //
2930 // Note: The GC could run during the call to FindSystemClass,
2931 // so we need to make sure the class object is GC-valid while we're in
2932 // there. Do this by clearing the interface list so the GC will just
2933 // think that the entries are null.
2934
2935
2936 // Use the single, global copies of "interfaces" and "iftable"
2937 // (remember not to free them for arrays).
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002938 {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07002939 mirror::IfTable* array_iftable = array_iftable_.Read();
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07002940 CHECK(array_iftable != nullptr);
2941 new_class->SetIfTable(array_iftable);
2942 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002943
Elliott Hughes00626c22013-06-14 15:04:14 -07002944 // Inherit access flags from the component type.
2945 int access_flags = new_class->GetComponentType()->GetAccessFlags();
2946 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
2947 access_flags &= kAccJavaFlagsMask;
2948 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002949 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07002950 access_flags |= kAccAbstract | kAccFinal;
2951 access_flags &= ~kAccInterface;
2952
2953 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002954
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002955 mirror::Class* existing = InsertClass(descriptor, new_class.Get(), Hash(descriptor));
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08002956 if (existing == nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002957 return new_class.Get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002958 }
2959 // Another thread must have loaded the class after we
2960 // started but before we finished. Abandon what we've
2961 // done.
2962 //
2963 // (Yes, this happens.)
2964
Brian Carlstrom07bb8552012-01-18 22:10:50 -08002965 return existing;
Brian Carlstroma331b3c2011-07-18 17:47:56 -07002966}
2967
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002968mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Ian Rogers62f05122014-03-21 11:21:29 -07002969 switch (type) {
2970 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002971 return GetClassRoot(kPrimitiveByte);
Ian Rogers62f05122014-03-21 11:21:29 -07002972 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002973 return GetClassRoot(kPrimitiveChar);
Ian Rogers62f05122014-03-21 11:21:29 -07002974 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002975 return GetClassRoot(kPrimitiveDouble);
Ian Rogers62f05122014-03-21 11:21:29 -07002976 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002977 return GetClassRoot(kPrimitiveFloat);
Ian Rogers62f05122014-03-21 11:21:29 -07002978 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002979 return GetClassRoot(kPrimitiveInt);
Ian Rogers62f05122014-03-21 11:21:29 -07002980 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002981 return GetClassRoot(kPrimitiveLong);
Ian Rogers62f05122014-03-21 11:21:29 -07002982 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002983 return GetClassRoot(kPrimitiveShort);
Ian Rogers62f05122014-03-21 11:21:29 -07002984 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002985 return GetClassRoot(kPrimitiveBoolean);
Ian Rogers62f05122014-03-21 11:21:29 -07002986 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07002987 return GetClassRoot(kPrimitiveVoid);
Ian Rogers62f05122014-03-21 11:21:29 -07002988 default:
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002989 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07002990 }
Elliott Hughesbd935992011-08-22 11:59:34 -07002991 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002992 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Elliott Hughesbd935992011-08-22 11:59:34 -07002993 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002994}
2995
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002996mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass,
2997 size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002998 if (VLOG_IS_ON(class_linker)) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002999 mirror::DexCache* dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08003000 std::string source;
3001 if (dex_cache != NULL) {
3002 source += " from ";
3003 source += dex_cache->GetLocation()->ToModifiedUtf8();
3004 }
3005 LOG(INFO) << "Loaded class " << descriptor << source;
3006 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003007 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers1d54e732013-05-02 21:10:01 -07003008 mirror::Class* existing =
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003009 LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
Brian Carlstrom07bb8552012-01-18 22:10:50 -08003010 if (existing != NULL) {
3011 return existing;
Ian Rogers5d76c432011-10-31 21:42:49 -07003012 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003013 if (kIsDebugBuild && !klass->IsTemp() && klass->GetClassLoader() == NULL &&
3014 dex_cache_image_class_lookup_required_) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003015 // Check a class loaded with the system class loader matches one in the image if the class
3016 // is in the image.
3017 existing = LookupClassFromImage(descriptor);
3018 if (existing != NULL) {
3019 CHECK(klass == existing);
3020 }
3021 }
Mathieu Chartier4e305412014-02-19 10:54:44 -08003022 VerifyObject(klass);
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003023 class_table_.insert(std::make_pair(hash, GcRoot<mirror::Class>(klass)));
Mathieu Chartier893263b2014-03-04 11:07:42 -08003024 if (log_new_class_table_roots_) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003025 new_class_roots_.push_back(std::make_pair(hash, GcRoot<mirror::Class>(klass)));
Mathieu Chartier893263b2014-03-04 11:07:42 -08003026 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08003027 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003028}
3029
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003030mirror::Class* ClassLinker::UpdateClass(const char* descriptor, mirror::Class* klass,
3031 size_t hash) {
3032 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3033 mirror::Class* existing =
3034 LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
3035
3036 if (existing == nullptr) {
3037 CHECK(klass->IsProxyClass());
3038 return nullptr;
3039 }
3040
3041 CHECK_NE(existing, klass) << descriptor;
3042 CHECK(!existing->IsResolved()) << descriptor;
3043 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusResolving) << descriptor;
3044
3045 for (auto it = class_table_.lower_bound(hash), end = class_table_.end(); it != end && it->first == hash;
3046 ++it) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003047 mirror::Class* klass = it->second.Read();
Hiroshi Yamauchi0fbd6e62014-07-17 16:16:31 -07003048 if (klass == existing) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003049 class_table_.erase(it);
3050 break;
3051 }
3052 }
3053
3054 CHECK(!klass->IsTemp()) << descriptor;
3055 if (kIsDebugBuild && klass->GetClassLoader() == nullptr &&
3056 dex_cache_image_class_lookup_required_) {
3057 // Check a class loaded with the system class loader matches one in the image if the class
3058 // is in the image.
3059 existing = LookupClassFromImage(descriptor);
3060 if (existing != nullptr) {
3061 CHECK(klass == existing) << descriptor;
3062 }
3063 }
3064 VerifyObject(klass);
3065
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003066 class_table_.insert(std::make_pair(hash, GcRoot<mirror::Class>(klass)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003067 if (log_new_class_table_roots_) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003068 new_class_roots_.push_back(std::make_pair(hash, GcRoot<mirror::Class>(klass)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003069 }
3070
3071 return existing;
3072}
3073
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003074bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08003075 size_t hash = Hash(descriptor);
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003076 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Brian Carlstromf3632832014-05-20 15:36:53 -07003077 for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
3078 it != end && it->first == hash;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003079 ++it) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003080 mirror::Class* klass = it->second.Read();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003081 if (klass->GetClassLoader() == class_loader && klass->DescriptorEquals(descriptor)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003082 class_table_.erase(it);
Brian Carlstromae826982011-11-09 01:33:42 -08003083 return true;
3084 }
3085 }
3086 return false;
3087}
3088
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003089mirror::Class* ClassLinker::LookupClass(const char* descriptor,
3090 const mirror::ClassLoader* class_loader) {
Elliott Hughesc3b77c72011-12-15 20:56:48 -08003091 size_t hash = Hash(descriptor);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003092 {
3093 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3094 mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
3095 if (result != NULL) {
3096 return result;
3097 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07003098 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003099 if (class_loader != NULL || !dex_cache_image_class_lookup_required_) {
3100 return NULL;
3101 } else {
3102 // Lookup failed but need to search dex_caches_.
3103 mirror::Class* result = LookupClassFromImage(descriptor);
3104 if (result != NULL) {
3105 InsertClass(descriptor, result, hash);
3106 } else {
3107 // Searching the image dex files/caches failed, we don't want to get into this situation
3108 // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image
3109 // classes into the class table.
3110 const int32_t kMaxFailedDexCacheLookups = 1000;
3111 if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) {
3112 MoveImageClassesToClassTable();
3113 }
3114 }
3115 return result;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003116 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08003117}
3118
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003119mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor,
3120 const mirror::ClassLoader* class_loader,
3121 size_t hash) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003122 auto end = class_table_.end();
3123 for (auto it = class_table_.lower_bound(hash); it != end && it->first == hash; ++it) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003124 mirror::Class* klass = it->second.Read();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003125 if (klass->GetClassLoader() == class_loader && klass->DescriptorEquals(descriptor)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003126 if (kIsDebugBuild) {
3127 // Check for duplicates in the table.
3128 for (++it; it != end && it->first == hash; ++it) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003129 mirror::Class* klass2 = it->second.Read();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003130 CHECK(!(klass2->GetClassLoader() == class_loader &&
3131 klass2->DescriptorEquals(descriptor)))
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003132 << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
3133 << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003134 }
Brian Carlstrom07bb8552012-01-18 22:10:50 -08003135 }
Ian Rogers5d76c432011-10-31 21:42:49 -07003136 return klass;
3137 }
3138 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003139 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003140}
3141
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003142static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches()
3143 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
3144 gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
3145 CHECK(image != NULL);
3146 mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
3147 return root->AsObjectArray<mirror::DexCache>();
3148}
3149
3150void ClassLinker::MoveImageClassesToClassTable() {
3151 Thread* self = Thread::Current();
3152 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
3153 if (!dex_cache_image_class_lookup_required_) {
3154 return; // All dex cache classes are already in the class table.
3155 }
3156 const char* old_no_suspend_cause =
3157 self->StartAssertNoThreadSuspension("Moving image classes to class table");
3158 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
Ian Rogerscb6b0f32014-08-12 02:30:58 -07003159 std::string temp;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003160 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
3161 mirror::DexCache* dex_cache = dex_caches->Get(i);
3162 mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes();
3163 for (int32_t j = 0; j < types->GetLength(); j++) {
3164 mirror::Class* klass = types->Get(j);
3165 if (klass != NULL) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003166 DCHECK(klass->GetClassLoader() == NULL);
Ian Rogerscb6b0f32014-08-12 02:30:58 -07003167 const char* descriptor = klass->GetDescriptor(&temp);
3168 size_t hash = Hash(descriptor);
3169 mirror::Class* existing = LookupClassFromTableLocked(descriptor, NULL, hash);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003170 if (existing != NULL) {
3171 CHECK(existing == klass) << PrettyClassAndClassLoader(existing) << " != "
3172 << PrettyClassAndClassLoader(klass);
3173 } else {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003174 class_table_.insert(std::make_pair(hash, GcRoot<mirror::Class>(klass)));
Mathieu Chartier893263b2014-03-04 11:07:42 -08003175 if (log_new_class_table_roots_) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003176 new_class_roots_.push_back(std::make_pair(hash, GcRoot<mirror::Class>(klass)));
Mathieu Chartier893263b2014-03-04 11:07:42 -08003177 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003178 }
3179 }
Elliott Hughes6fa602d2011-12-02 17:54:25 -08003180 }
3181 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003182 dex_cache_image_class_lookup_required_ = false;
3183 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
3184}
3185
3186mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
3187 Thread* self = Thread::Current();
3188 const char* old_no_suspend_cause =
3189 self->StartAssertNoThreadSuspension("Image class lookup");
3190 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
3191 for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
3192 mirror::DexCache* dex_cache = dex_caches->Get(i);
3193 const DexFile* dex_file = dex_cache->GetDexFile();
Vladimir Marko801a8112014-01-06 14:28:16 +00003194 // Try binary searching the string/type index.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003195 const DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
3196 if (string_id != NULL) {
3197 const DexFile::TypeId* type_id =
3198 dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
3199 if (type_id != NULL) {
3200 uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id);
3201 mirror::Class* klass = dex_cache->GetResolvedType(type_idx);
3202 if (klass != NULL) {
3203 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
3204 return klass;
3205 }
3206 }
3207 }
3208 }
3209 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
3210 return NULL;
3211}
3212
3213void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) {
3214 result.clear();
3215 if (dex_cache_image_class_lookup_required_) {
3216 MoveImageClassesToClassTable();
3217 }
3218 size_t hash = Hash(descriptor);
3219 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003220 for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
Mathieu Chartier02e25112013-08-14 16:14:24 -07003221 it != end && it->first == hash; ++it) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07003222 mirror::Class* klass = it->second.Read();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003223 if (klass->DescriptorEquals(descriptor)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003224 result.push_back(klass);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08003225 }
3226 }
3227}
3228
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003229void ClassLinker::VerifyClass(Handle<mirror::Class> klass) {
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08003230 // TODO: assert that the monitor on the Class is held
Ian Rogers1f539342012-10-03 21:09:42 -07003231 Thread* self = Thread::Current();
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003232 ObjectLock<mirror::Class> lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08003233
Ian Rogers9ffb0392012-09-10 11:56:50 -07003234 // Don't attempt to re-verify if already sufficiently verified.
3235 if (klass->IsVerified() ||
3236 (klass->IsCompileTimeVerified() && Runtime::Current()->IsCompiler())) {
jeffhao98eacac2011-09-14 16:11:53 -07003237 return;
3238 }
3239
Ian Rogers9ffb0392012-09-10 11:56:50 -07003240 // The class might already be erroneous, for example at compile time if we attempted to verify
3241 // this class as a parent to another.
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08003242 if (klass->IsErroneous()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003243 ThrowEarlierClassFailure(klass.Get());
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08003244 return;
3245 }
3246
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003247 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003248 klass->SetStatus(mirror::Class::kStatusVerifying, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07003249 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003250 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003251 << PrettyClass(klass.Get());
Ian Rogers9ffb0392012-09-10 11:56:50 -07003252 CHECK(!Runtime::Current()->IsCompiler());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003253 klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime, self);
Ian Rogers9ffb0392012-09-10 11:56:50 -07003254 }
jeffhao98eacac2011-09-14 16:11:53 -07003255
Jeff Hao4a200f52014-04-01 14:58:49 -07003256 // Skip verification if disabled.
3257 if (!Runtime::Current()->IsVerificationEnabled()) {
3258 klass->SetStatus(mirror::Class::kStatusVerified, self);
3259 return;
3260 }
3261
Ian Rogers9ffb0392012-09-10 11:56:50 -07003262 // Verify super class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003263 StackHandleScope<2> hs(self);
3264 Handle<mirror::Class> super(hs.NewHandle(klass->GetSuperClass()));
3265 if (super.Get() != NULL) {
Ian Rogers9ffb0392012-09-10 11:56:50 -07003266 // Acquire lock to prevent races on verifying the super class.
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003267 ObjectLock<mirror::Class> lock(self, super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08003268
3269 if (!super->IsVerified() && !super->IsErroneous()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003270 VerifyClass(super);
Ian Rogers1c5eb702012-02-01 09:18:34 -08003271 }
jeffhaof1e6b7c2012-06-05 18:33:30 -07003272 if (!super->IsCompileTimeVerified()) {
Brian Carlstromf3632832014-05-20 15:36:53 -07003273 std::string error_msg(
3274 StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
3275 PrettyDescriptor(klass.Get()).c_str(),
3276 PrettyDescriptor(super.Get()).c_str()));
Ian Rogers1c5eb702012-02-01 09:18:34 -08003277 LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003278 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException(nullptr)));
3279 if (cause.Get() != nullptr) {
Ian Rogers1c5eb702012-02-01 09:18:34 -08003280 self->ClearException();
3281 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003282 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
3283 if (cause.Get() != nullptr) {
3284 self->GetException(nullptr)->SetCause(cause.Get());
Ian Rogers1c5eb702012-02-01 09:18:34 -08003285 }
Jeff Hao22cb09b2013-12-12 14:29:15 -08003286 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex());
Vladimir Marko2b5eaa22013-12-13 13:59:30 +00003287 if (Runtime::Current()->IsCompiler()) {
3288 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref);
3289 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003290 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers1c5eb702012-02-01 09:18:34 -08003291 return;
3292 }
3293 }
3294
Elliott Hughes634eb2e2012-03-22 16:06:28 -07003295 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07003296 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003297 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003298 bool preverified = VerifyClassUsingOatFile(dex_file, klass.Get(), oat_file_class_status);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003299 if (oat_file_class_status == mirror::Class::kStatusError) {
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003300 VLOG(class_linker) << "Skipping runtime verification of erroneous class "
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003301 << PrettyDescriptor(klass.Get()) << " in "
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003302 << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003303 ThrowVerifyError(klass.Get(), "Rejecting class %s because it failed compile-time verification",
3304 PrettyDescriptor(klass.Get()).c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003305 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhaoec014232012-09-05 10:42:25 -07003306 return;
3307 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02003308 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
Ian Rogers62d6c772013-02-27 08:32:07 -08003309 std::string error_msg;
jeffhaof1e6b7c2012-06-05 18:33:30 -07003310 if (!preverified) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003311 verifier_failure = verifier::MethodVerifier::VerifyClass(klass.Get(),
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003312 Runtime::Current()->IsCompiler(),
3313 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07003314 }
3315 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07003316 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003317 VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass.Get())
Ian Rogers529781d2012-07-23 17:24:29 -07003318 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
3319 << " because: " << error_msg;
3320 }
Ian Rogers1f539342012-10-03 21:09:42 -07003321 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07003322 // Make sure all classes referenced by catch blocks are resolved.
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003323 ResolveClassExceptionHandlerTypes(dex_file, klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07003324 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003325 // Even though there were no verifier failures we need to respect whether the super-class
3326 // was verified or requiring runtime reverification.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003327 if (super.Get() == NULL || super->IsVerified()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003328 klass->SetStatus(mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003329 } else {
3330 CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003331 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07003332 // Pretend a soft failure occured so that we don't consider the class verified below.
3333 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003334 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07003335 } else {
3336 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
3337 // Soft failures at compile time should be retried at runtime. Soft
3338 // failures at runtime will be handled by slow paths in the generated
3339 // code. Set status accordingly.
3340 if (Runtime::Current()->IsCompiler()) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003341 klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07003342 } else {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003343 klass->SetStatus(mirror::Class::kStatusVerified, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07003344 }
3345 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07003346 } else {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003347 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(klass.Get())
Ian Rogers1c5eb702012-02-01 09:18:34 -08003348 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
3349 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003350 self->AssertNoPendingException();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003351 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003352 klass->SetStatus(mirror::Class::kStatusError, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07003353 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02003354 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07003355 // Class is verified so we don't need to do any access check on its methods.
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02003356 // Let the interpreter know it by setting the kAccPreverified flag onto each
3357 // method.
3358 // Note: we're going here during compilation and at runtime. When we set the
3359 // kAccPreverified flag when compiling image classes, the flag is recorded
3360 // in the image and is set when loading the image.
3361 klass->SetPreverifiedFlagOnAllMethods();
3362 }
jeffhao98eacac2011-09-14 16:11:53 -07003363}
3364
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003365bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
3366 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07003367 // If we're compiling, we can only verify the class using the oat file if
3368 // we are not compiling the image or if the class we're verifying is not part of
3369 // the app. In other words, we will only check for preverification of bootclasspath
3370 // classes.
3371 if (Runtime::Current()->IsCompiler()) {
3372 // Are we compiling the bootclasspath?
3373 if (!Runtime::Current()->UseCompileTimeClassPath()) {
3374 return false;
3375 }
3376 // We are compiling an app (not the image).
3377
3378 // Is this an app class? (I.e. not a bootclasspath class)
3379 if (klass->GetClassLoader() != NULL) {
3380 return false;
3381 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003382 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07003383
Brian Carlstrom5b332c82012-02-01 15:02:31 -08003384 const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07003385 // Make this work with gtests, which do not set up the image properly.
3386 // TODO: we should clean up gtests to set up the image path properly.
Nicolas Geoffray9c290012014-07-22 10:48:00 +01003387 if (Runtime::Current()->IsCompiler() || (oat_file == NULL)) {
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07003388 return false;
3389 }
3390
Brian Carlstrom5b332c82012-02-01 15:02:31 -08003391 CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07003392 uint dex_location_checksum = dex_file.GetLocationChecksum();
Ian Rogers8d31bbd2013-10-13 10:44:14 -07003393 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -07003394 &dex_location_checksum);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08003395 CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003396 uint16_t class_def_index = klass->GetDexClassDefIndex();
Vladimir Markod3c5beb2014-04-11 16:32:51 +01003397 oat_file_class_status = oat_dex_file->GetOatClass(class_def_index).GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003398 if (oat_file_class_status == mirror::Class::kStatusVerified ||
3399 oat_file_class_status == mirror::Class::kStatusInitialized) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07003400 return true;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003401 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003402 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07003403 // Compile time verification failed with a soft error. Compile time verification can fail
3404 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08003405 // class ... {
3406 // Foo x;
3407 // .... () {
3408 // if (...) {
3409 // v1 gets assigned a type of resolved class Foo
3410 // } else {
3411 // v1 gets assigned a type of unresolved class Bar
3412 // }
3413 // iput x = v1
3414 // } }
3415 // when we merge v1 following the if-the-else it results in Conflict
3416 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
3417 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
3418 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
3419 // at compile time).
3420 return false;
3421 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003422 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07003423 // Compile time verification failed with a hard error. This is caused by invalid instructions
3424 // in the class. These errors are unrecoverable.
3425 return false;
3426 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003427 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08003428 // Status is uninitialized if we couldn't determine the status at compile time, for example,
3429 // not loading the class.
3430 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
3431 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003432 return false;
3433 }
Ian Rogerscb6b0f32014-08-12 02:30:58 -07003434 std::string temp;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07003435 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
Ian Rogersfc0e94b2013-09-23 23:51:32 -07003436 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " "
Ian Rogerscb6b0f32014-08-12 02:30:58 -07003437 << klass->GetDescriptor(&temp);
Brian Carlstrom5b332c82012-02-01 15:02:31 -08003438
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003439 return false;
3440}
3441
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003442void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003443 Handle<mirror::Class> klass) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003444 for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
3445 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
3446 }
3447 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
3448 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i));
3449 }
3450}
3451
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003452void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
Brian Carlstromea46f952013-07-30 01:26:50 -07003453 mirror::ArtMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003454 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
3455 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
3456 if (code_item == NULL) {
3457 return; // native or abstract method
3458 }
3459 if (code_item->tries_size_ == 0) {
3460 return; // nothing to process
3461 }
3462 const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
3463 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
3464 ClassLinker* linker = Runtime::Current()->GetClassLinker();
3465 for (uint32_t idx = 0; idx < handlers_size; idx++) {
3466 CatchHandlerIterator iterator(handlers_ptr);
3467 for (; iterator.HasNext(); iterator.Next()) {
3468 // Ensure exception types are resolved so that they don't need resolution to be delivered,
3469 // unresolved exception types will be ignored by exception delivery
3470 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003471 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08003472 if (exception_type == NULL) {
3473 DCHECK(Thread::Current()->IsExceptionPending());
3474 Thread::Current()->ClearException();
3475 }
3476 }
3477 }
3478 handlers_ptr = iterator.EndDataPointer();
3479 }
3480}
3481
Brian Carlstromea46f952013-07-30 01:26:50 -07003482static void CheckProxyConstructor(mirror::ArtMethod* constructor);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003483static void CheckProxyMethod(Handle<mirror::ArtMethod> method,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003484 Handle<mirror::ArtMethod> prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08003485
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -07003486mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name,
Mathieu Chartier590fee92013-09-13 13:46:47 -07003487 jobjectArray interfaces, jobject loader,
3488 jobjectArray methods, jobjectArray throws) {
3489 Thread* self = soa.Self();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003490 StackHandleScope<8> hs(self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003491 Handle<mirror::Class> klass(hs.NewHandle(
3492 AllocClass(self, GetClassRoot(kJavaLangClass), sizeof(mirror::Class))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003493 if (klass.Get() == NULL) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003494 CHECK(self->IsExceptionPending()); // OOME.
3495 return NULL;
3496 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003497 DCHECK(klass->GetClass() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003498 klass->SetObjectSize(sizeof(mirror::Proxy));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003499 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003500 klass->SetClassLoader(soa.Decode<mirror::ClassLoader*>(loader));
Ian Rogersc2b44472011-12-14 21:17:17 -08003501 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003502 klass->SetName(soa.Decode<mirror::String*>(name));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003503 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003504 klass->SetDexCache(proxy_class->GetDexCache());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003505 klass->SetStatus(mirror::Class::kStatusIdx, self);
Ian Rogersc2b44472011-12-14 21:17:17 -08003506
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003507 // Instance fields are inherited, but we add a couple of static fields...
Ian Rogersa436fde2013-08-27 23:34:06 -07003508 {
3509 mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
3510 if (UNLIKELY(sfields == NULL)) {
3511 CHECK(self->IsExceptionPending()); // OOME.
3512 return NULL;
3513 }
3514 klass->SetSFields(sfields);
3515 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003516 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
3517 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003518 Handle<mirror::ArtField> interfaces_sfield(hs.NewHandle(AllocArtField(self)));
3519 if (UNLIKELY(interfaces_sfield.Get() == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003520 CHECK(self->IsExceptionPending()); // OOME.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003521 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003522 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003523 klass->SetStaticField(0, interfaces_sfield.Get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003524 interfaces_sfield->SetDexFieldIndex(0);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003525 interfaces_sfield->SetDeclaringClass(klass.Get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003526 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
3527 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003528 Handle<mirror::ArtField> throws_sfield(hs.NewHandle(AllocArtField(self)));
3529 if (UNLIKELY(throws_sfield.Get() == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003530 CHECK(self->IsExceptionPending()); // OOME.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003531 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003532 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003533 klass->SetStaticField(1, throws_sfield.Get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003534 throws_sfield->SetDexFieldIndex(1);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003535 throws_sfield->SetDeclaringClass(klass.Get());
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003536 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04003537
Ian Rogers466bb252011-10-14 03:29:56 -07003538 // Proxies have 1 direct method, the constructor
Ian Rogersa436fde2013-08-27 23:34:06 -07003539 {
Mathieu Chartier590fee92013-09-13 13:46:47 -07003540 mirror::ObjectArray<mirror::ArtMethod>* directs = AllocArtMethodArray(self, 1);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003541 if (UNLIKELY(directs == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003542 CHECK(self->IsExceptionPending()); // OOME.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003543 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003544 }
3545 klass->SetDirectMethods(directs);
3546 mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003547 if (UNLIKELY(constructor == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003548 CHECK(self->IsExceptionPending()); // OOME.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003549 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003550 }
3551 klass->SetDirectMethod(0, constructor);
3552 }
Jesse Wilson95caa792011-10-12 18:14:17 -04003553
Mathieu Chartier590fee92013-09-13 13:46:47 -07003554 // Create virtual method using specified prototypes.
3555 size_t num_virtual_methods =
3556 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods)->GetLength();
Ian Rogersa436fde2013-08-27 23:34:06 -07003557 {
Brian Carlstromf3632832014-05-20 15:36:53 -07003558 mirror::ObjectArray<mirror::ArtMethod>* virtuals = AllocArtMethodArray(self,
3559 num_virtual_methods);
Ian Rogersa436fde2013-08-27 23:34:06 -07003560 if (UNLIKELY(virtuals == NULL)) {
3561 CHECK(self->IsExceptionPending()); // OOME.
3562 return NULL;
3563 }
3564 klass->SetVirtualMethods(virtuals);
3565 }
Jesse Wilson95caa792011-10-12 18:14:17 -04003566 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003567 StackHandleScope<1> hs(self);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003568 mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
3569 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003570 Handle<mirror::ArtMethod> prototype(hs.NewHandle(decoded_methods->Get(i)));
Ian Rogersa436fde2013-08-27 23:34:06 -07003571 mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003572 if (UNLIKELY(clone == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003573 CHECK(self->IsExceptionPending()); // OOME.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003574 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003575 }
3576 klass->SetVirtualMethod(i, clone);
Jesse Wilson95caa792011-10-12 18:14:17 -04003577 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003578
3579 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
Brian Carlstromf3632832014-05-20 15:36:53 -07003580 klass->SetStatus(mirror::Class::kStatusLoaded, self); // Now effectively in the loaded state.
Ian Rogers62d6c772013-02-27 08:32:07 -08003581 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08003582
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003583 std::string descriptor(GetDescriptorForProxy(klass.Get()));
3584 mirror::Class* new_class = nullptr;
Ian Rogersc8982582012-09-07 16:53:25 -07003585 {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003586 ObjectLock<mirror::Class> resolution_lock(self, klass); // Must hold lock on object when resolved.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003587 // Link the fields and virtual methods, creating vtable and iftables
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003588 Handle<mirror::ObjectArray<mirror::Class> > h_interfaces(
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003589 hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003590 if (!LinkClass(self, descriptor.c_str(), klass, h_interfaces, &new_class)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003591 klass->SetStatus(mirror::Class::kStatusError, self);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003592 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003593 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003594 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003595
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003596 CHECK(klass->IsRetired());
3597 CHECK_NE(klass.Get(), new_class);
3598 klass.Assign(new_class);
3599
3600 CHECK_EQ(interfaces_sfield->GetDeclaringClass(), new_class);
3601 interfaces_sfield->SetObject<false>(klass.Get(), soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
3602 CHECK_EQ(throws_sfield->GetDeclaringClass(), new_class);
3603 throws_sfield->SetObject<false>(klass.Get(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws));
3604
3605 {
3606 // Lock on klass is released. Lock new class object.
3607 ObjectLock<mirror::Class> initialization_lock(self, klass);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003608 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogersc8982582012-09-07 16:53:25 -07003609 }
Ian Rogersc2b44472011-12-14 21:17:17 -08003610
3611 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07003612 if (kIsDebugBuild) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003613 CHECK(klass->GetIFields() == nullptr);
Ian Rogersc2b44472011-12-14 21:17:17 -08003614 CheckProxyConstructor(klass->GetDirectMethod(0));
3615 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003616 StackHandleScope<2> hs(self);
Mathieu Chartier590fee92013-09-13 13:46:47 -07003617 mirror::ObjectArray<mirror::ArtMethod>* decoded_methods =
3618 soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(methods);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003619 Handle<mirror::ArtMethod> prototype(hs.NewHandle(decoded_methods->Get(i)));
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003620 Handle<mirror::ArtMethod> virtual_method(hs.NewHandle(klass->GetVirtualMethod(i)));
3621 CheckProxyMethod(virtual_method, prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08003622 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003623
Mathieu Chartier590fee92013-09-13 13:46:47 -07003624 mirror::String* decoded_name = soa.Decode<mirror::String*>(name);
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003625 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
Mathieu Chartier590fee92013-09-13 13:46:47 -07003626 decoded_name->ToModifiedUtf8().c_str()));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003627 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name);
3628
3629 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
Mathieu Chartier590fee92013-09-13 13:46:47 -07003630 decoded_name->ToModifiedUtf8().c_str()));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07003631 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08003632
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003633 CHECK_EQ(klass.Get()->GetInterfaces(),
Brian Carlstromf3632832014-05-20 15:36:53 -07003634 soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07003635 CHECK_EQ(klass.Get()->GetThrows(),
Brian Carlstromf3632832014-05-20 15:36:53 -07003636 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>*>(throws));
Ian Rogersc2b44472011-12-14 21:17:17 -08003637 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003638 mirror::Class* existing = InsertClass(descriptor.c_str(), klass.Get(), Hash(descriptor.c_str()));
Mathieu Chartier31b9d662013-10-14 11:53:12 -07003639 CHECK(existing == nullptr);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003640 return klass.Get();
Jesse Wilson95caa792011-10-12 18:14:17 -04003641}
3642
Ian Rogersef7d42f2014-01-06 12:55:46 -08003643std::string ClassLinker::GetDescriptorForProxy(mirror::Class* proxy_class) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003644 DCHECK(proxy_class->IsProxyClass());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003645 mirror::String* name = proxy_class->GetName();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003646 DCHECK(name != NULL);
3647 return DotToDescriptor(name->ToModifiedUtf8().c_str());
3648}
3649
Ian Rogersef7d42f2014-01-06 12:55:46 -08003650mirror::ArtMethod* ClassLinker::FindMethodForProxy(mirror::Class* proxy_class,
3651 mirror::ArtMethod* proxy_method) {
Ian Rogers16f93672012-02-14 12:29:06 -08003652 DCHECK(proxy_class->IsProxyClass());
3653 DCHECK(proxy_method->IsProxyMethod());
3654 // Locate the dex cache of the original interface/Object
Andreas Gampe4ef12f52014-07-31 16:23:49 -07003655 mirror::DexCache* dex_cache = nullptr;
Ian Rogers16f93672012-02-14 12:29:06 -08003656 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003657 ReaderMutexLock mu(Thread::Current(), dex_lock_);
Ian Rogers16f93672012-02-14 12:29:06 -08003658 for (size_t i = 0; i != dex_caches_.size(); ++i) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003659 mirror::DexCache* a_dex_cache = GetDexCache(i);
Andreas Gampe4ef12f52014-07-31 16:23:49 -07003660 if (proxy_method->HasSameDexCacheResolvedTypes(a_dex_cache->GetResolvedTypes())) {
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003661 dex_cache = a_dex_cache;
Ian Rogers16f93672012-02-14 12:29:06 -08003662 break;
3663 }
3664 }
3665 }
Andreas Gampe4ef12f52014-07-31 16:23:49 -07003666 CHECK(dex_cache != nullptr);
Ian Rogers16f93672012-02-14 12:29:06 -08003667 uint32_t method_idx = proxy_method->GetDexMethodIndex();
Brian Carlstromea46f952013-07-30 01:26:50 -07003668 mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
Andreas Gampe4ef12f52014-07-31 16:23:49 -07003669 CHECK(resolved_method != nullptr);
Ian Rogers16f93672012-02-14 12:29:06 -08003670 return resolved_method;
3671}
3672
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003673
Brian Carlstromea46f952013-07-30 01:26:50 -07003674mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003675 Handle<mirror::Class> klass,
Brian Carlstromea46f952013-07-30 01:26:50 -07003676 mirror::Class* proxy_class) {
Ian Rogers466bb252011-10-14 03:29:56 -07003677 // Create constructor for Proxy that must initialize h
Brian Carlstromea46f952013-07-30 01:26:50 -07003678 mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods =
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003679 proxy_class->GetDirectMethods();
Brian Carlstromea46f952013-07-30 01:26:50 -07003680 CHECK_EQ(proxy_direct_methods->GetLength(), 16);
3681 mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2);
Sebastien Hertz440d3da2014-08-27 15:32:56 +02003682 // Ensure constructor is in dex cache so that we can use the dex cache to look up the overridden
3683 // constructor method.
3684 proxy_class->GetDexCache()->SetResolvedMethod(proxy_constructor->GetDexMethodIndex(),
3685 proxy_constructor);
Jeff Hao95b4c652014-08-14 17:18:52 -07003686 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
3687 // code_ too)
Jeff Hao4bf8d112014-07-24 16:26:09 -07003688 mirror::ArtMethod* constructor = down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
3689 if (constructor == nullptr) {
Ian Rogersa436fde2013-08-27 23:34:06 -07003690 CHECK(self->IsExceptionPending()); // OOME.
Jeff Hao4bf8d112014-07-24 16:26:09 -07003691 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003692 }
Ian Rogers466bb252011-10-14 03:29:56 -07003693 // Make this constructor public and fix the class to be our Proxy version
3694 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003695 constructor->SetDeclaringClass(klass.Get());
Ian Rogersc2b44472011-12-14 21:17:17 -08003696 return constructor;
3697}
3698
Brian Carlstromea46f952013-07-30 01:26:50 -07003699static void CheckProxyConstructor(mirror::ArtMethod* constructor)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003700 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07003701 CHECK(constructor->IsConstructor());
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003702 CHECK_STREQ(constructor->GetName(), "<init>");
3703 CHECK_STREQ(constructor->GetSignature().ToString().c_str(),
3704 "(Ljava/lang/reflect/InvocationHandler;)V");
Ian Rogers466bb252011-10-14 03:29:56 -07003705 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04003706}
3707
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003708mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003709 Handle<mirror::Class> klass,
3710 Handle<mirror::ArtMethod> prototype) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003711 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
3712 // prototype method
Ian Rogers16f93672012-02-14 12:29:06 -08003713 prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003714 prototype.Get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003715 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07003716 // as necessary
Brian Carlstromea46f952013-07-30 01:26:50 -07003717 mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
Ian Rogersa436fde2013-08-27 23:34:06 -07003718 if (UNLIKELY(method == NULL)) {
3719 CHECK(self->IsExceptionPending()); // OOME.
3720 return NULL;
3721 }
Ian Rogers466bb252011-10-14 03:29:56 -07003722
3723 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
3724 // the intersection of throw exceptions as defined in Proxy
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003725 method->SetDeclaringClass(klass.Get());
Ian Rogers466bb252011-10-14 03:29:56 -07003726 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04003727
Ian Rogers466bb252011-10-14 03:29:56 -07003728 // At runtime the method looks like a reference and argument saving method, clone the code
3729 // related parameters from this method.
Ian Rogersef7d42f2014-01-06 12:55:46 -08003730 method->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler());
3731 method->SetEntryPointFromPortableCompiledCode(GetPortableProxyInvokeHandler());
Dragos Sbirlea08bf1962013-08-12 08:53:04 -07003732 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge);
Ian Rogers16f93672012-02-14 12:29:06 -08003733
Ian Rogersc2b44472011-12-14 21:17:17 -08003734 return method;
3735}
Jesse Wilson95caa792011-10-12 18:14:17 -04003736
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003737static void CheckProxyMethod(Handle<mirror::ArtMethod> method, Handle<mirror::ArtMethod> prototype)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003738 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers466bb252011-10-14 03:29:56 -07003739 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003740 CHECK(!prototype->IsFinal());
3741 CHECK(method->IsFinal());
3742 CHECK(!method->IsAbstract());
Ian Rogers19846512012-02-24 11:42:47 -08003743
3744 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
3745 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
3746 CHECK_EQ(prototype->GetDexCacheStrings(), method->GetDexCacheStrings());
Andreas Gampe4ef12f52014-07-31 16:23:49 -07003747 CHECK(prototype->HasSameDexCacheResolvedMethods(method.Get()));
3748 CHECK(prototype->HasSameDexCacheResolvedTypes(method.Get()));
Ian Rogers19846512012-02-24 11:42:47 -08003749 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
3750
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003751 MethodHelper mh(method);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003752 MethodHelper mh2(prototype);
3753 CHECK_STREQ(method->GetName(), prototype->GetName());
3754 CHECK_STREQ(method->GetShorty(), prototype->GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07003755 // More complex sanity - via dex cache
Ian Rogers19846512012-02-24 11:42:47 -08003756 CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
Jesse Wilson95caa792011-10-12 18:14:17 -04003757}
3758
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003759static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics,
3760 bool can_init_parents)
3761 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08003762 if (can_init_statics && can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003763 return true;
3764 }
3765 if (!can_init_statics) {
3766 // Check if there's a class initializer.
Ian Rogersd91d6d62013-09-25 20:26:14 -07003767 mirror::ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003768 if (clinit != NULL) {
3769 return false;
3770 }
3771 // Check if there are encoded static values needing initialization.
3772 if (klass->NumStaticFields() != 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07003773 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003774 DCHECK(dex_class_def != NULL);
3775 if (dex_class_def->static_values_off_ != 0) {
3776 return false;
3777 }
3778 }
3779 }
3780 if (!klass->IsInterface() && klass->HasSuperClass()) {
3781 mirror::Class* super_class = klass->GetSuperClass();
3782 if (!can_init_parents && !super_class->IsInitialized()) {
3783 return false;
3784 } else {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08003785 if (!CanWeInitializeClass(super_class, can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003786 return false;
3787 }
3788 }
3789 }
3790 return true;
3791}
3792
Mathieu Chartier590fee92013-09-13 13:46:47 -07003793bool ClassLinker::IsInitialized() const {
3794 return init_done_;
3795}
3796
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003797bool ClassLinker::InitializeClass(Handle<mirror::Class> klass, bool can_init_statics,
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003798 bool can_init_parents) {
3799 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
3800
3801 // Are we already initialized and therefore done?
3802 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
3803 // an initialized class will never change its state.
3804 if (klass->IsInitialized()) {
3805 return true;
3806 }
3807
3808 // Fast fail if initialization requires a full runtime. Not part of the JLS.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003809 if (!CanWeInitializeClass(klass.Get(), can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003810 return false;
3811 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003812
Carl Shapirob5573532011-07-12 18:22:59 -07003813 Thread* self = Thread::Current();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003814 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003815 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003816 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003817
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003818 // Re-check under the lock in case another thread initialized ahead of us.
3819 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003820 return true;
3821 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003822
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003823 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07003824 if (klass->IsErroneous()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003825 ThrowEarlierClassFailure(klass.Get());
Brian Carlstromd1422f82011-09-28 11:37:09 -07003826 return false;
3827 }
3828
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003829 CHECK(klass->IsResolved()) << PrettyClass(klass.Get()) << ": state=" << klass->GetStatus();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003830
3831 if (!klass->IsVerified()) {
jeffhao98eacac2011-09-14 16:11:53 -07003832 VerifyClass(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003833 if (!klass->IsVerified()) {
3834 // We failed to verify, expect either the klass to be erroneous or verification failed at
3835 // compile time.
3836 if (klass->IsErroneous()) {
jeffhaoa9b3bf42012-06-06 17:18:39 -07003837 CHECK(self->IsExceptionPending());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003838 } else {
3839 CHECK(Runtime::Current()->IsCompiler());
3840 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07003841 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003842 return false;
Mathieu Chartier58c016c2014-08-27 15:28:28 -07003843 } else {
3844 self->AssertNoPendingException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003845 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003846 }
3847
Brian Carlstromd1422f82011-09-28 11:37:09 -07003848 // If the class is kStatusInitializing, either this thread is
3849 // initializing higher up the stack or another thread has beat us
3850 // to initializing and we need to wait. Either way, this
3851 // invocation of InitializeClass will not be responsible for
3852 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003853 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Mathieu Chartier58c016c2014-08-27 15:28:28 -07003854 // Could have got an exception during verification.
3855 if (self->IsExceptionPending()) {
3856 return false;
3857 }
Elliott Hughes005ab2e2011-09-11 17:15:31 -07003858 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07003859 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003860 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003861 return true;
3862 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003863 // No. That's fine. Wait for another thread to finish initializing.
3864 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003865 }
3866
3867 if (!ValidateSuperClassDescriptors(klass)) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003868 klass->SetStatus(mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003869 return false;
3870 }
3871
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003872 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003873
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003874 // From here out other threads may observe that we're initializing and so changes of state
3875 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07003876 klass->SetClinitThreadId(self->GetTid());
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003877 klass->SetStatus(mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003878
3879 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003880 }
3881
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07003882 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003883 if (!klass->IsInterface() && klass->HasSuperClass()) {
3884 mirror::Class* super_class = klass->GetSuperClass();
3885 if (!super_class->IsInitialized()) {
3886 CHECK(!super_class->IsInterface());
3887 CHECK(can_init_parents);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003888 StackHandleScope<1> hs(self);
3889 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class));
3890 bool super_initialized = InitializeClass(handle_scope_super, can_init_statics, true);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003891 if (!super_initialized) {
3892 // The super class was verified ahead of entering initializing, we should only be here if
3893 // the super class became erroneous due to initialization.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003894 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending())
Brian Carlstromf3632832014-05-20 15:36:53 -07003895 << "Super class initialization failed for "
3896 << PrettyDescriptor(handle_scope_super.Get())
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003897 << " that has unexpected status " << handle_scope_super->GetStatus()
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003898 << "\nPending exception:\n"
3899 << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003900 ObjectLock<mirror::Class> lock(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003901 // Initialization failed because the super-class is erroneous.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003902 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003903 return false;
3904 }
Ian Rogers1bddec32012-02-04 12:27:34 -08003905 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003906 }
3907
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003908 if (klass->NumStaticFields() > 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07003909 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003910 CHECK(dex_class_def != NULL);
Mathieu Chartierf8322842014-05-16 10:59:25 -07003911 const DexFile& dex_file = klass->GetDexFile();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003912 StackHandleScope<2> hs(self);
3913 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
Mathieu Chartierf8322842014-05-16 10:59:25 -07003914 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache()));
Mathieu Chartier590fee92013-09-13 13:46:47 -07003915 EncodedStaticFieldValueIterator it(dex_file, &dex_cache, &class_loader,
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003916 this, *dex_class_def);
3917 if (it.HasNext()) {
3918 CHECK(can_init_statics);
Brian Carlstromf3632832014-05-20 15:36:53 -07003919 // We reordered the fields, so we need to be able to map the
3920 // field indexes to the right fields.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003921 SafeMap<uint32_t, mirror::ArtField*> field_map;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003922 ConstructFieldMap(dex_file, *dex_class_def, klass.Get(), field_map);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003923 for (size_t i = 0; it.HasNext(); i++, it.Next()) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01003924 if (Runtime::Current()->IsActiveTransaction()) {
3925 it.ReadValueToField<true>(field_map.Get(i));
3926 } else {
3927 it.ReadValueToField<false>(field_map.Get(i));
3928 }
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003929 }
3930 }
3931 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003932
Ian Rogersd91d6d62013-09-25 20:26:14 -07003933 mirror::ArtMethod* clinit = klass->FindClassInitializer();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003934 if (clinit != NULL) {
3935 CHECK(can_init_statics);
Ian Rogers5d27faf2014-05-02 17:17:18 -07003936 JValue result;
3937 clinit->Invoke(self, NULL, 0, &result, "V");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003938 }
3939
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003940 uint64_t t1 = NanoTime();
3941
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003942 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003943 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003944 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003945
3946 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003947 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003948 klass->SetStatus(mirror::Class::kStatusError, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003949 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003950 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07003951 RuntimeStats* global_stats = Runtime::Current()->GetStats();
3952 RuntimeStats* thread_stats = self->GetStats();
3953 ++global_stats->class_init_count;
3954 ++thread_stats->class_init_count;
3955 global_stats->class_init_time_ns += (t1 - t0);
3956 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07003957 // Set the class as initialized except if failed to initialize static fields.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003958 klass->SetStatus(mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003959 if (VLOG_IS_ON(class_linker)) {
Ian Rogerscb6b0f32014-08-12 02:30:58 -07003960 std::string temp;
3961 LOG(INFO) << "Initialized class " << klass->GetDescriptor(&temp) << " from " <<
Mathieu Chartierf8322842014-05-16 10:59:25 -07003962 klass->GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08003963 }
Brian Carlstrom073278c2014-02-19 15:21:21 -08003964 // Opportunistically set static method trampolines to their destination.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003965 FixupStaticTrampolines(klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003966 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003967 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08003968 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003969}
3970
Mathieu Chartier0cd81352014-05-22 16:48:55 -07003971bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass, Thread* self,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003972 ObjectLock<mirror::Class>& lock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003973 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003974 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003975 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07003976 CHECK(!klass->IsInitialized());
Ian Rogers05f30572013-02-20 12:13:11 -08003977 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07003978
3979 // When we wake up, repeat the test for init-in-progress. If
3980 // there's an exception pending (only possible if
3981 // "interruptShouldThrow" was set), bail out.
3982 if (self->IsExceptionPending()) {
Elliott Hughes4d0207c2011-10-03 19:14:34 -07003983 WrapExceptionInInitializer();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003984 klass->SetStatus(mirror::Class::kStatusError, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07003985 return false;
3986 }
3987 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003988 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07003989 continue;
3990 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003991 if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07003992 // Compile time initialization failed.
3993 return false;
3994 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07003995 if (klass->IsErroneous()) {
3996 // The caller wants an exception, but it was thrown in a
3997 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07003998 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003999 PrettyDescriptor(klass.Get()).c_str());
Brian Carlstromd1422f82011-09-28 11:37:09 -07004000 return false;
4001 }
4002 if (klass->IsInitialized()) {
4003 return true;
4004 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004005 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass.Get()) << " is "
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004006 << klass->GetStatus();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004007 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004008 LOG(FATAL) << "Not Reached" << PrettyClass(klass.Get());
Brian Carlstromd1422f82011-09-28 11:37:09 -07004009}
4010
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004011bool ClassLinker::ValidateSuperClassDescriptors(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004012 if (klass->IsInterface()) {
4013 return true;
4014 }
Ian Rogers151f2212014-05-06 11:27:27 -07004015 // Begin with the methods local to the superclass.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004016 StackHandleScope<2> hs(Thread::Current());
4017 MethodHelper mh(hs.NewHandle<mirror::ArtMethod>(nullptr));
4018 MethodHelper super_mh(hs.NewHandle<mirror::ArtMethod>(nullptr));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004019 if (klass->HasSuperClass() &&
4020 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004021 for (int i = klass->GetSuperClass()->GetVTableLength() - 1; i >= 0; --i) {
4022 mh.ChangeMethod(klass->GetVTableEntry(i));
4023 super_mh.ChangeMethod(klass->GetSuperClass()->GetVTableEntry(i));
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004024 if (mh.GetMethod() != super_mh.GetMethod() &&
4025 !mh.HasSameSignatureWithDifferentClassLoaders(&super_mh)) {
4026 ThrowLinkageError(klass.Get(),
4027 "Class %s method %s resolves differently in superclass %s",
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004028 PrettyDescriptor(klass.Get()).c_str(),
Ian Rogers151f2212014-05-06 11:27:27 -07004029 PrettyMethod(mh.GetMethod()).c_str(),
4030 PrettyDescriptor(klass->GetSuperClass()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004031 return false;
4032 }
4033 }
4034 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07004035 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Ian Rogers151f2212014-05-06 11:27:27 -07004036 if (klass->GetClassLoader() != klass->GetIfTable()->GetInterface(i)->GetClassLoader()) {
4037 uint32_t num_methods = klass->GetIfTable()->GetInterface(i)->NumVirtualMethods();
4038 for (uint32_t j = 0; j < num_methods; ++j) {
4039 mh.ChangeMethod(klass->GetIfTable()->GetMethodArray(i)->GetWithoutChecks(j));
4040 super_mh.ChangeMethod(klass->GetIfTable()->GetInterface(i)->GetVirtualMethod(j));
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004041 if (mh.GetMethod() != super_mh.GetMethod() &&
4042 !mh.HasSameSignatureWithDifferentClassLoaders(&super_mh)) {
4043 ThrowLinkageError(klass.Get(),
4044 "Class %s method %s resolves differently in interface %s",
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004045 PrettyDescriptor(klass.Get()).c_str(),
Ian Rogers151f2212014-05-06 11:27:27 -07004046 PrettyMethod(mh.GetMethod()).c_str(),
4047 PrettyDescriptor(klass->GetIfTable()->GetInterface(i)).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004048 return false;
4049 }
4050 }
4051 }
4052 }
4053 return true;
4054}
4055
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004056bool ClassLinker::EnsureInitialized(Handle<mirror::Class> c, bool can_init_fields,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004057 bool can_init_parents) {
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004058 DCHECK(c.Get() != nullptr);
Mathieu Chartier58c016c2014-08-27 15:28:28 -07004059 if (c->IsInitialized()) {
4060 return true;
4061 }
4062 const bool success = InitializeClass(c, can_init_fields, can_init_parents);
4063 Thread* self = Thread::Current();
4064 if (!success) {
4065 if (can_init_fields && can_init_parents) {
4066 CHECK(self->IsExceptionPending()) << PrettyClass(c.Get());
4067 }
4068 } else {
4069 self->AssertNoPendingException();
Ian Rogers595799e2012-01-11 17:32:51 -08004070 }
4071 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07004072}
4073
Elliott Hughes5fe594f2011-09-08 12:33:17 -07004074void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
Mathieu Chartier590fee92013-09-13 13:46:47 -07004075 mirror::Class* c,
4076 SafeMap<uint32_t, mirror::ArtField*>& field_map) {
Elliott Hughes5fe594f2011-09-08 12:33:17 -07004077 const byte* class_data = dex_file.GetClassData(dex_class_def);
Ian Rogers0571d352011-11-03 19:51:38 -07004078 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004079 StackHandleScope<2> hs(Thread::Current());
4080 Handle<mirror::DexCache> dex_cache(hs.NewHandle(c->GetDexCache()));
4081 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(c->GetClassLoader()));
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004082 CHECK(!kMovingFields);
Ian Rogers0571d352011-11-03 19:51:38 -07004083 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004084 field_map.Put(i, ResolveField(dex_file, it.GetMemberIndex(), dex_cache, class_loader, true));
Elliott Hughes5fe594f2011-09-08 12:33:17 -07004085 }
4086}
4087
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004088void ClassLinker::FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class) {
4089 mirror::ObjectArray<mirror::ArtField>* fields = new_class->GetIFields();
4090 if (fields != nullptr) {
4091 for (int index = 0; index < fields->GetLength(); index ++) {
4092 if (fields->Get(index)->GetDeclaringClass() == temp_class) {
4093 fields->Get(index)->SetDeclaringClass(new_class);
4094 }
4095 }
4096 }
4097
4098 fields = new_class->GetSFields();
4099 if (fields != nullptr) {
4100 for (int index = 0; index < fields->GetLength(); index ++) {
4101 if (fields->Get(index)->GetDeclaringClass() == temp_class) {
4102 fields->Get(index)->SetDeclaringClass(new_class);
4103 }
4104 }
4105 }
4106
4107 mirror::ObjectArray<mirror::ArtMethod>* methods = new_class->GetDirectMethods();
4108 if (methods != nullptr) {
4109 for (int index = 0; index < methods->GetLength(); index ++) {
4110 if (methods->Get(index)->GetDeclaringClass() == temp_class) {
4111 methods->Get(index)->SetDeclaringClass(new_class);
4112 }
4113 }
4114 }
4115
4116 methods = new_class->GetVirtualMethods();
4117 if (methods != nullptr) {
4118 for (int index = 0; index < methods->GetLength(); index ++) {
4119 if (methods->Get(index)->GetDeclaringClass() == temp_class) {
4120 methods->Get(index)->SetDeclaringClass(new_class);
4121 }
4122 }
4123 }
4124}
4125
4126bool ClassLinker::LinkClass(Thread* self, const char* descriptor, Handle<mirror::Class> klass,
4127 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
4128 mirror::Class** new_class) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004129 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004130
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004131 if (!LinkSuperClass(klass)) {
4132 return false;
4133 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004134 if (!LinkMethods(self, klass, interfaces)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004135 return false;
4136 }
4137 if (!LinkInstanceFields(klass)) {
4138 return false;
4139 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004140 size_t class_size;
4141 if (!LinkStaticFields(klass, &class_size)) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07004142 return false;
4143 }
4144 CreateReferenceInstanceOffsets(klass);
4145 CreateReferenceStaticOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004146 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004147
4148 if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) {
4149 // We don't need to retire this class as it has no embedded tables or it was created the
4150 // correct size during class linker initialization.
4151 CHECK_EQ(klass->GetClassSize(), class_size) << PrettyDescriptor(klass.Get());
4152
4153 if (klass->ShouldHaveEmbeddedImtAndVTable()) {
4154 klass->PopulateEmbeddedImtAndVTable();
4155 }
4156
4157 // This will notify waiters on klass that saw the not yet resolved
4158 // class in the class_table_ during EnsureResolved.
4159 klass->SetStatus(mirror::Class::kStatusResolved, self);
4160 *new_class = klass.Get();
4161 } else {
4162 CHECK(!klass->IsResolved());
4163 // Retire the temporary class and create the correctly sized resolved class.
4164 *new_class = klass->CopyOf(self, class_size);
4165 if (UNLIKELY(*new_class == NULL)) {
4166 CHECK(self->IsExceptionPending()); // Expect an OOME.
4167 klass->SetStatus(mirror::Class::kStatusError, self);
4168 return false;
4169 }
4170
4171 CHECK_EQ((*new_class)->GetClassSize(), class_size);
4172 StackHandleScope<1> hs(self);
4173 auto new_class_h = hs.NewHandleWrapper<mirror::Class>(new_class);
4174 ObjectLock<mirror::Class> lock(self, new_class_h);
4175
4176 FixupTemporaryDeclaringClass(klass.Get(), new_class_h.Get());
4177
4178 mirror::Class* existing = UpdateClass(descriptor, new_class_h.Get(), Hash(descriptor));
4179 CHECK(existing == NULL || existing == klass.Get());
4180
4181 // This will notify waiters on temp class that saw the not yet resolved class in the
4182 // class_table_ during EnsureResolved.
4183 klass->SetStatus(mirror::Class::kStatusRetired, self);
4184
4185 CHECK_EQ(new_class_h->GetStatus(), mirror::Class::kStatusResolving);
4186 // This will notify waiters on new_class that saw the not yet resolved
4187 // class in the class_table_ during EnsureResolved.
4188 new_class_h->SetStatus(mirror::Class::kStatusResolved, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004189 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004190 return true;
4191}
4192
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004193bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004194 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers8b2c0b92013-09-19 02:56:49 -07004195 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
4196 uint16_t super_class_idx = class_def.superclass_idx_;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004197 if (super_class_idx != DexFile::kDexNoIndex16) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004198 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004199 if (super_class == NULL) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07004200 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004201 return false;
4202 }
Ian Rogersbe125a92012-01-11 15:19:49 -08004203 // Verify
4204 if (!klass->CanAccess(super_class)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004205 ThrowIllegalAccessError(klass.Get(), "Class %s extended by class %s is inaccessible",
Ian Rogers62d6c772013-02-27 08:32:07 -08004206 PrettyDescriptor(super_class).c_str(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004207 PrettyDescriptor(klass.Get()).c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08004208 return false;
4209 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004210 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004211 klass->SetSuperClass(super_class);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004212 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07004213 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004214 if (interfaces != NULL) {
4215 for (size_t i = 0; i < interfaces->Size(); i++) {
4216 uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004217 mirror::Class* interface = ResolveType(dex_file, idx, klass.Get());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004218 if (interface == NULL) {
4219 DCHECK(Thread::Current()->IsExceptionPending());
4220 return false;
4221 }
4222 // Verify
4223 if (!klass->CanAccess(interface)) {
4224 // TODO: the RI seemed to ignore this in my testing.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004225 ThrowIllegalAccessError(klass.Get(), "Interface %s implemented by class %s is inaccessible",
Ian Rogers62d6c772013-02-27 08:32:07 -08004226 PrettyDescriptor(interface).c_str(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004227 PrettyDescriptor(klass.Get()).c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004228 return false;
4229 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004230 }
4231 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07004232 // Mark the class as loaded.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004233 klass->SetStatus(mirror::Class::kStatusLoaded, NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004234 return true;
4235}
4236
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004237bool ClassLinker::LinkSuperClass(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004238 CHECK(!klass->IsPrimitive());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004239 mirror::Class* super = klass->GetSuperClass();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004240 if (klass.Get() == GetClassRoot(kJavaLangObject)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004241 if (super != NULL) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004242 ThrowClassFormatError(klass.Get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004243 return false;
4244 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004245 return true;
4246 }
4247 if (super == NULL) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004248 ThrowLinkageError(klass.Get(), "No superclass defined for class %s",
4249 PrettyDescriptor(klass.Get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004250 return false;
4251 }
4252 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07004253 if (super->IsFinal() || super->IsInterface()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004254 ThrowIncompatibleClassChangeError(klass.Get(), "Superclass %s of %s is %s",
Ian Rogers62d6c772013-02-27 08:32:07 -08004255 PrettyDescriptor(super).c_str(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004256 PrettyDescriptor(klass.Get()).c_str(),
Ian Rogers62d6c772013-02-27 08:32:07 -08004257 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004258 return false;
4259 }
4260 if (!klass->CanAccess(super)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004261 ThrowIllegalAccessError(klass.Get(), "Superclass %s is inaccessible to class %s",
Ian Rogers62d6c772013-02-27 08:32:07 -08004262 PrettyDescriptor(super).c_str(),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004263 PrettyDescriptor(klass.Get()).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004264 return false;
4265 }
Elliott Hughes20cde902011-10-04 17:37:27 -07004266
Brian Carlstromf3632832014-05-20 15:36:53 -07004267 // Inherit kAccClassIsFinalizable from the superclass in case this
4268 // class doesn't override finalize.
Elliott Hughes20cde902011-10-04 17:37:27 -07004269 if (super->IsFinalizable()) {
4270 klass->SetFinalizable();
4271 }
4272
Elliott Hughes2da50362011-10-10 16:57:08 -07004273 // Inherit reference flags (if any) from the superclass.
4274 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask);
4275 if (reference_flags != 0) {
4276 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags);
4277 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07004278 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07004279 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004280 ThrowLinkageError(klass.Get(),
Ian Rogers62d6c772013-02-27 08:32:07 -08004281 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004282 PrettyDescriptor(klass.Get()).c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07004283 return false;
4284 }
Elliott Hughes2da50362011-10-10 16:57:08 -07004285
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004286 if (kIsDebugBuild) {
4287 // Ensure super classes are fully resolved prior to resolving fields..
4288 while (super != NULL) {
4289 CHECK(super->IsResolved());
4290 super = super->GetSuperClass();
4291 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004292 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004293 return true;
4294}
4295
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004296// Populate the class vtable and itable. Compute return type indices.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004297bool ClassLinker::LinkMethods(Thread* self, Handle<mirror::Class> klass,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004298 Handle<mirror::ObjectArray<mirror::Class>> interfaces) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004299 if (klass->IsInterface()) {
4300 // No vtable.
4301 size_t count = klass->NumVirtualMethods();
4302 if (!IsUint(16, count)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004303 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zd", count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004304 return false;
4305 }
Carl Shapiro565f5072011-07-10 13:39:43 -07004306 for (size_t i = 0; i < count; ++i) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004307 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004308 }
jeffhaobdb76512011-09-07 11:43:16 -07004309 // Link interface method tables
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004310 return LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004311 } else {
Elliott Hughesbc258fa2011-10-06 14:45:21 -07004312 // Link virtual and interface method tables
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004313 return LinkVirtualMethods(self, klass) && LinkInterfaceMethods(klass, interfaces);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004314 }
4315 return true;
4316}
4317
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004318bool ClassLinker::LinkVirtualMethods(Thread* self, Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004319 if (klass->HasSuperClass()) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004320 uint32_t max_count = klass->NumVirtualMethods() +
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004321 klass->GetSuperClass()->GetVTableLength();
4322 size_t actual_count = klass->GetSuperClass()->GetVTableLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07004323 CHECK_LE(actual_count, max_count);
Mingyao Yang82546342014-08-13 14:51:03 -07004324 StackHandleScope<4> hs(self);
4325 Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass()));
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004326 Handle<mirror::ObjectArray<mirror::ArtMethod>> vtable;
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004327 if (super_class->ShouldHaveEmbeddedImtAndVTable()) {
4328 vtable = hs.NewHandle(AllocArtMethodArray(self, max_count));
4329 if (UNLIKELY(vtable.Get() == nullptr)) {
4330 CHECK(self->IsExceptionPending()); // OOME.
4331 return false;
4332 }
4333 int len = super_class->GetVTableLength();
Mingyao Yang1a128582014-07-22 17:33:25 -07004334 for (int i = 0; i < len; i++) {
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004335 vtable->Set<false>(i, super_class->GetVTableEntry(i));
4336 }
4337 } else {
Mingyao Yang82546342014-08-13 14:51:03 -07004338 CHECK(super_class->GetVTable() != nullptr) << PrettyClass(super_class.Get());
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004339 vtable = hs.NewHandle(super_class->GetVTable()->CopyOf(self, max_count));
4340 if (UNLIKELY(vtable.Get() == nullptr)) {
4341 CHECK(self->IsExceptionPending()); // OOME.
4342 return false;
4343 }
Ian Rogersa436fde2013-08-27 23:34:06 -07004344 }
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004345
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004346 // See if any of our virtual methods override the superclass.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004347 MethodHelper local_mh(hs.NewHandle<mirror::ArtMethod>(nullptr));
4348 MethodHelper super_mh(hs.NewHandle<mirror::ArtMethod>(nullptr));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004349 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004350 mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004351 local_mh.ChangeMethod(local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004352 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07004353 for (; j < actual_count; ++j) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004354 mirror::ArtMethod* super_method = vtable->Get(j);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004355 super_mh.ChangeMethod(super_method);
Elliott Hughes39717372012-07-13 16:21:23 -07004356 if (local_mh.HasSameNameAndSignature(&super_mh)) {
Brian Carlstromf3632832014-05-20 15:36:53 -07004357 if (klass->CanAccessMember(super_method->GetDeclaringClass(),
4358 super_method->GetAccessFlags())) {
Elliott Hughes39717372012-07-13 16:21:23 -07004359 if (super_method->IsFinal()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004360 ThrowLinkageError(klass.Get(), "Method %s overrides final method in class %s",
Elliott Hughes39717372012-07-13 16:21:23 -07004361 PrettyMethod(local_method).c_str(),
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004362 super_method->GetDeclaringClassDescriptor());
Elliott Hughes39717372012-07-13 16:21:23 -07004363 return false;
4364 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004365 vtable->Set<false>(j, local_method);
Elliott Hughes39717372012-07-13 16:21:23 -07004366 local_method->SetMethodIndex(j);
4367 break;
4368 } else {
4369 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(local_method)
4370 << " would have incorrectly overridden the package-private method in "
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004371 << PrettyDescriptor(super_method->GetDeclaringClassDescriptor());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004372 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004373 }
4374 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07004375 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004376 // Not overriding, append.
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004377 vtable->Set<false>(actual_count, local_method);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004378 local_method->SetMethodIndex(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004379 actual_count += 1;
4380 }
4381 }
4382 if (!IsUint(16, actual_count)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004383 ThrowClassFormatError(klass.Get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004384 return false;
4385 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004386 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004387 CHECK_LE(actual_count, max_count);
4388 if (actual_count < max_count) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004389 vtable.Assign(vtable->CopyOf(self, actual_count));
4390 if (UNLIKELY(vtable.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004391 CHECK(self->IsExceptionPending()); // OOME.
4392 return false;
4393 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004394 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004395 klass->SetVTable(vtable.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004396 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004397 CHECK_EQ(klass.Get(), GetClassRoot(kJavaLangObject));
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07004398 uint32_t num_virtual_methods = klass->NumVirtualMethods();
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07004399 if (!IsUint(16, num_virtual_methods)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004400 ThrowClassFormatError(klass.Get(), "Too many methods: %d", num_virtual_methods);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004401 return false;
4402 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004403 StackHandleScope<1> hs(self);
Ian Rogers700a4022014-05-19 16:49:03 -07004404 Handle<mirror::ObjectArray<mirror::ArtMethod>>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004405 vtable(hs.NewHandle(AllocArtMethodArray(self, num_virtual_methods)));
4406 if (UNLIKELY(vtable.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004407 CHECK(self->IsExceptionPending()); // OOME.
4408 return false;
4409 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07004410 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004411 mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004412 vtable->Set<false>(i, virtual_method);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004413 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004414 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004415 klass->SetVTable(vtable.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004416 }
4417 return true;
4418}
4419
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004420bool ClassLinker::LinkInterfaceMethods(Handle<mirror::Class> klass,
4421 Handle<mirror::ObjectArray<mirror::Class>> interfaces) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004422 Thread* const self = Thread::Current();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004423 Runtime* const runtime = Runtime::Current();
Jeff Hao88474b42013-10-23 16:24:40 -07004424 // Set the imt table to be all conflicts by default.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004425 klass->SetImTable(runtime->GetDefaultImt());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004426 size_t super_ifcount;
4427 if (klass->HasSuperClass()) {
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07004428 super_ifcount = klass->GetSuperClass()->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004429 } else {
4430 super_ifcount = 0;
4431 }
Mathieu Chartierf8322842014-05-16 10:59:25 -07004432 uint32_t num_interfaces =
4433 interfaces.Get() == nullptr ? klass->NumDirectInterfaces() : interfaces->GetLength();
4434 size_t ifcount = super_ifcount + num_interfaces;
4435 for (size_t i = 0; i < num_interfaces; i++) {
4436 mirror::Class* interface =
4437 interfaces.Get() == nullptr ? mirror::Class::GetDirectInterface(self, klass, i) :
4438 interfaces->Get(i);
4439 ifcount += interface->GetIfTableCount();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004440 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07004441 if (ifcount == 0) {
Ian Rogers9bc81912012-10-11 21:43:36 -07004442 // Class implements no interfaces.
4443 DCHECK_EQ(klass->GetIfTableCount(), 0);
4444 DCHECK(klass->GetIfTable() == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004445 return true;
4446 }
Ian Rogers9bc81912012-10-11 21:43:36 -07004447 if (ifcount == super_ifcount) {
4448 // Class implements same interfaces as parent, are any of these not marker interfaces?
4449 bool has_non_marker_interface = false;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004450 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Ian Rogers9bc81912012-10-11 21:43:36 -07004451 for (size_t i = 0; i < ifcount; ++i) {
4452 if (super_iftable->GetMethodArrayCount(i) > 0) {
4453 has_non_marker_interface = true;
4454 break;
4455 }
4456 }
4457 if (!has_non_marker_interface) {
4458 // Class just inherits marker interfaces from parent so recycle parent's iftable.
4459 klass->SetIfTable(super_iftable);
4460 return true;
4461 }
4462 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004463 StackHandleScope<4> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004464 Handle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount)));
4465 if (UNLIKELY(iftable.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004466 CHECK(self->IsExceptionPending()); // OOME.
4467 return false;
4468 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004469 if (super_ifcount != 0) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004470 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07004471 for (size_t i = 0; i < super_ifcount; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004472 mirror::Class* super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07004473 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07004474 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004475 }
4476 // Flatten the interface inheritance hierarchy.
4477 size_t idx = super_ifcount;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004478 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004479 mirror::Class* interface =
Mathieu Chartierf8322842014-05-16 10:59:25 -07004480 interfaces.Get() == nullptr ? mirror::Class::GetDirectInterface(self, klass, i) :
4481 interfaces->Get(i);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07004482 DCHECK(interface != NULL);
4483 if (!interface->IsInterface()) {
Ian Rogerscb6b0f32014-08-12 02:30:58 -07004484 std::string temp;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004485 ThrowIncompatibleClassChangeError(klass.Get(), "Class %s implements non-interface class %s",
4486 PrettyDescriptor(klass.Get()).c_str(),
Ian Rogerscb6b0f32014-08-12 02:30:58 -07004487 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004488 return false;
4489 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08004490 // Check if interface is already in iftable
4491 bool duplicate = false;
4492 for (size_t j = 0; j < idx; j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004493 mirror::Class* existing_interface = iftable->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08004494 if (existing_interface == interface) {
4495 duplicate = true;
4496 break;
4497 }
4498 }
4499 if (!duplicate) {
4500 // Add this non-duplicate interface.
Ian Rogers9bc81912012-10-11 21:43:36 -07004501 iftable->SetInterface(idx++, interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08004502 // Add this interface's non-duplicate super-interfaces.
4503 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004504 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
Ian Rogersb52b01a2012-01-12 17:01:38 -08004505 bool super_duplicate = false;
4506 for (size_t k = 0; k < idx; k++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004507 mirror::Class* existing_interface = iftable->GetInterface(k);
Ian Rogersb52b01a2012-01-12 17:01:38 -08004508 if (existing_interface == super_interface) {
4509 super_duplicate = true;
4510 break;
4511 }
4512 }
4513 if (!super_duplicate) {
Ian Rogers9bc81912012-10-11 21:43:36 -07004514 iftable->SetInterface(idx++, super_interface);
Ian Rogersb52b01a2012-01-12 17:01:38 -08004515 }
4516 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004517 }
4518 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08004519 // Shrink iftable in case duplicates were found
4520 if (idx < ifcount) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004521 iftable.Assign(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
4522 if (UNLIKELY(iftable.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004523 CHECK(self->IsExceptionPending()); // OOME.
4524 return false;
4525 }
Ian Rogersb52b01a2012-01-12 17:01:38 -08004526 ifcount = idx;
4527 } else {
4528 CHECK_EQ(idx, ifcount);
4529 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004530 klass->SetIfTable(iftable.Get());
Elliott Hughes4681c802011-09-25 18:04:37 -07004531
4532 // If we're an interface, we don't need the vtable pointers, so we're done.
Ian Rogers9bc81912012-10-11 21:43:36 -07004533 if (klass->IsInterface()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004534 return true;
4535 }
Jeff Hao88474b42013-10-23 16:24:40 -07004536 // Allocate imtable
4537 bool imtable_changed = false;
Ian Rogers700a4022014-05-19 16:49:03 -07004538 Handle<mirror::ObjectArray<mirror::ArtMethod>> imtable(
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004539 hs.NewHandle(AllocArtMethodArray(self, mirror::Class::kImtSize)));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004540 if (UNLIKELY(imtable.Get() == NULL)) {
Jeff Hao88474b42013-10-23 16:24:40 -07004541 CHECK(self->IsExceptionPending()); // OOME.
4542 return false;
4543 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004544 MethodHelper interface_mh(hs.NewHandle<mirror::ArtMethod>(nullptr));
4545 MethodHelper vtable_mh(hs.NewHandle<mirror::ArtMethod>(nullptr));
Brian Carlstromea46f952013-07-30 01:26:50 -07004546 std::vector<mirror::ArtMethod*> miranda_list;
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07004547 for (size_t i = 0; i < ifcount; ++i) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004548 size_t num_methods = iftable->GetInterface(i)->NumVirtualMethods();
Ian Rogers9bc81912012-10-11 21:43:36 -07004549 if (num_methods > 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004550 StackHandleScope<2> hs(self);
Ian Rogers700a4022014-05-19 16:49:03 -07004551 Handle<mirror::ObjectArray<mirror::ArtMethod>>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004552 method_array(hs.NewHandle(AllocArtMethodArray(self, num_methods)));
4553 if (UNLIKELY(method_array.Get() == nullptr)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004554 CHECK(self->IsExceptionPending()); // OOME.
4555 return false;
4556 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004557 iftable->SetMethodArray(i, method_array.Get());
Ian Rogers700a4022014-05-19 16:49:03 -07004558 Handle<mirror::ObjectArray<mirror::ArtMethod>> vtable(
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004559 hs.NewHandle(klass->GetVTableDuringLinking()));
Ian Rogers62d6c772013-02-27 08:32:07 -08004560 for (size_t j = 0; j < num_methods; ++j) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004561 mirror::ArtMethod* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004562 interface_mh.ChangeMethod(interface_method);
Ian Rogers9bc81912012-10-11 21:43:36 -07004563 int32_t k;
4564 // For each method listed in the interface's method list, find the
4565 // matching method in our class's method list. We want to favor the
4566 // subclass over the superclass, which just requires walking
4567 // back from the end of the vtable. (This only matters if the
4568 // superclass defines a private method and this class redefines
4569 // it -- otherwise it would use the same vtable slot. In .dex files
4570 // those don't end up in the virtual method table, so it shouldn't
4571 // matter which direction we go. We walk it backward anyway.)
4572 for (k = vtable->GetLength() - 1; k >= 0; --k) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004573 mirror::ArtMethod* vtable_method = vtable->Get(k);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004574 vtable_mh.ChangeMethod(vtable_method);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004575 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Elliott Hughes68243612013-02-22 17:16:07 -08004576 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Brian Carlstromf3632832014-05-20 15:36:53 -07004577 ThrowIllegalAccessError(
4578 klass.Get(),
4579 "Method '%s' implementing interface method '%s' is not public",
4580 PrettyMethod(vtable_method).c_str(),
4581 PrettyMethod(interface_method).c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07004582 return false;
4583 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004584 method_array->Set<false>(j, vtable_method);
Jeff Hao88474b42013-10-23 16:24:40 -07004585 // Place method in imt if entry is empty, place conflict otherwise.
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004586 uint32_t imt_index = interface_method->GetDexMethodIndex() % mirror::Class::kImtSize;
Jeff Hao88474b42013-10-23 16:24:40 -07004587 if (imtable->Get(imt_index) == NULL) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004588 imtable->Set<false>(imt_index, vtable_method);
Jeff Hao88474b42013-10-23 16:24:40 -07004589 imtable_changed = true;
4590 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004591 imtable->Set<false>(imt_index, runtime->GetImtConflictMethod());
Jeff Hao88474b42013-10-23 16:24:40 -07004592 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004593 break;
4594 }
4595 }
Ian Rogers9bc81912012-10-11 21:43:36 -07004596 if (k < 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004597 StackHandleScope<1> hs(self);
4598 auto miranda_method = hs.NewHandle<mirror::ArtMethod>(nullptr);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004599 for (mirror::ArtMethod* mir_method : miranda_list) {
4600 vtable_mh.ChangeMethod(mir_method);
Ian Rogers9bc81912012-10-11 21:43:36 -07004601 if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004602 miranda_method.Assign(mir_method);
Ian Rogers9bc81912012-10-11 21:43:36 -07004603 break;
4604 }
4605 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004606 if (miranda_method.Get() == NULL) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004607 // Point the interface table at a phantom slot.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004608 miranda_method.Assign(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
4609 if (UNLIKELY(miranda_method.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004610 CHECK(self->IsExceptionPending()); // OOME.
4611 return false;
4612 }
Ian Rogersa436fde2013-08-27 23:34:06 -07004613 // TODO: If a methods move then the miranda_list may hold stale references.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004614 miranda_list.push_back(miranda_method.Get());
Ian Rogers9bc81912012-10-11 21:43:36 -07004615 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004616 method_array->Set<false>(j, miranda_method.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004617 }
4618 }
4619 }
4620 }
Jeff Hao88474b42013-10-23 16:24:40 -07004621 if (imtable_changed) {
4622 // Fill in empty entries in interface method table with conflict.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004623 mirror::ArtMethod* imt_conflict_method = runtime->GetImtConflictMethod();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004624 for (size_t i = 0; i < mirror::Class::kImtSize; i++) {
Jeff Hao88474b42013-10-23 16:24:40 -07004625 if (imtable->Get(i) == NULL) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004626 imtable->Set<false>(i, imt_conflict_method);
Jeff Hao88474b42013-10-23 16:24:40 -07004627 }
4628 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004629 klass->SetImTable(imtable.Get());
Jeff Hao88474b42013-10-23 16:24:40 -07004630 }
Elliott Hughes4681c802011-09-25 18:04:37 -07004631 if (!miranda_list.empty()) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07004632 int old_method_count = klass->NumVirtualMethods();
Elliott Hughes4681c802011-09-25 18:04:37 -07004633 int new_method_count = old_method_count + miranda_list.size();
Ian Rogersa436fde2013-08-27 23:34:06 -07004634 mirror::ObjectArray<mirror::ArtMethod>* virtuals;
4635 if (old_method_count == 0) {
4636 virtuals = AllocArtMethodArray(self, new_method_count);
4637 } else {
4638 virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count);
4639 }
4640 if (UNLIKELY(virtuals == NULL)) {
4641 CHECK(self->IsExceptionPending()); // OOME.
4642 return false;
4643 }
4644 klass->SetVirtualMethods(virtuals);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004645
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004646 StackHandleScope<1> hs(self);
Ian Rogers700a4022014-05-19 16:49:03 -07004647 Handle<mirror::ObjectArray<mirror::ArtMethod>> vtable(
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004648 hs.NewHandle(klass->GetVTableDuringLinking()));
4649 CHECK(vtable.Get() != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004650 int old_vtable_count = vtable->GetLength();
Elliott Hughes4681c802011-09-25 18:04:37 -07004651 int new_vtable_count = old_vtable_count + miranda_list.size();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004652 vtable.Assign(vtable->CopyOf(self, new_vtable_count));
4653 if (UNLIKELY(vtable.Get() == NULL)) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004654 CHECK(self->IsExceptionPending()); // OOME.
4655 return false;
4656 }
Elliott Hughes4681c802011-09-25 18:04:37 -07004657 for (size_t i = 0; i < miranda_list.size(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004658 mirror::ArtMethod* method = miranda_list[i];
Ian Rogers9074b992011-10-26 17:41:55 -07004659 // Leave the declaring class alone as type indices are relative to it
Brian Carlstrom92827a52011-10-10 15:50:01 -07004660 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
4661 method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
4662 klass->SetVirtualMethod(old_method_count + i, method);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004663 vtable->Set<false>(old_vtable_count + i, method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004664 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004665 // TODO: do not assign to the vtable field until it is fully constructed.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004666 klass->SetVTable(vtable.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004667 }
Elliott Hughes4681c802011-09-25 18:04:37 -07004668
Brian Carlstromea46f952013-07-30 01:26:50 -07004669 mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
Elliott Hughes4681c802011-09-25 18:04:37 -07004670 for (int i = 0; i < vtable->GetLength(); ++i) {
4671 CHECK(vtable->Get(i) != NULL);
4672 }
4673
4674// klass->DumpClass(std::cerr, Class::kDumpClassFullDetail);
4675
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004676 return true;
4677}
4678
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004679bool ClassLinker::LinkInstanceFields(Handle<mirror::Class> klass) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004680 CHECK(klass.Get() != NULL);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004681 return LinkFields(klass, false, nullptr);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004682}
4683
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004684bool ClassLinker::LinkStaticFields(Handle<mirror::Class> klass, size_t* class_size) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004685 CHECK(klass.Get() != NULL);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004686 return LinkFields(klass, true, class_size);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004687}
4688
Brian Carlstromdbc05252011-09-09 01:59:59 -07004689struct LinkFieldsComparator {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004690 explicit LinkFieldsComparator() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
4691 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004692 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Ian Rogersef7d42f2014-01-06 12:55:46 -08004693 bool operator()(mirror::ArtField* field1, mirror::ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004694 NO_THREAD_SAFETY_ANALYSIS {
Brian Carlstromdbc05252011-09-09 01:59:59 -07004695 // First come reference fields, then 64-bit, and finally 32-bit
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004696 Primitive::Type type1 = field1->GetTypeAsPrimitiveType();
4697 Primitive::Type type2 = field2->GetTypeAsPrimitiveType();
Ian Rogersef7d42f2014-01-06 12:55:46 -08004698 if (type1 != type2) {
4699 bool is_primitive1 = type1 != Primitive::kPrimNot;
4700 bool is_primitive2 = type2 != Primitive::kPrimNot;
Brian Carlstromf3632832014-05-20 15:36:53 -07004701 bool is64bit1 = is_primitive1 && (type1 == Primitive::kPrimLong ||
4702 type1 == Primitive::kPrimDouble);
4703 bool is64bit2 = is_primitive2 && (type2 == Primitive::kPrimLong ||
4704 type2 == Primitive::kPrimDouble);
Ian Rogersef7d42f2014-01-06 12:55:46 -08004705 int order1 = !is_primitive1 ? 0 : (is64bit1 ? 1 : 2);
4706 int order2 = !is_primitive2 ? 0 : (is64bit2 ? 1 : 2);
4707 if (order1 != order2) {
4708 return order1 < order2;
4709 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07004710 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07004711 // same basic group? then sort by string.
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004712 return strcmp(field1->GetName(), field2->GetName()) < 0;
Brian Carlstromdbc05252011-09-09 01:59:59 -07004713 }
4714};
4715
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004716bool ClassLinker::LinkFields(Handle<mirror::Class> klass, bool is_static, size_t* class_size) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004717 size_t num_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004718 is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004719
Brian Carlstromea46f952013-07-30 01:26:50 -07004720 mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004721 is_static ? klass->GetSFields() : klass->GetIFields();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004722
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004723 // Initialize field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07004724 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004725 if (is_static) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004726 uint32_t base = sizeof(mirror::Class); // Static fields come after the class.
4727 if (klass->ShouldHaveEmbeddedImtAndVTable()) {
4728 // Static fields come after the embedded tables.
4729 base = mirror::Class::ComputeClassSize(true, klass->GetVTableDuringLinking()->GetLength(),
4730 0, 0, 0);
4731 }
4732 field_offset = MemberOffset(base);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004733 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004734 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004735 if (super_class != NULL) {
Brian Carlstromf3632832014-05-20 15:36:53 -07004736 CHECK(super_class->IsResolved())
4737 << PrettyClass(klass.Get()) << " " << PrettyClass(super_class);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004738 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004739 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004740 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004741
Brian Carlstromf3632832014-05-20 15:36:53 -07004742 CHECK_EQ(num_fields == 0, fields == NULL) << PrettyClass(klass.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004743
Brian Carlstromdbc05252011-09-09 01:59:59 -07004744 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07004745 // minimizes disruption of C++ version such as Class and Method.
Brian Carlstromea46f952013-07-30 01:26:50 -07004746 std::deque<mirror::ArtField*> grouped_and_sorted_fields;
Brian Carlstromdbc05252011-09-09 01:59:59 -07004747 for (size_t i = 0; i < num_fields; i++) {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004748 mirror::ArtField* f = fields->Get(i);
Brian Carlstromf3632832014-05-20 15:36:53 -07004749 CHECK(f != NULL) << PrettyClass(klass.Get());
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004750 grouped_and_sorted_fields.push_back(f);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004751 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07004752 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
4753 LinkFieldsComparator());
Brian Carlstromdbc05252011-09-09 01:59:59 -07004754
4755 // References should be at the front.
4756 size_t current_field = 0;
4757 size_t num_reference_fields = 0;
4758 for (; current_field < num_fields; current_field++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004759 mirror::ArtField* field = grouped_and_sorted_fields.front();
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004760 Primitive::Type type = field->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07004761 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07004762 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004763 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004764 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07004765 grouped_and_sorted_fields.pop_front();
4766 num_reference_fields++;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004767 fields->Set<false>(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004768 field->SetOffset(field_offset);
4769 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004770 }
4771
4772 // Now we want to pack all of the double-wide fields together. If
4773 // we're not aligned, though, we want to shuffle one 32-bit field
4774 // into place. If we can't find one, we'll have to pad it.
Elliott Hughes06b37d92011-10-16 11:51:29 -07004775 if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07004776 for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004777 mirror::ArtField* field = grouped_and_sorted_fields[i];
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004778 Primitive::Type type = field->GetTypeAsPrimitiveType();
Brian Carlstromf3632832014-05-20 15:36:53 -07004779 CHECK(type != Primitive::kPrimNot) << PrettyField(field); // should be primitive types
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07004780 if (type == Primitive::kPrimLong || type == Primitive::kPrimDouble) {
Brian Carlstromdbc05252011-09-09 01:59:59 -07004781 continue;
4782 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004783 fields->Set<false>(current_field++, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004784 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004785 // drop the consumed field
4786 grouped_and_sorted_fields.erase(grouped_and_sorted_fields.begin() + i);
4787 break;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004788 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07004789 // whether we found a 32-bit field for padding or not, we advance
4790 field_offset = MemberOffset(field_offset.Uint32Value() + sizeof(uint32_t));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004791 }
4792
4793 // Alignment is good, shuffle any double-wide fields forward, and
4794 // finish assigning field offsets to all fields.
Brian Carlstromf3632832014-05-20 15:36:53 -07004795 DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()))
4796 << PrettyClass(klass.Get());
Brian Carlstromdbc05252011-09-09 01:59:59 -07004797 while (!grouped_and_sorted_fields.empty()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07004798 mirror::ArtField* field = grouped_and_sorted_fields.front();
Brian Carlstromdbc05252011-09-09 01:59:59 -07004799 grouped_and_sorted_fields.pop_front();
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004800 Primitive::Type type = field->GetTypeAsPrimitiveType();
Brian Carlstromf3632832014-05-20 15:36:53 -07004801 CHECK(type != Primitive::kPrimNot) << PrettyField(field); // should be primitive types
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004802 fields->Set<false>(current_field, field);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004803 field->SetOffset(field_offset);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004804 field_offset = MemberOffset(field_offset.Uint32Value() +
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07004805 ((type == Primitive::kPrimLong || type == Primitive::kPrimDouble)
Brian Carlstromdbc05252011-09-09 01:59:59 -07004806 ? sizeof(uint64_t)
4807 : sizeof(uint32_t)));
4808 current_field++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004809 }
4810
Elliott Hughesadb460d2011-10-05 17:02:34 -07004811 // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004812 if (!is_static && klass->DescriptorEquals("Ljava/lang/ref/Reference;")) {
Elliott Hughesadb460d2011-10-05 17:02:34 -07004813 // We know there are no non-reference fields in the Reference classes, and we know
4814 // that 'referent' is alphabetically last, so this is easy...
Brian Carlstromf3632832014-05-20 15:36:53 -07004815 CHECK_EQ(num_reference_fields, num_fields) << PrettyClass(klass.Get());
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004816 CHECK_STREQ(fields->Get(num_fields - 1)->GetName(), "referent") << PrettyClass(klass.Get());
Elliott Hughesadb460d2011-10-05 17:02:34 -07004817 --num_reference_fields;
4818 }
4819
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004820 if (kIsDebugBuild) {
4821 // Make sure that all reference fields appear before
4822 // non-reference fields, and all double-wide fields are aligned.
4823 bool seen_non_ref = false;
4824 for (size_t i = 0; i < num_fields; i++) {
4825 mirror::ArtField* field = fields->Get(i);
4826 if (false) { // enable to debug field layout
4827 LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004828 << " class=" << PrettyClass(klass.Get())
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004829 << " field=" << PrettyField(field)
Ian Rogersb0fa5dc2014-04-28 16:47:08 -07004830 << " offset="
4831 << field->GetField32(MemberOffset(mirror::ArtField::OffsetOffset()));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004832 }
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004833 Primitive::Type type = field->GetTypeAsPrimitiveType();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004834 bool is_primitive = type != Primitive::kPrimNot;
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004835 if (klass->DescriptorEquals("Ljava/lang/ref/Reference;") &&
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07004836 strcmp("referent", field->GetName()) == 0) {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004837 is_primitive = true; // We lied above, so we have to expect a lie here.
4838 }
4839 if (is_primitive) {
4840 if (!seen_non_ref) {
4841 seen_non_ref = true;
Brian Carlstromf3632832014-05-20 15:36:53 -07004842 DCHECK_EQ(num_reference_fields, i) << PrettyField(field);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004843 }
4844 } else {
Brian Carlstromf3632832014-05-20 15:36:53 -07004845 DCHECK(!seen_non_ref) << PrettyField(field);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004846 }
4847 }
4848 if (!seen_non_ref) {
Brian Carlstromf3632832014-05-20 15:36:53 -07004849 DCHECK_EQ(num_fields, num_reference_fields) << PrettyClass(klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004850 }
4851 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004852
4853 size_t size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004854 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004855 if (is_static) {
4856 klass->SetNumReferenceStaticFields(num_reference_fields);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004857 *class_size = size;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004858 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004859 klass->SetNumReferenceInstanceFields(num_reference_fields);
Brian Carlstromdbc05252011-09-09 01:59:59 -07004860 if (!klass->IsVariableSize()) {
Ian Rogerscb6b0f32014-08-12 02:30:58 -07004861 std::string temp;
4862 DCHECK_GE(size, sizeof(mirror::Object)) << klass->GetDescriptor(&temp);
Mathieu Chartier79b4f382013-10-23 15:21:37 -07004863 size_t previous_size = klass->GetObjectSize();
4864 if (previous_size != 0) {
4865 // Make sure that we didn't originally have an incorrect size.
Ian Rogerscb6b0f32014-08-12 02:30:58 -07004866 CHECK_EQ(previous_size, size) << klass->GetDescriptor(&temp);
Mathieu Chartier79b4f382013-10-23 15:21:37 -07004867 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004868 klass->SetObjectSize(size);
4869 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004870 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004871 return true;
4872}
4873
4874// Set the bitmap of reference offsets, refOffsets, from the ifields
4875// list.
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004876void ClassLinker::CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004877 uint32_t reference_offsets = 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004878 mirror::Class* super_class = klass->GetSuperClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004879 if (super_class != NULL) {
4880 reference_offsets = super_class->GetReferenceInstanceOffsets();
Brian Carlstrom4873d462011-08-21 15:23:39 -07004881 // If our superclass overflowed, we don't stand a chance.
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004882 if (reference_offsets == CLASS_WALK_SUPER) {
4883 klass->SetReferenceInstanceOffsets(reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004884 return;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004885 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004886 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004887 CreateReferenceOffsets(klass, false, reference_offsets);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004888}
4889
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004890void ClassLinker::CreateReferenceStaticOffsets(Handle<mirror::Class> klass) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004891 CreateReferenceOffsets(klass, true, 0);
Brian Carlstrom4873d462011-08-21 15:23:39 -07004892}
4893
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004894void ClassLinker::CreateReferenceOffsets(Handle<mirror::Class> klass, bool is_static,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004895 uint32_t reference_offsets) {
4896 size_t num_reference_fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004897 is_static ? klass->NumReferenceStaticFieldsDuringLinking()
4898 : klass->NumReferenceInstanceFieldsDuringLinking();
Ian Rogersef7d42f2014-01-06 12:55:46 -08004899 mirror::ObjectArray<mirror::ArtField>* fields =
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004900 is_static ? klass->GetSFields() : klass->GetIFields();
Brian Carlstrom4873d462011-08-21 15:23:39 -07004901 // All of the fields that contain object references are guaranteed
4902 // to be at the beginning of the fields list.
4903 for (size_t i = 0; i < num_reference_fields; ++i) {
4904 // Note that byte_offset is the offset from the beginning of
4905 // object, not the offset into instance data
Ian Rogersef7d42f2014-01-06 12:55:46 -08004906 mirror::ArtField* field = fields->Get(i);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004907 MemberOffset byte_offset = field->GetOffsetDuringLinking();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004908 CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
4909 if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
4910 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset.Uint32Value());
Brian Carlstrom4873d462011-08-21 15:23:39 -07004911 CHECK_NE(new_bit, 0U);
4912 reference_offsets |= new_bit;
4913 } else {
4914 reference_offsets = CLASS_WALK_SUPER;
4915 break;
4916 }
4917 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004918 // Update fields in klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004919 if (is_static) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004920 klass->SetReferenceStaticOffsets(reference_offsets);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07004921 } else {
4922 klass->SetReferenceInstanceOffsets(reference_offsets);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004923 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004924}
4925
Mathieu Chartier590fee92013-09-13 13:46:47 -07004926mirror::String* ClassLinker::ResolveString(const DexFile& dex_file, uint32_t string_idx,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004927 Handle<mirror::DexCache> dex_cache) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004928 DCHECK(dex_cache.Get() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004929 mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004930 if (resolved != NULL) {
4931 return resolved;
4932 }
Ian Rogersdfb325e2013-10-30 01:00:44 -07004933 uint32_t utf16_length;
4934 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004935 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004936 dex_cache->SetResolvedString(string_idx, string);
4937 return string;
4938}
4939
Mathieu Chartier590fee92013-09-13 13:46:47 -07004940mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
Ian Rogersef7d42f2014-01-06 12:55:46 -08004941 mirror::Class* referrer) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004942 StackHandleScope<2> hs(Thread::Current());
4943 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
4944 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
Mathieu Chartier590fee92013-09-13 13:46:47 -07004945 return ResolveType(dex_file, type_idx, dex_cache, class_loader);
4946}
4947
4948mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004949 Handle<mirror::DexCache> dex_cache,
4950 Handle<mirror::ClassLoader> class_loader) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004951 DCHECK(dex_cache.Get() != NULL);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004952 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004953 if (resolved == NULL) {
Ian Rogers98379392014-02-24 16:53:16 -08004954 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07004955 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Ian Rogers98379392014-02-24 16:53:16 -08004956 resolved = FindClass(self, descriptor, class_loader);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004957 if (resolved != NULL) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05004958 // TODO: we used to throw here if resolved's class loader was not the
4959 // boot class loader. This was to permit different classes with the
4960 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004961 dex_cache->SetResolvedType(type_idx, resolved);
4962 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08004963 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08004964 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08004965 // Convert a ClassNotFoundException to a NoClassDefFoundError.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004966 StackHandleScope<1> hs(self);
4967 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException(nullptr)));
Ian Rogers62d6c772013-02-27 08:32:07 -08004968 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004969 DCHECK(resolved == NULL); // No Handle needed to preserve resolved.
Ian Rogers98379392014-02-24 16:53:16 -08004970 self->ClearException();
jeffhao8cd6dda2012-02-22 10:15:34 -08004971 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004972 self->GetException(NULL)->SetCause(cause.Get());
jeffhao8cd6dda2012-02-22 10:15:34 -08004973 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07004974 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004975 }
Brian Carlstromabcf7ae2013-09-23 22:19:52 -07004976 DCHECK((resolved == NULL) || resolved->IsResolved() || resolved->IsErroneous())
4977 << PrettyDescriptor(resolved) << " " << resolved->GetStatus();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004978 return resolved;
4979}
4980
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004981mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file, uint32_t method_idx,
4982 Handle<mirror::DexCache> dex_cache,
4983 Handle<mirror::ClassLoader> class_loader,
4984 Handle<mirror::ArtMethod> referrer,
Ian Rogersd91d6d62013-09-25 20:26:14 -07004985 InvokeType type) {
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07004986 DCHECK(dex_cache.Get() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07004987 // Check for hit in the dex cache.
Brian Carlstromea46f952013-07-30 01:26:50 -07004988 mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
Mathieu Chartier0cd81352014-05-22 16:48:55 -07004989 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004990 return resolved;
4991 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004992 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004993 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004994 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07004995 if (klass == nullptr) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07004996 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07004997 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07004998 }
Ian Rogers08f753d2012-08-24 14:35:25 -07004999 // Scan using method_idx, this saves string compares but will only hit for matching dex
5000 // caches/files.
5001 switch (type) {
5002 case kDirect: // Fall-through.
5003 case kStatic:
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005004 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx);
Ian Rogers08f753d2012-08-24 14:35:25 -07005005 break;
5006 case kInterface:
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005007 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx);
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005008 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07005009 break;
5010 case kSuper: // Fall-through.
5011 case kVirtual:
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005012 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx);
Ian Rogers08f753d2012-08-24 14:35:25 -07005013 break;
5014 default:
5015 LOG(FATAL) << "Unreachable - invocation type: " << type;
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07005016 }
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005017 if (resolved == nullptr) {
Ian Rogers08f753d2012-08-24 14:35:25 -07005018 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005019 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07005020 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07005021 switch (type) {
5022 case kDirect: // Fall-through.
5023 case kStatic:
jeffhao8cd6dda2012-02-22 10:15:34 -08005024 resolved = klass->FindDirectMethod(name, signature);
Ian Rogers08f753d2012-08-24 14:35:25 -07005025 break;
5026 case kInterface:
5027 resolved = klass->FindInterfaceMethod(name, signature);
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005028 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07005029 break;
5030 case kSuper: // Fall-through.
5031 case kVirtual:
5032 resolved = klass->FindVirtualMethod(name, signature);
5033 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005034 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07005035 }
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005036 // If we found a method, check for incompatible class changes.
5037 if (LIKELY(resolved != nullptr && !resolved->CheckIncompatibleClassChange(type))) {
Ian Rogers08f753d2012-08-24 14:35:25 -07005038 // Be a good citizen and update the dex cache to speed subsequent calls.
5039 dex_cache->SetResolvedMethod(method_idx, resolved);
5040 return resolved;
5041 } else {
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005042 // If we had a method, it's an incompatible-class-change error.
5043 if (resolved != nullptr) {
5044 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer.Get());
5045 } else {
5046 // We failed to find the method which means either an access error, an incompatible class
5047 // change, or no such method. First try to find the method among direct and virtual methods.
5048 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
5049 const Signature signature = dex_file.GetMethodSignature(method_id);
5050 switch (type) {
5051 case kDirect:
5052 case kStatic:
Ian Rogers08f753d2012-08-24 14:35:25 -07005053 resolved = klass->FindVirtualMethod(name, signature);
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005054 // Note: kDirect and kStatic are also mutually exclusive, but in that case we would
5055 // have had a resolved method before, which triggers the "true" branch above.
5056 break;
5057 case kInterface:
5058 case kVirtual:
5059 case kSuper:
5060 resolved = klass->FindDirectMethod(name, signature);
5061 break;
5062 }
5063
5064 // If we found something, check that it can be accessed by the referrer.
5065 if (resolved != nullptr && referrer.Get() != nullptr) {
5066 mirror::Class* methods_class = resolved->GetDeclaringClass();
5067 mirror::Class* referring_class = referrer->GetDeclaringClass();
5068 if (!referring_class->CanAccess(methods_class)) {
5069 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
5070 resolved, type);
5071 return nullptr;
5072 } else if (!referring_class->CanAccessMember(methods_class,
5073 resolved->GetAccessFlags())) {
5074 ThrowIllegalAccessErrorMethod(referring_class, resolved);
5075 return nullptr;
5076 }
5077 }
5078
5079 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check interface
5080 // methods and throw if we find the method there. If we find nothing, throw a
5081 // NoSuchMethodError.
5082 switch (type) {
5083 case kDirect:
5084 case kStatic:
5085 if (resolved != nullptr) {
Mathieu Chartier0cd81352014-05-22 16:48:55 -07005086 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer.Get());
Ian Rogers08f753d2012-08-24 14:35:25 -07005087 } else {
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005088 resolved = klass->FindInterfaceMethod(name, signature);
5089 if (resolved != nullptr) {
5090 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer.Get());
5091 } else {
5092 ThrowNoSuchMethodError(type, klass, name, signature);
5093 }
Ian Rogers08f753d2012-08-24 14:35:25 -07005094 }
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005095 break;
5096 case kInterface:
5097 if (resolved != nullptr) {
5098 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer.Get());
Ian Rogers08f753d2012-08-24 14:35:25 -07005099 } else {
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005100 resolved = klass->FindVirtualMethod(name, signature);
5101 if (resolved != nullptr) {
5102 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer.Get());
5103 } else {
5104 ThrowNoSuchMethodError(type, klass, name, signature);
5105 }
Ian Rogers08f753d2012-08-24 14:35:25 -07005106 }
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005107 break;
5108 case kSuper:
Andreas Gampe9cb8d7a2014-08-25 20:55:01 -07005109 if (resolved != nullptr) {
5110 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer.Get());
5111 } else {
5112 ThrowNoSuchMethodError(type, klass, name, signature);
5113 }
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005114 break;
5115 case kVirtual:
5116 if (resolved != nullptr) {
5117 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer.Get());
5118 } else {
5119 resolved = klass->FindInterfaceMethod(name, signature);
5120 if (resolved != nullptr) {
5121 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer.Get());
5122 } else {
5123 ThrowNoSuchMethodError(type, klass, name, signature);
5124 }
5125 }
5126 break;
5127 }
Ian Rogers08f753d2012-08-24 14:35:25 -07005128 }
5129 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampeb5d1efa2014-08-13 21:49:37 -07005130 return nullptr;
Ian Rogers08f753d2012-08-24 14:35:25 -07005131 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005132}
5133
Mathieu Chartier590fee92013-09-13 13:46:47 -07005134mirror::ArtField* ClassLinker::ResolveField(const DexFile& dex_file, uint32_t field_idx,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07005135 Handle<mirror::DexCache> dex_cache,
5136 Handle<mirror::ClassLoader> class_loader,
Brian Carlstrome8104522013-10-15 21:56:36 -07005137 bool is_static) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005138 DCHECK(dex_cache.Get() != nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -07005139 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Andreas Gampe4ef12f52014-07-31 16:23:49 -07005140 if (resolved != nullptr) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07005141 return resolved;
5142 }
5143 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07005144 Thread* const self = Thread::Current();
5145 StackHandleScope<1> hs(self);
5146 Handle<mirror::Class> klass(
5147 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader)));
Andreas Gampe4ef12f52014-07-31 16:23:49 -07005148 if (klass.Get() == nullptr) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08005149 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe4ef12f52014-07-31 16:23:49 -07005150 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07005151 }
5152
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07005153 if (is_static) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07005154 resolved = mirror::Class::FindStaticField(self, klass, dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07005155 } else {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005156 resolved = klass->FindInstanceField(dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07005157 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005158
Andreas Gampe4ef12f52014-07-31 16:23:49 -07005159 if (resolved == nullptr) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005160 const char* name = dex_file.GetFieldName(field_id);
5161 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
5162 if (is_static) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07005163 resolved = mirror::Class::FindStaticField(self, klass, name, type);
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005164 } else {
5165 resolved = klass->FindInstanceField(name, type);
5166 }
Andreas Gampe4ef12f52014-07-31 16:23:49 -07005167 if (resolved == nullptr) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07005168 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass.Get(), type, name);
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005169 return NULL;
5170 }
Ian Rogersb067ac22011-12-13 18:05:09 -08005171 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005172 dex_cache->SetResolvedField(field_idx, resolved);
Ian Rogersb067ac22011-12-13 18:05:09 -08005173 return resolved;
5174}
5175
Brian Carlstromea46f952013-07-30 01:26:50 -07005176mirror::ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005177 uint32_t field_idx,
Mathieu Chartier0cd81352014-05-22 16:48:55 -07005178 Handle<mirror::DexCache> dex_cache,
5179 Handle<mirror::ClassLoader> class_loader) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005180 DCHECK(dex_cache.Get() != nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -07005181 mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
Andreas Gampe4ef12f52014-07-31 16:23:49 -07005182 if (resolved != nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08005183 return resolved;
5184 }
5185 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07005186 Thread* self = Thread::Current();
5187 StackHandleScope<1> hs(self);
5188 Handle<mirror::Class> klass(
5189 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader)));
5190 if (klass.Get() == NULL) {
Ian Rogersb067ac22011-12-13 18:05:09 -08005191 DCHECK(Thread::Current()->IsExceptionPending());
5192 return NULL;
5193 }
5194
Ian Rogersdfb325e2013-10-30 01:00:44 -07005195 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
5196 StringPiece type(dex_file.StringDataByIdx(
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005197 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
Mathieu Chartierf8322842014-05-16 10:59:25 -07005198 resolved = mirror::Class::FindField(self, klass, name, type);
Ian Rogersb067ac22011-12-13 18:05:09 -08005199 if (resolved != NULL) {
5200 dex_cache->SetResolvedField(field_idx, resolved);
5201 } else {
Mathieu Chartierf8322842014-05-16 10:59:25 -07005202 ThrowNoSuchFieldError("", klass.Get(), type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07005203 }
5204 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07005205}
5206
Brian Carlstromea46f952013-07-30 01:26:50 -07005207const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005208 uint32_t* length) {
5209 mirror::Class* declaring_class = referrer->GetDeclaringClass();
5210 mirror::DexCache* dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07005211 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07005212 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08005213 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07005214}
5215
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005216void ClassLinker::DumpAllClasses(int flags) {
5217 if (dex_cache_image_class_lookup_required_) {
5218 MoveImageClassesToClassTable();
5219 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07005220 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
5221 // 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 -08005222 std::vector<mirror::Class*> all_classes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07005223 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07005224 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07005225 for (std::pair<const size_t, GcRoot<mirror::Class> >& it : class_table_) {
5226 mirror::Class* klass = it.second.Read();
Hiroshi Yamauchia91a4bc2014-06-13 16:44:55 -07005227 all_classes.push_back(klass);
Ian Rogers5d76c432011-10-31 21:42:49 -07005228 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07005229 }
5230
5231 for (size_t i = 0; i < all_classes.size(); ++i) {
5232 all_classes[i]->DumpClass(std::cerr, flags);
5233 }
5234}
5235
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005236void ClassLinker::DumpForSigQuit(std::ostream& os) {
5237 if (dex_cache_image_class_lookup_required_) {
5238 MoveImageClassesToClassTable();
5239 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07005240 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005241 os << "Loaded classes: " << class_table_.size() << " allocated classes\n";
Elliott Hughescac6cc72011-11-03 20:31:21 -07005242}
5243
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005244size_t ClassLinker::NumLoadedClasses() {
5245 if (dex_cache_image_class_lookup_required_) {
5246 MoveImageClassesToClassTable();
5247 }
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07005248 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005249 return class_table_.size();
Elliott Hughese27955c2011-08-26 15:21:24 -07005250}
5251
Brian Carlstrom47d237a2011-10-18 15:08:33 -07005252pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07005253 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07005254}
5255
5256pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07005257 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07005258}
5259
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005260void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005261 DCHECK(!init_done_);
5262
5263 DCHECK(klass != NULL);
5264 DCHECK(klass->GetClassLoader() == NULL);
5265
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07005266 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07005267 DCHECK(class_roots != NULL);
5268 DCHECK(class_roots->Get(class_root) == NULL);
5269 class_roots->Set<false>(class_root, klass);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005270}
5271
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005272} // namespace art