blob: 46f16449ed1f5a4a993db3461666fb6180c1e7c7 [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
Alex Lighteb7c1442015-08-31 13:17:42 -070019#include <algorithm>
Brian Carlstromdbc05252011-09-09 01:59:59 -070020#include <deque>
Ian Rogerscf7f1912014-10-22 22:06:39 -070021#include <iostream>
Vladimir Marko21300532017-01-24 18:06:55 +000022#include <map>
Ian Rogers700a4022014-05-19 16:49:03 -070023#include <memory>
Fred Shih381e4ca2014-08-25 17:24:27 -070024#include <queue>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070025#include <string>
Alex Lighteb7c1442015-08-31 13:17:42 -070026#include <tuple>
Andreas Gampea696c0a2014-12-10 20:51:45 -080027#include <unistd.h>
Alex Lighteb7c1442015-08-31 13:17:42 -070028#include <unordered_map>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070029#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070030#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070031
Andreas Gampe46ee31b2016-12-14 10:11:49 -080032#include "android-base/stringprintf.h"
33
Mathieu Chartierc7853442015-03-27 14:35:38 -070034#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070035#include "art_method-inl.h"
36#include "base/arena_allocator.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080037#include "base/casts.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080038#include "base/logging.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070039#include "base/scoped_arena_containers.h"
Narayan Kamathd1c606f2014-06-09 16:50:19 +010040#include "base/scoped_flock.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080041#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080042#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010043#include "base/time_utils.h"
Elliott Hughes76160052012-12-12 16:31:20 -080044#include "base/unix_file/fd_file.h"
Andreas Gampeb9aec2c2015-04-23 22:23:47 -070045#include "base/value_object.h"
Mingyao Yang063fc772016-08-02 11:02:54 -070046#include "cha.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080047#include "class_linker-inl.h"
Mathieu Chartiere4275c02015-08-06 15:34:15 -070048#include "class_table-inl.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000049#include "compiler_callbacks.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080050#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070051#include "dex_file-inl.h"
Mathieu Chartiere58991b2015-10-13 07:59:34 -070052#include "entrypoints/entrypoint_utils.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070053#include "entrypoints/runtime_asm_entrypoints.h"
Alex Light705ad492015-09-21 11:36:30 -070054#include "experimental_flags.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070055#include "gc_root-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070056#include "gc/accounting/card_table-inl.h"
Mathieu Chartier03c1dd92016-03-07 16:13:54 -080057#include "gc/accounting/heap_bitmap-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070058#include "gc/heap.h"
Mathieu Chartier1b1e31f2016-05-19 10:13:04 -070059#include "gc/scoped_gc_critical_section.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070060#include "gc/space/image_space.h"
Vladimir Markobfb80d22017-02-14 14:08:12 +000061#include "gc/space/space-inl.h"
Mathieu Chartiere58991b2015-10-13 07:59:34 -070062#include "handle_scope-inl.h"
Mathieu Chartier4a26f172016-01-26 14:26:18 -080063#include "image-inl.h"
Andreas Gampe75a7db62016-09-26 12:04:26 -070064#include "imt_conflict_table.h"
65#include "imtable-inl.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070066#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070067#include "interpreter/interpreter.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080068#include "jit/jit.h"
69#include "jit/jit_code_cache.h"
Calin Juravle33083d62017-01-18 15:29:12 -080070#include "jit/profile_compilation_info.h"
Andreas Gampe08883de2016-11-08 13:20:52 -080071#include "jni_internal.h"
Ian Rogers0571d352011-11-03 19:51:38 -070072#include "leb128.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070073#include "linear_alloc.h"
Orion Hodsonc069a302017-01-18 09:23:12 +000074#include "mirror/call_site.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080075#include "mirror/class.h"
76#include "mirror/class-inl.h"
Alex Lightd6251582016-10-31 11:12:30 -070077#include "mirror/class_ext.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080078#include "mirror/class_loader.h"
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -070079#include "mirror/dex_cache.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070080#include "mirror/dex_cache-inl.h"
Narayan Kamath000e1882016-10-24 17:14:25 +010081#include "mirror/emulated_stack_frame.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -070082#include "mirror/field.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080083#include "mirror/iftable-inl.h"
Mathieu Chartierfc58af42015-04-16 18:00:39 -070084#include "mirror/method.h"
Narayan Kamathafa48272016-08-03 12:46:58 +010085#include "mirror/method_type.h"
86#include "mirror/method_handle_impl.h"
Orion Hodsonc069a302017-01-18 09:23:12 +000087#include "mirror/method_handles_lookup.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080088#include "mirror/object-inl.h"
89#include "mirror/object_array-inl.h"
90#include "mirror/proxy.h"
Fred Shih4ee7a662014-07-11 09:59:27 -070091#include "mirror/reference-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080092#include "mirror/stack_trace_element.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070093#include "mirror/string-inl.h"
Mathieu Chartiere58991b2015-10-13 07:59:34 -070094#include "native/dalvik_system_DexFile.h"
95#include "oat.h"
96#include "oat_file.h"
97#include "oat_file-inl.h"
98#include "oat_file_assistant.h"
99#include "oat_file_manager.h"
100#include "object_lock.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800101#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -0700102#include "runtime.h"
Andreas Gampeac30fa22017-01-18 21:02:36 -0800103#include "runtime_callbacks.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700104#include "ScopedLocalRef.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -0700105#include "scoped_thread_state_change-inl.h"
Ian Rogers7b078e82014-09-10 14:44:24 -0700106#include "thread-inl.h"
Mingyao Yang063fc772016-08-02 11:02:54 -0700107#include "thread_list.h"
Mathieu Chartier7778b882015-10-05 16:41:10 -0700108#include "trace.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700109#include "utils.h"
Vladimir Marko05792b92015-08-03 11:56:49 +0100110#include "utils/dex_cache_arrays_layout-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800111#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -0700112#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700113
114namespace art {
115
Andreas Gampe46ee31b2016-12-14 10:11:49 -0800116using android::base::StringPrintf;
117
Mathieu Chartierc7853442015-03-27 14:35:38 -0700118static constexpr bool kSanityCheckObjects = kIsDebugBuild;
Mathieu Chartier8790c7f2016-03-31 15:05:45 -0700119static constexpr bool kVerifyArtMethodDeclaringClasses = kIsDebugBuild;
Mathieu Chartierc7853442015-03-27 14:35:38 -0700120
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700121static void ThrowNoClassDefFoundError(const char* fmt, ...)
122 __attribute__((__format__(__printf__, 1, 2)))
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700123 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -0700124static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700125 va_list args;
126 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -0800127 Thread* self = Thread::Current();
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000128 self->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -0800129 va_end(args);
130}
131
Andreas Gampe99babb62015-11-02 16:20:00 -0800132static bool HasInitWithString(Thread* self, ClassLinker* class_linker, const char* descriptor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700133 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700134 ArtMethod* method = self->GetCurrentMethod(nullptr);
Andreas Gampebfdcdc12015-04-22 18:10:36 -0700135 StackHandleScope<1> hs(self);
136 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(method != nullptr ?
Mathieu Chartier90443472015-07-16 20:32:27 -0700137 method->GetDeclaringClass()->GetClassLoader() : nullptr));
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700138 ObjPtr<mirror::Class> exception_class = class_linker->FindClass(self, descriptor, class_loader);
Andreas Gampebfdcdc12015-04-22 18:10:36 -0700139
140 if (exception_class == nullptr) {
141 // No exc class ~ no <init>-with-string.
142 CHECK(self->IsExceptionPending());
143 self->ClearException();
144 return false;
145 }
146
Mathieu Chartiere401d142015-04-22 13:56:20 -0700147 ArtMethod* exception_init_method = exception_class->FindDeclaredDirectMethod(
Andreas Gampe99babb62015-11-02 16:20:00 -0800148 "<init>", "(Ljava/lang/String;)V", class_linker->GetImagePointerSize());
Andreas Gampebfdcdc12015-04-22 18:10:36 -0700149 return exception_init_method != nullptr;
150}
151
Alex Lightd6251582016-10-31 11:12:30 -0700152static mirror::Object* GetVerifyError(ObjPtr<mirror::Class> c)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700153 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lightd6251582016-10-31 11:12:30 -0700154 ObjPtr<mirror::ClassExt> ext(c->GetExtData());
155 if (ext == nullptr) {
156 return nullptr;
157 } else {
158 return ext->GetVerifyError();
159 }
160}
161
162// Helper for ThrowEarlierClassFailure. Throws the stored error.
163static void HandleEarlierVerifyError(Thread* self,
164 ClassLinker* class_linker,
165 ObjPtr<mirror::Class> c)
166 REQUIRES_SHARED(Locks::mutator_lock_) {
167 ObjPtr<mirror::Object> obj = GetVerifyError(c);
Andreas Gampe99babb62015-11-02 16:20:00 -0800168 DCHECK(obj != nullptr);
169 self->AssertNoPendingException();
170 if (obj->IsClass()) {
171 // Previous error has been stored as class. Create a new exception of that type.
172
173 // It's possible the exception doesn't have a <init>(String).
174 std::string temp;
175 const char* descriptor = obj->AsClass()->GetDescriptor(&temp);
176
177 if (HasInitWithString(self, class_linker, descriptor)) {
David Sehr709b0702016-10-13 09:12:37 -0700178 self->ThrowNewException(descriptor, c->PrettyDescriptor().c_str());
Andreas Gampe99babb62015-11-02 16:20:00 -0800179 } else {
180 self->ThrowNewException(descriptor, nullptr);
181 }
182 } else {
183 // Previous error has been stored as an instance. Just rethrow.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700184 ObjPtr<mirror::Class> throwable_class =
Andreas Gampe99babb62015-11-02 16:20:00 -0800185 self->DecodeJObject(WellKnownClasses::java_lang_Throwable)->AsClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700186 ObjPtr<mirror::Class> error_class = obj->GetClass();
Andreas Gampe99babb62015-11-02 16:20:00 -0800187 CHECK(throwable_class->IsAssignableFrom(error_class));
188 self->SetException(obj->AsThrowable());
189 }
190 self->AssertPendingException();
191}
192
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700193void ClassLinker::ThrowEarlierClassFailure(ObjPtr<mirror::Class> c, bool wrap_in_no_class_def) {
Elliott Hughes5c599942012-06-13 16:45:05 -0700194 // The class failed to initialize on a previous attempt, so we want to throw
195 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
196 // failed in verification, in which case v2 5.4.1 says we need to re-throw
197 // the previous error.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800198 Runtime* const runtime = Runtime::Current();
199 if (!runtime->IsAotCompiler()) { // Give info if this occurs at runtime.
Andreas Gampe3d6b4702015-09-21 08:35:52 -0700200 std::string extra;
Alex Lightd6251582016-10-31 11:12:30 -0700201 if (GetVerifyError(c) != nullptr) {
202 ObjPtr<mirror::Object> verify_error = GetVerifyError(c);
Andreas Gampe369c8512016-01-28 15:31:39 -0800203 if (verify_error->IsClass()) {
David Sehr709b0702016-10-13 09:12:37 -0700204 extra = mirror::Class::PrettyDescriptor(verify_error->AsClass());
Andreas Gampe369c8512016-01-28 15:31:39 -0800205 } else {
206 extra = verify_error->AsThrowable()->Dump();
207 }
Andreas Gampe3d6b4702015-09-21 08:35:52 -0700208 }
David Sehr709b0702016-10-13 09:12:37 -0700209 LOG(INFO) << "Rejecting re-init on previously-failed class " << c->PrettyClass()
210 << ": " << extra;
Ian Rogers87e552d2012-08-31 15:54:48 -0700211 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700212
David Sehr709b0702016-10-13 09:12:37 -0700213 CHECK(c->IsErroneous()) << c->PrettyClass() << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -0800214 Thread* self = Thread::Current();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800215 if (runtime->IsAotCompiler()) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700216 // At compile time, accurate errors and NCDFE are disabled to speed compilation.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700217 ObjPtr<mirror::Throwable> pre_allocated = runtime->GetPreAllocatedNoClassDefFoundError();
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000218 self->SetException(pre_allocated);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700219 } else {
Alex Lightd6251582016-10-31 11:12:30 -0700220 if (GetVerifyError(c) != nullptr) {
Andreas Gampecb086952015-11-02 16:20:00 -0800221 // Rethrow stored error.
Andreas Gampe99babb62015-11-02 16:20:00 -0800222 HandleEarlierVerifyError(self, this, c);
Andreas Gampecb086952015-11-02 16:20:00 -0800223 }
Alex Lightd6251582016-10-31 11:12:30 -0700224 // TODO This might be wrong if we hit an OOME while allocating the ClassExt. In that case we
225 // might have meant to go down the earlier if statement with the original error but it got
226 // swallowed by the OOM so we end up here.
227 if (GetVerifyError(c) == nullptr || wrap_in_no_class_def) {
Andreas Gampecb086952015-11-02 16:20:00 -0800228 // If there isn't a recorded earlier error, or this is a repeat throw from initialization,
229 // the top-level exception must be a NoClassDefFoundError. The potentially already pending
230 // exception will be a cause.
231 self->ThrowNewWrappedException("Ljava/lang/NoClassDefFoundError;",
David Sehr709b0702016-10-13 09:12:37 -0700232 c->PrettyDescriptor().c_str());
Ian Rogers7b078e82014-09-10 14:44:24 -0700233 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700234 }
235}
236
Brian Carlstromb23eab12014-10-08 17:55:21 -0700237static void VlogClassInitializationFailure(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700238 REQUIRES_SHARED(Locks::mutator_lock_) {
Brian Carlstromb23eab12014-10-08 17:55:21 -0700239 if (VLOG_IS_ON(class_linker)) {
240 std::string temp;
241 LOG(INFO) << "Failed to initialize class " << klass->GetDescriptor(&temp) << " from "
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000242 << klass->GetLocation() << "\n" << Thread::Current()->GetException()->Dump();
Brian Carlstromb23eab12014-10-08 17:55:21 -0700243 }
244}
245
246static void WrapExceptionInInitializer(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700247 REQUIRES_SHARED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700248 Thread* self = Thread::Current();
249 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700250
251 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700252 CHECK(cause.get() != nullptr);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700253
Andreas Gampe1e8a3952016-11-30 10:13:19 -0800254 // Boot classpath classes should not fail initialization. This is a sanity debug check. This
255 // cannot in general be guaranteed, but in all likelihood leads to breakage down the line.
256 if (klass->GetClassLoader() == nullptr && !Runtime::Current()->IsAotCompiler()) {
Andreas Gampe22f71d22016-11-21 10:10:08 -0800257 std::string tmp;
Andreas Gampe1e8a3952016-11-30 10:13:19 -0800258 LOG(kIsDebugBuild ? FATAL : WARNING) << klass->GetDescriptor(&tmp) << " failed initialization";
Andreas Gampe22f71d22016-11-21 10:10:08 -0800259 }
260
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700261 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700262 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
263 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700264
Elliott Hughesa4f94742012-05-29 16:28:38 -0700265 // We only wrap non-Error exceptions; an Error can just be used as-is.
266 if (!is_error) {
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000267 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", nullptr);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700268 }
Brian Carlstromb23eab12014-10-08 17:55:21 -0700269 VlogClassInitializationFailure(klass);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700270}
271
Fred Shih381e4ca2014-08-25 17:24:27 -0700272// Gap between two fields in object layout.
273struct FieldGap {
274 uint32_t start_offset; // The offset from the start of the object.
275 uint32_t size; // The gap size of 1, 2, or 4 bytes.
276};
277struct FieldGapsComparator {
278 explicit FieldGapsComparator() {
279 }
280 bool operator() (const FieldGap& lhs, const FieldGap& rhs)
281 NO_THREAD_SAFETY_ANALYSIS {
Andreas Gampef52857f2015-02-18 15:38:57 -0800282 // Sort by gap size, largest first. Secondary sort by starting offset.
Richard Uhlerfab67882015-07-13 17:00:35 -0700283 // Note that the priority queue returns the largest element, so operator()
284 // should return true if lhs is less than rhs.
285 return lhs.size < rhs.size || (lhs.size == rhs.size && lhs.start_offset > rhs.start_offset);
Fred Shih381e4ca2014-08-25 17:24:27 -0700286 }
287};
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700288typedef std::priority_queue<FieldGap, std::vector<FieldGap>, FieldGapsComparator> FieldGaps;
Fred Shih381e4ca2014-08-25 17:24:27 -0700289
290// Adds largest aligned gaps to queue of gaps.
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800291static void AddFieldGap(uint32_t gap_start, uint32_t gap_end, FieldGaps* gaps) {
Fred Shih381e4ca2014-08-25 17:24:27 -0700292 DCHECK(gaps != nullptr);
293
294 uint32_t current_offset = gap_start;
295 while (current_offset != gap_end) {
296 size_t remaining = gap_end - current_offset;
297 if (remaining >= sizeof(uint32_t) && IsAligned<4>(current_offset)) {
298 gaps->push(FieldGap {current_offset, sizeof(uint32_t)});
299 current_offset += sizeof(uint32_t);
300 } else if (remaining >= sizeof(uint16_t) && IsAligned<2>(current_offset)) {
301 gaps->push(FieldGap {current_offset, sizeof(uint16_t)});
302 current_offset += sizeof(uint16_t);
303 } else {
304 gaps->push(FieldGap {current_offset, sizeof(uint8_t)});
305 current_offset += sizeof(uint8_t);
306 }
307 DCHECK_LE(current_offset, gap_end) << "Overran gap";
308 }
309}
310// Shuffle fields forward, making use of gaps whenever possible.
311template<int n>
Vladimir Marko76649e82014-11-10 18:32:59 +0000312static void ShuffleForward(size_t* current_field_idx,
Fred Shih381e4ca2014-08-25 17:24:27 -0700313 MemberOffset* field_offset,
Mathieu Chartierc7853442015-03-27 14:35:38 -0700314 std::deque<ArtField*>* grouped_and_sorted_fields,
Fred Shih381e4ca2014-08-25 17:24:27 -0700315 FieldGaps* gaps)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700316 REQUIRES_SHARED(Locks::mutator_lock_) {
Fred Shih381e4ca2014-08-25 17:24:27 -0700317 DCHECK(current_field_idx != nullptr);
318 DCHECK(grouped_and_sorted_fields != nullptr);
Fred Shih381e4ca2014-08-25 17:24:27 -0700319 DCHECK(gaps != nullptr);
320 DCHECK(field_offset != nullptr);
321
322 DCHECK(IsPowerOfTwo(n));
323 while (!grouped_and_sorted_fields->empty()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700324 ArtField* field = grouped_and_sorted_fields->front();
Fred Shih381e4ca2014-08-25 17:24:27 -0700325 Primitive::Type type = field->GetTypeAsPrimitiveType();
326 if (Primitive::ComponentSize(type) < n) {
327 break;
328 }
329 if (!IsAligned<n>(field_offset->Uint32Value())) {
330 MemberOffset old_offset = *field_offset;
331 *field_offset = MemberOffset(RoundUp(field_offset->Uint32Value(), n));
332 AddFieldGap(old_offset.Uint32Value(), field_offset->Uint32Value(), gaps);
333 }
David Sehr709b0702016-10-13 09:12:37 -0700334 CHECK(type != Primitive::kPrimNot) << field->PrettyField(); // should be primitive types
Fred Shih381e4ca2014-08-25 17:24:27 -0700335 grouped_and_sorted_fields->pop_front();
Fred Shih381e4ca2014-08-25 17:24:27 -0700336 if (!gaps->empty() && gaps->top().size >= n) {
337 FieldGap gap = gaps->top();
338 gaps->pop();
Roland Levillain14d90572015-07-16 10:52:26 +0100339 DCHECK_ALIGNED(gap.start_offset, n);
Fred Shih381e4ca2014-08-25 17:24:27 -0700340 field->SetOffset(MemberOffset(gap.start_offset));
341 if (gap.size > n) {
342 AddFieldGap(gap.start_offset + n, gap.start_offset + gap.size, gaps);
343 }
344 } else {
Roland Levillain14d90572015-07-16 10:52:26 +0100345 DCHECK_ALIGNED(field_offset->Uint32Value(), n);
Fred Shih381e4ca2014-08-25 17:24:27 -0700346 field->SetOffset(*field_offset);
347 *field_offset = MemberOffset(field_offset->Uint32Value() + n);
348 }
349 ++(*current_field_idx);
350 }
351}
352
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800353ClassLinker::ClassLinker(InternTable* intern_table)
Andreas Gampecc1b5352016-12-01 16:58:38 -0800354 : failed_dex_cache_class_lookups_(0),
Ian Rogers98379392014-02-24 16:53:16 -0800355 class_roots_(nullptr),
356 array_iftable_(nullptr),
357 find_array_class_cache_next_victim_(0),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700358 init_done_(false),
Vladimir Marko1998cd02017-01-13 13:02:58 +0000359 log_new_roots_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700360 intern_table_(intern_table),
Ian Rogers98379392014-02-24 16:53:16 -0800361 quick_resolution_trampoline_(nullptr),
Andreas Gampe2da88232014-02-27 12:26:20 -0800362 quick_imt_conflict_trampoline_(nullptr),
Vladimir Marko8a630572014-04-09 18:45:35 +0100363 quick_generic_jni_trampoline_(nullptr),
Mathieu Chartier2d721012014-11-10 11:08:06 -0800364 quick_to_interpreter_bridge_trampoline_(nullptr),
Andreas Gampe542451c2016-07-26 09:02:02 -0700365 image_pointer_size_(kRuntimePointerSize) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700366 CHECK(intern_table_ != nullptr);
Andreas Gampe8ac75952015-06-02 21:01:45 -0700367 static_assert(kFindArrayCacheSize == arraysize(find_array_class_cache_),
368 "Array cache size wrong.");
369 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700370}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700371
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800372void ClassLinker::CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700373 ObjPtr<mirror::Class> c2 = FindSystemClass(self, descriptor);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800374 if (c2 == nullptr) {
375 LOG(FATAL) << "Could not find class " << descriptor;
376 UNREACHABLE();
377 }
378 if (c1.Get() != c2) {
379 std::ostringstream os1, os2;
380 c1->DumpClass(os1, mirror::Class::kDumpClassFullDetail);
381 c2->DumpClass(os2, mirror::Class::kDumpClassFullDetail);
382 LOG(FATAL) << "InitWithoutImage: Class mismatch for " << descriptor
383 << ". This is most likely the result of a broken build. Make sure that "
384 << "libcore and art projects match.\n\n"
385 << os1.str() << "\n\n" << os2.str();
386 UNREACHABLE();
387 }
388}
389
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800390bool ClassLinker::InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path,
391 std::string* error_msg) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800392 VLOG(startup) << "ClassLinker::Init";
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700393
Mathieu Chartiere401d142015-04-22 13:56:20 -0700394 Thread* const self = Thread::Current();
395 Runtime* const runtime = Runtime::Current();
396 gc::Heap* const heap = runtime->GetHeap();
397
Jeff Haodcdc85b2015-12-04 14:06:18 -0800398 CHECK(!heap->HasBootImageSpace()) << "Runtime has image. We should use it.";
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700399 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700400
Mathieu Chartiere401d142015-04-22 13:56:20 -0700401 // Use the pointer size from the runtime since we are probably creating the image.
402 image_pointer_size_ = InstructionSetPointerSize(runtime->GetInstructionSet());
403
Elliott Hughes30646832011-10-13 16:59:46 -0700404 // java_lang_Class comes first, it's needed for AllocClass
Mathieu Chartier590fee92013-09-13 13:46:47 -0700405 // 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 -0800406 heap->IncrementDisableMovingGC(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700407 StackHandleScope<64> hs(self); // 64 is picked arbitrarily.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700408 auto class_class_size = mirror::Class::ClassClassSize(image_pointer_size_);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700409 Handle<mirror::Class> java_lang_Class(hs.NewHandle(down_cast<mirror::Class*>(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700410 heap->AllocNonMovableObject<true>(self, nullptr, class_class_size, VoidFunctor()))));
Andreas Gampefa4333d2017-02-14 11:10:34 -0800411 CHECK(java_lang_Class != nullptr);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700412 mirror::Class::SetClassClass(java_lang_Class.Get());
413 java_lang_Class->SetClass(java_lang_Class.Get());
Hiroshi Yamauchi12b58b22016-11-01 11:55:29 -0700414 if (kUseBakerReadBarrier) {
415 java_lang_Class->AssertReadBarrierState();
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800416 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700417 java_lang_Class->SetClassSize(class_class_size);
Hiroshi Yamauchif0edfc32014-09-25 11:46:46 -0700418 java_lang_Class->SetPrimitiveType(Primitive::kPrimNot);
Mathieu Chartier1d27b342014-01-28 12:51:09 -0800419 heap->DecrementDisableMovingGC(self);
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700420 // AllocClass(ObjPtr<mirror::Class>) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700421
Elliott Hughes418d20f2011-09-22 14:00:39 -0700422 // Class[] is used for reflection support.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700423 auto class_array_class_size = mirror::ObjectArray<mirror::Class>::ClassSize(image_pointer_size_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700424 Handle<mirror::Class> class_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700425 AllocClass(self, java_lang_Class.Get(), class_array_class_size)));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700426 class_array_class->SetComponentType(java_lang_Class.Get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700427
Ian Rogers23435d02012-09-24 11:23:12 -0700428 // java_lang_Object comes next so that object_array_class can be created.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700429 Handle<mirror::Class> java_lang_Object(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700430 AllocClass(self, java_lang_Class.Get(), mirror::Object::ClassSize(image_pointer_size_))));
Andreas Gampefa4333d2017-02-14 11:10:34 -0800431 CHECK(java_lang_Object != nullptr);
Ian Rogers23435d02012-09-24 11:23:12 -0700432 // backfill Object as the super class of Class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700433 java_lang_Class->SetSuperClass(java_lang_Object.Get());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700434 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusLoaded, self);
Brian Carlstroma0808032011-07-18 00:39:23 -0700435
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700436 java_lang_Object->SetObjectSize(sizeof(mirror::Object));
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800437 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been
438 // cleared without triggering the read barrier and unintentionally mark the sentinel alive.
439 runtime->SetSentinel(heap->AllocNonMovableObject<true>(self,
440 java_lang_Object.Get(),
441 java_lang_Object->GetObjectSize(),
442 VoidFunctor()));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700443
Ian Rogers23435d02012-09-24 11:23:12 -0700444 // Object[] next to hold class roots.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700445 Handle<mirror::Class> object_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700446 AllocClass(self, java_lang_Class.Get(),
447 mirror::ObjectArray<mirror::Object>::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700448 object_array_class->SetComponentType(java_lang_Object.Get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700449
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700450 // Setup the char (primitive) class to be used for char[].
451 Handle<mirror::Class> char_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700452 AllocClass(self, java_lang_Class.Get(),
453 mirror::Class::PrimitiveClassSize(image_pointer_size_))));
Hiroshi Yamauchif0edfc32014-09-25 11:46:46 -0700454 // The primitive char class won't be initialized by
455 // InitializePrimitiveClass until line 459, but strings (and
456 // internal char arrays) will be allocated before that and the
457 // component size, which is computed from the primitive type, needs
458 // to be set here.
459 char_class->SetPrimitiveType(Primitive::kPrimChar);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700460
Ian Rogers23435d02012-09-24 11:23:12 -0700461 // Setup the char[] class to be used for String.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700462 Handle<mirror::Class> char_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700463 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700464 char_array_class->SetComponentType(char_class.Get());
465 mirror::CharArray::SetArrayClass(char_array_class.Get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700466
Ian Rogers23435d02012-09-24 11:23:12 -0700467 // Setup String.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700468 Handle<mirror::Class> java_lang_String(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700469 AllocClass(self, java_lang_Class.Get(), mirror::String::ClassSize(image_pointer_size_))));
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700470 java_lang_String->SetStringClass();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700471 mirror::String::SetClass(java_lang_String.Get());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700472 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusResolved, self);
Jesse Wilson14150742011-07-29 19:04:44 -0400473
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700474 // Setup java.lang.ref.Reference.
Fred Shih4ee7a662014-07-11 09:59:27 -0700475 Handle<mirror::Class> java_lang_ref_Reference(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700476 AllocClass(self, java_lang_Class.Get(), mirror::Reference::ClassSize(image_pointer_size_))));
Fred Shih4ee7a662014-07-11 09:59:27 -0700477 mirror::Reference::SetClass(java_lang_ref_Reference.Get());
478 java_lang_ref_Reference->SetObjectSize(mirror::Reference::InstanceSize());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700479 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusResolved, self);
Fred Shih4ee7a662014-07-11 09:59:27 -0700480
Ian Rogers23435d02012-09-24 11:23:12 -0700481 // Create storage for root classes, save away our work so far (requires descriptors).
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700482 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700483 mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.Get(),
484 kClassRootsMax));
485 CHECK(!class_roots_.IsNull());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700486 SetClassRoot(kJavaLangClass, java_lang_Class.Get());
487 SetClassRoot(kJavaLangObject, java_lang_Object.Get());
488 SetClassRoot(kClassArrayClass, class_array_class.Get());
489 SetClassRoot(kObjectArrayClass, object_array_class.Get());
490 SetClassRoot(kCharArrayClass, char_array_class.Get());
491 SetClassRoot(kJavaLangString, java_lang_String.Get());
Fred Shih4ee7a662014-07-11 09:59:27 -0700492 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700493
Mathieu Chartier6beced42016-11-15 15:51:31 -0800494 // Fill in the empty iftable. Needs to be done after the kObjectArrayClass root is set.
495 java_lang_Object->SetIfTable(AllocIfTable(self, 0));
496
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700497 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700498 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
499 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
500 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
501 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
502 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
503 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
504 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
505 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700506
Ian Rogers23435d02012-09-24 11:23:12 -0700507 // Create array interface entries to populate once we can load system classes.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700508 array_iftable_ = GcRoot<mirror::IfTable>(AllocIfTable(self, 2));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700509
Ian Rogers23435d02012-09-24 11:23:12 -0700510 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700511 Handle<mirror::Class> int_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700512 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700513 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700514 mirror::IntArray::SetArrayClass(int_array_class.Get());
515 SetClassRoot(kIntArrayClass, int_array_class.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700516
Mathieu Chartierc7853442015-03-27 14:35:38 -0700517 // Create long array type for AllocDexCache (done in AppendToBootClassPath).
518 Handle<mirror::Class> long_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700519 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
Mathieu Chartierc7853442015-03-27 14:35:38 -0700520 long_array_class->SetComponentType(GetClassRoot(kPrimitiveLong));
521 mirror::LongArray::SetArrayClass(long_array_class.Get());
522 SetClassRoot(kLongArrayClass, long_array_class.Get());
523
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700524 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700525
Ian Rogers52813c92012-10-11 11:50:38 -0700526 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700527 Handle<mirror::Class> java_lang_DexCache(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700528 AllocClass(self, java_lang_Class.Get(), mirror::DexCache::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700529 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.Get());
Vladimir Marko05792b92015-08-03 11:56:49 +0100530 java_lang_DexCache->SetDexCacheClass();
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700531 java_lang_DexCache->SetObjectSize(mirror::DexCache::InstanceSize());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700532 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusResolved, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700533
Alex Lightd6251582016-10-31 11:12:30 -0700534
535 // Setup dalvik.system.ClassExt
536 Handle<mirror::Class> dalvik_system_ClassExt(hs.NewHandle(
537 AllocClass(self, java_lang_Class.Get(), mirror::ClassExt::ClassSize(image_pointer_size_))));
538 SetClassRoot(kDalvikSystemClassExt, dalvik_system_ClassExt.Get());
539 mirror::ClassExt::SetClass(dalvik_system_ClassExt.Get());
540 mirror::Class::SetStatus(dalvik_system_ClassExt, mirror::Class::kStatusResolved, self);
541
Mathieu Chartier66f19252012-09-18 08:57:04 -0700542 // Set up array classes for string, field, method
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700543 Handle<mirror::Class> object_array_string(hs.NewHandle(
544 AllocClass(self, java_lang_Class.Get(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700545 mirror::ObjectArray<mirror::String>::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700546 object_array_string->SetComponentType(java_lang_String.Get());
547 SetClassRoot(kJavaLangStringArrayClass, object_array_string.Get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700548
Nicolas Geoffray796d6302016-03-13 22:22:31 +0000549 LinearAlloc* linear_alloc = runtime->GetLinearAlloc();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700550 // Create runtime resolution and imt conflict methods.
551 runtime->SetResolutionMethod(runtime->CreateResolutionMethod());
Nicolas Geoffray796d6302016-03-13 22:22:31 +0000552 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod(linear_alloc));
553 runtime->SetImtUnimplementedMethod(runtime->CreateImtConflictMethod(linear_alloc));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700554
Ian Rogers23435d02012-09-24 11:23:12 -0700555 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
556 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
557 // these roots.
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800558 if (boot_class_path.empty()) {
559 *error_msg = "Boot classpath is empty.";
560 return false;
561 }
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800562 for (auto& dex_file : boot_class_path) {
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800563 if (dex_file.get() == nullptr) {
564 *error_msg = "Null dex file.";
565 return false;
566 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700567 AppendToBootClassPath(self, *dex_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800568 boot_dex_files_.push_back(std::move(dex_file));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700569 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700570
571 // now we can use FindSystemClass
572
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700573 // run char class through InitializePrimitiveClass to finish init
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700574 InitializePrimitiveClass(char_class.Get(), Primitive::kPrimChar);
575 SetClassRoot(kPrimitiveChar, char_class.Get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700576
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700577 // Set up GenericJNI entrypoint. That is mainly a hack for common_compiler_test.h so that
578 // we do not need friend classes or a publicly exposed setter.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700579 quick_generic_jni_trampoline_ = GetQuickGenericJniStub();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800580 if (!runtime->IsAotCompiler()) {
Alex Light64ad14d2014-08-19 14:23:13 -0700581 // We need to set up the generic trampolines since we don't have an image.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700582 quick_resolution_trampoline_ = GetQuickResolutionStub();
583 quick_imt_conflict_trampoline_ = GetQuickImtConflictStub();
584 quick_to_interpreter_bridge_trampoline_ = GetQuickToInterpreterBridge();
Alex Light64ad14d2014-08-19 14:23:13 -0700585 }
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700586
Alex Lightd6251582016-10-31 11:12:30 -0700587 // Object, String, ClassExt and DexCache need to be rerun through FindSystemClass to finish init
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700588 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800589 CheckSystemClass(self, java_lang_Object, "Ljava/lang/Object;");
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700590 CHECK_EQ(java_lang_Object->GetObjectSize(), mirror::Object::InstanceSize());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700591 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800592 CheckSystemClass(self, java_lang_String, "Ljava/lang/String;");
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700593 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800594 CheckSystemClass(self, java_lang_DexCache, "Ljava/lang/DexCache;");
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700595 CHECK_EQ(java_lang_DexCache->GetObjectSize(), mirror::DexCache::InstanceSize());
Alex Lightd6251582016-10-31 11:12:30 -0700596 mirror::Class::SetStatus(dalvik_system_ClassExt, mirror::Class::kStatusNotReady, self);
597 CheckSystemClass(self, dalvik_system_ClassExt, "Ldalvik/system/ClassExt;");
598 CHECK_EQ(dalvik_system_ClassExt->GetObjectSize(), mirror::ClassExt::InstanceSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700599
Ian Rogers23435d02012-09-24 11:23:12 -0700600 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers98379392014-02-24 16:53:16 -0800601 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800602 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700603
Ian Rogers98379392014-02-24 16:53:16 -0800604 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800605 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700606
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800607 CheckSystemClass(self, char_array_class, "[C");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700608
Ian Rogers98379392014-02-24 16:53:16 -0800609 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800610 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700611
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800612 CheckSystemClass(self, int_array_class, "[I");
613 CheckSystemClass(self, long_array_class, "[J");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700614
Ian Rogers98379392014-02-24 16:53:16 -0800615 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800616 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700617
Ian Rogers98379392014-02-24 16:53:16 -0800618 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800619 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700620
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800621 // Run Class through FindSystemClass. This initializes the dex_cache_ fields and register it
622 // in class_table_.
623 CheckSystemClass(self, java_lang_Class, "Ljava/lang/Class;");
Elliott Hughes418d20f2011-09-22 14:00:39 -0700624
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800625 CheckSystemClass(self, class_array_class, "[Ljava/lang/Class;");
626 CheckSystemClass(self, object_array_class, "[Ljava/lang/Object;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700627
Ian Rogers23435d02012-09-24 11:23:12 -0700628 // Setup the single, global copy of "iftable".
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700629 auto java_lang_Cloneable = hs.NewHandle(FindSystemClass(self, "Ljava/lang/Cloneable;"));
Andreas Gampefa4333d2017-02-14 11:10:34 -0800630 CHECK(java_lang_Cloneable != nullptr);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700631 auto java_io_Serializable = hs.NewHandle(FindSystemClass(self, "Ljava/io/Serializable;"));
Andreas Gampefa4333d2017-02-14 11:10:34 -0800632 CHECK(java_io_Serializable != nullptr);
Ian Rogers23435d02012-09-24 11:23:12 -0700633 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
634 // crawl up and explicitly list all of the supers as well.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700635 array_iftable_.Read()->SetInterface(0, java_lang_Cloneable.Get());
636 array_iftable_.Read()->SetInterface(1, java_io_Serializable.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700637
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700638 // Sanity check Class[] and Object[]'s interfaces. GetDirectInterface may cause thread
639 // suspension.
640 CHECK_EQ(java_lang_Cloneable.Get(),
Vladimir Marko19a4d372016-12-08 14:41:46 +0000641 mirror::Class::GetDirectInterface(self, class_array_class.Get(), 0));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700642 CHECK_EQ(java_io_Serializable.Get(),
Vladimir Marko19a4d372016-12-08 14:41:46 +0000643 mirror::Class::GetDirectInterface(self, class_array_class.Get(), 1));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700644 CHECK_EQ(java_lang_Cloneable.Get(),
Vladimir Marko19a4d372016-12-08 14:41:46 +0000645 mirror::Class::GetDirectInterface(self, object_array_class.Get(), 0));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700646 CHECK_EQ(java_io_Serializable.Get(),
Vladimir Marko19a4d372016-12-08 14:41:46 +0000647 mirror::Class::GetDirectInterface(self, object_array_class.Get(), 1));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700648
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700649 CHECK_EQ(object_array_string.Get(),
650 FindSystemClass(self, GetClassRootDescriptor(kJavaLangStringArrayClass)));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700651
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800652 // End of special init trickery, all subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700653
Ian Rogers23435d02012-09-24 11:23:12 -0700654 // Create java.lang.reflect.Proxy root.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700655 SetClassRoot(kJavaLangReflectProxy, FindSystemClass(self, "Ljava/lang/reflect/Proxy;"));
Ian Rogers466bb252011-10-14 03:29:56 -0700656
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700657 // Create java.lang.reflect.Field.class root.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700658 auto* class_root = FindSystemClass(self, "Ljava/lang/reflect/Field;");
659 CHECK(class_root != nullptr);
660 SetClassRoot(kJavaLangReflectField, class_root);
661 mirror::Field::SetClass(class_root);
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700662
663 // Create java.lang.reflect.Field array root.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700664 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Field;");
665 CHECK(class_root != nullptr);
666 SetClassRoot(kJavaLangReflectFieldArrayClass, class_root);
667 mirror::Field::SetArrayClass(class_root);
668
669 // Create java.lang.reflect.Constructor.class root and array root.
670 class_root = FindSystemClass(self, "Ljava/lang/reflect/Constructor;");
671 CHECK(class_root != nullptr);
672 SetClassRoot(kJavaLangReflectConstructor, class_root);
673 mirror::Constructor::SetClass(class_root);
674 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Constructor;");
675 CHECK(class_root != nullptr);
676 SetClassRoot(kJavaLangReflectConstructorArrayClass, class_root);
677 mirror::Constructor::SetArrayClass(class_root);
678
679 // Create java.lang.reflect.Method.class root and array root.
680 class_root = FindSystemClass(self, "Ljava/lang/reflect/Method;");
681 CHECK(class_root != nullptr);
682 SetClassRoot(kJavaLangReflectMethod, class_root);
683 mirror::Method::SetClass(class_root);
684 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Method;");
685 CHECK(class_root != nullptr);
686 SetClassRoot(kJavaLangReflectMethodArrayClass, class_root);
687 mirror::Method::SetArrayClass(class_root);
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700688
Narayan Kamathafa48272016-08-03 12:46:58 +0100689 // Create java.lang.invoke.MethodType.class root
690 class_root = FindSystemClass(self, "Ljava/lang/invoke/MethodType;");
691 CHECK(class_root != nullptr);
692 SetClassRoot(kJavaLangInvokeMethodType, class_root);
693 mirror::MethodType::SetClass(class_root);
694
695 // Create java.lang.invoke.MethodHandleImpl.class root
696 class_root = FindSystemClass(self, "Ljava/lang/invoke/MethodHandleImpl;");
697 CHECK(class_root != nullptr);
698 SetClassRoot(kJavaLangInvokeMethodHandleImpl, class_root);
699 mirror::MethodHandleImpl::SetClass(class_root);
700
Orion Hodsonc069a302017-01-18 09:23:12 +0000701 // Create java.lang.invoke.MethodHandles.Lookup.class root
702 class_root = FindSystemClass(self, "Ljava/lang/invoke/MethodHandles$Lookup;");
703 CHECK(class_root != nullptr);
704 SetClassRoot(kJavaLangInvokeMethodHandlesLookup, class_root);
705 mirror::MethodHandlesLookup::SetClass(class_root);
706
707 // Create java.lang.invoke.CallSite.class root
708 class_root = FindSystemClass(self, "Ljava/lang/invoke/CallSite;");
709 CHECK(class_root != nullptr);
710 SetClassRoot(kJavaLangInvokeCallSite, class_root);
711 mirror::CallSite::SetClass(class_root);
712
Narayan Kamath000e1882016-10-24 17:14:25 +0100713 class_root = FindSystemClass(self, "Ldalvik/system/EmulatedStackFrame;");
714 CHECK(class_root != nullptr);
715 SetClassRoot(kDalvikSystemEmulatedStackFrame, class_root);
716 mirror::EmulatedStackFrame::SetClass(class_root);
717
Brian Carlstrom1f870082011-08-23 16:02:11 -0700718 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Fred Shih4ee7a662014-07-11 09:59:27 -0700719 // finish initializing Reference class
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700720 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800721 CheckSystemClass(self, java_lang_ref_Reference, "Ljava/lang/ref/Reference;");
Fred Shih4ee7a662014-07-11 09:59:27 -0700722 CHECK_EQ(java_lang_ref_Reference->GetObjectSize(), mirror::Reference::InstanceSize());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700723 CHECK_EQ(java_lang_ref_Reference->GetClassSize(),
724 mirror::Reference::ClassSize(image_pointer_size_));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700725 class_root = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700726 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700727 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagFinalizerReference);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700728 class_root = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700729 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700730 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagPhantomReference);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700731 class_root = FindSystemClass(self, "Ljava/lang/ref/SoftReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700732 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700733 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagSoftReference);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700734 class_root = FindSystemClass(self, "Ljava/lang/ref/WeakReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700735 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700736 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700737
Ian Rogers23435d02012-09-24 11:23:12 -0700738 // Setup the ClassLoader, verifying the object_size_.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700739 class_root = FindSystemClass(self, "Ljava/lang/ClassLoader;");
Mathieu Chartiere4275c02015-08-06 15:34:15 -0700740 class_root->SetClassLoaderClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700741 CHECK_EQ(class_root->GetObjectSize(), mirror::ClassLoader::InstanceSize());
742 SetClassRoot(kJavaLangClassLoader, class_root);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700743
jeffhao8cd6dda2012-02-22 10:15:34 -0800744 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700745 // java.lang.StackTraceElement as a convenience.
Ian Rogers98379392014-02-24 16:53:16 -0800746 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800747 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Brian Carlstromf3632832014-05-20 15:36:53 -0700748 SetClassRoot(kJavaLangClassNotFoundException,
749 FindSystemClass(self, "Ljava/lang/ClassNotFoundException;"));
Ian Rogers98379392014-02-24 16:53:16 -0800750 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;"));
Brian Carlstromf3632832014-05-20 15:36:53 -0700751 SetClassRoot(kJavaLangStackTraceElementArrayClass,
752 FindSystemClass(self, "[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800753 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700754
Andreas Gampe76bd8802014-12-10 16:43:58 -0800755 // Ensure void type is resolved in the core's dex cache so java.lang.Void is correctly
756 // initialized.
757 {
758 const DexFile& dex_file = java_lang_Object->GetDexFile();
Mathieu Chartier9507fa22015-10-29 15:08:57 -0700759 const DexFile::TypeId* void_type_id = dex_file.FindTypeId("V");
Andreas Gampe76bd8802014-12-10 16:43:58 -0800760 CHECK(void_type_id != nullptr);
Andreas Gampea5b09a62016-11-17 15:21:22 -0800761 dex::TypeIndex void_type_idx = dex_file.GetIndexForTypeId(*void_type_id);
Andreas Gampe76bd8802014-12-10 16:43:58 -0800762 // Now we resolve void type so the dex cache contains it. We use java.lang.Object class
763 // as referrer so the used dex cache is core's one.
Andreas Gampea5b09a62016-11-17 15:21:22 -0800764 ObjPtr<mirror::Class> resolved_type = ResolveType(dex_file,
765 void_type_idx,
766 java_lang_Object.Get());
Andreas Gampe76bd8802014-12-10 16:43:58 -0800767 CHECK_EQ(resolved_type, GetClassRoot(kPrimitiveVoid));
768 self->AssertNoPendingException();
769 }
770
Mathieu Chartiercdca4762016-04-28 09:44:54 -0700771 // Create conflict tables that depend on the class linker.
772 runtime->FixupConflictTables();
773
Ian Rogers98379392014-02-24 16:53:16 -0800774 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700775
Brian Carlstroma004aa92012-02-08 18:05:09 -0800776 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800777
778 return true;
Brian Carlstroma663ea52011-08-19 23:33:41 -0700779}
780
Ian Rogers98379392014-02-24 16:53:16 -0800781void ClassLinker::FinishInit(Thread* self) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800782 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700783
784 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700785 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700786 // as the types of the field can't be resolved prior to the runtime being
787 // fully initialized
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700788 StackHandleScope<2> hs(self);
789 Handle<mirror::Class> java_lang_ref_Reference = hs.NewHandle(GetClassRoot(kJavaLangRefReference));
790 Handle<mirror::Class> java_lang_ref_FinalizerReference =
791 hs.NewHandle(FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800792
Mathieu Chartierc7853442015-03-27 14:35:38 -0700793 ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700794 CHECK_STREQ(pendingNext->GetName(), "pendingNext");
795 CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700796
Mathieu Chartierc7853442015-03-27 14:35:38 -0700797 ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700798 CHECK_STREQ(queue->GetName(), "queue");
799 CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700800
Mathieu Chartierc7853442015-03-27 14:35:38 -0700801 ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700802 CHECK_STREQ(queueNext->GetName(), "queueNext");
803 CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700804
Mathieu Chartierc7853442015-03-27 14:35:38 -0700805 ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700806 CHECK_STREQ(referent->GetName(), "referent");
807 CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700808
Mathieu Chartierc7853442015-03-27 14:35:38 -0700809 ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700810 CHECK_STREQ(zombie->GetName(), "zombie");
811 CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700812
Brian Carlstroma663ea52011-08-19 23:33:41 -0700813 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700814 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700815 ClassRoot class_root = static_cast<ClassRoot>(i);
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700816 ObjPtr<mirror::Class> klass = GetClassRoot(class_root);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700817 CHECK(klass != nullptr);
818 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != nullptr);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700819 // note SetClassRoot does additional validation.
820 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700821 }
822
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700823 CHECK(!array_iftable_.IsNull());
Elliott Hughes92f14b22011-10-06 12:29:54 -0700824
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700825 // disable the slow paths in FindClass and CreatePrimitiveClass now
826 // that Object, Class, and Object[] are setup
827 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700828
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800829 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700830}
831
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700832void ClassLinker::RunRootClinits() {
833 Thread* self = Thread::Current();
834 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700835 ObjPtr<mirror::Class> c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700836 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700837 StackHandleScope<1> hs(self);
838 Handle<mirror::Class> h_class(hs.NewHandle(GetClassRoot(ClassRoot(i))));
Ian Rogers7b078e82014-09-10 14:44:24 -0700839 EnsureInitialized(self, h_class, true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700840 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700841 }
842 }
843}
844
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200845// Set image methods' entry point to interpreter.
846class SetInterpreterEntrypointArtMethodVisitor : public ArtMethodVisitor {
847 public:
Andreas Gampe542451c2016-07-26 09:02:02 -0700848 explicit SetInterpreterEntrypointArtMethodVisitor(PointerSize image_pointer_size)
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200849 : image_pointer_size_(image_pointer_size) {}
850
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700851 void Visit(ArtMethod* method) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200852 if (kIsDebugBuild && !method->IsRuntimeMethod()) {
853 CHECK(method->GetDeclaringClass() != nullptr);
854 }
855 if (!method->IsNative() && !method->IsRuntimeMethod() && !method->IsResolutionMethod()) {
856 method->SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(),
857 image_pointer_size_);
858 }
859 }
860
861 private:
Andreas Gampe542451c2016-07-26 09:02:02 -0700862 const PointerSize image_pointer_size_;
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200863
864 DISALLOW_COPY_AND_ASSIGN(SetInterpreterEntrypointArtMethodVisitor);
865};
866
Jeff Haodcdc85b2015-12-04 14:06:18 -0800867struct TrampolineCheckData {
868 const void* quick_resolution_trampoline;
869 const void* quick_imt_conflict_trampoline;
870 const void* quick_generic_jni_trampoline;
871 const void* quick_to_interpreter_bridge_trampoline;
Andreas Gampe542451c2016-07-26 09:02:02 -0700872 PointerSize pointer_size;
Jeff Haodcdc85b2015-12-04 14:06:18 -0800873 ArtMethod* m;
874 bool error;
875};
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800876
Jeff Haodcdc85b2015-12-04 14:06:18 -0800877static void CheckTrampolines(mirror::Object* obj, void* arg) NO_THREAD_SAFETY_ANALYSIS {
878 if (obj->IsClass()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700879 ObjPtr<mirror::Class> klass = obj->AsClass();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800880 TrampolineCheckData* d = reinterpret_cast<TrampolineCheckData*>(arg);
881 for (ArtMethod& m : klass->GetMethods(d->pointer_size)) {
882 const void* entrypoint = m.GetEntryPointFromQuickCompiledCodePtrSize(d->pointer_size);
883 if (entrypoint == d->quick_resolution_trampoline ||
884 entrypoint == d->quick_imt_conflict_trampoline ||
885 entrypoint == d->quick_generic_jni_trampoline ||
886 entrypoint == d->quick_to_interpreter_bridge_trampoline) {
887 d->m = &m;
888 d->error = true;
889 return;
890 }
891 }
892 }
893}
894
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800895bool ClassLinker::InitFromBootImage(std::string* error_msg) {
896 VLOG(startup) << __FUNCTION__ << " entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700897 CHECK(!init_done_);
898
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700899 Runtime* const runtime = Runtime::Current();
900 Thread* const self = Thread::Current();
901 gc::Heap* const heap = runtime->GetHeap();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800902 std::vector<gc::space::ImageSpace*> spaces = heap->GetBootImageSpaces();
903 CHECK(!spaces.empty());
Andreas Gampe542451c2016-07-26 09:02:02 -0700904 uint32_t pointer_size_unchecked = spaces[0]->GetImageHeader().GetPointerSizeUnchecked();
905 if (!ValidPointerSize(pointer_size_unchecked)) {
906 *error_msg = StringPrintf("Invalid image pointer size: %u", pointer_size_unchecked);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800907 return false;
908 }
Andreas Gampe542451c2016-07-26 09:02:02 -0700909 image_pointer_size_ = spaces[0]->GetImageHeader().GetPointerSize();
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800910 if (!runtime->IsAotCompiler()) {
911 // Only the Aot compiler supports having an image with a different pointer size than the
912 // runtime. This happens on the host for compiling 32 bit tests since we use a 64 bit libart
913 // compiler. We may also use 32 bit dex2oat on a system with 64 bit apps.
Andreas Gampe542451c2016-07-26 09:02:02 -0700914 if (image_pointer_size_ != kRuntimePointerSize) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800915 *error_msg = StringPrintf("Runtime must use current image pointer size: %zu vs %zu",
Andreas Gampe542451c2016-07-26 09:02:02 -0700916 static_cast<size_t>(image_pointer_size_),
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800917 sizeof(void*));
918 return false;
919 }
920 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800921 std::vector<const OatFile*> oat_files =
922 runtime->GetOatFileManager().RegisterImageOatFiles(spaces);
923 DCHECK(!oat_files.empty());
924 const OatHeader& default_oat_header = oat_files[0]->GetOatHeader();
925 CHECK_EQ(default_oat_header.GetImageFileLocationOatChecksum(), 0U);
926 CHECK_EQ(default_oat_header.GetImageFileLocationOatDataBegin(), 0U);
927 const char* image_file_location = oat_files[0]->GetOatHeader().
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700928 GetStoreValueByKey(OatHeader::kImageLocationKey);
929 CHECK(image_file_location == nullptr || *image_file_location == 0);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800930 quick_resolution_trampoline_ = default_oat_header.GetQuickResolutionTrampoline();
931 quick_imt_conflict_trampoline_ = default_oat_header.GetQuickImtConflictTrampoline();
932 quick_generic_jni_trampoline_ = default_oat_header.GetQuickGenericJniTrampoline();
933 quick_to_interpreter_bridge_trampoline_ = default_oat_header.GetQuickToInterpreterBridge();
934 if (kIsDebugBuild) {
935 // Check that the other images use the same trampoline.
936 for (size_t i = 1; i < oat_files.size(); ++i) {
937 const OatHeader& ith_oat_header = oat_files[i]->GetOatHeader();
938 const void* ith_quick_resolution_trampoline =
939 ith_oat_header.GetQuickResolutionTrampoline();
940 const void* ith_quick_imt_conflict_trampoline =
941 ith_oat_header.GetQuickImtConflictTrampoline();
942 const void* ith_quick_generic_jni_trampoline =
943 ith_oat_header.GetQuickGenericJniTrampoline();
944 const void* ith_quick_to_interpreter_bridge_trampoline =
945 ith_oat_header.GetQuickToInterpreterBridge();
946 if (ith_quick_resolution_trampoline != quick_resolution_trampoline_ ||
947 ith_quick_imt_conflict_trampoline != quick_imt_conflict_trampoline_ ||
948 ith_quick_generic_jni_trampoline != quick_generic_jni_trampoline_ ||
949 ith_quick_to_interpreter_bridge_trampoline != quick_to_interpreter_bridge_trampoline_) {
950 // Make sure that all methods in this image do not contain those trampolines as
951 // entrypoints. Otherwise the class-linker won't be able to work with a single set.
952 TrampolineCheckData data;
953 data.error = false;
954 data.pointer_size = GetImagePointerSize();
955 data.quick_resolution_trampoline = ith_quick_resolution_trampoline;
956 data.quick_imt_conflict_trampoline = ith_quick_imt_conflict_trampoline;
957 data.quick_generic_jni_trampoline = ith_quick_generic_jni_trampoline;
958 data.quick_to_interpreter_bridge_trampoline = ith_quick_to_interpreter_bridge_trampoline;
959 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
960 spaces[i]->GetLiveBitmap()->Walk(CheckTrampolines, &data);
961 if (data.error) {
962 ArtMethod* m = data.m;
David Sehr709b0702016-10-13 09:12:37 -0700963 LOG(ERROR) << "Found a broken ArtMethod: " << ArtMethod::PrettyMethod(m);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800964 *error_msg = "Found an ArtMethod with a bad entrypoint";
965 return false;
966 }
967 }
968 }
969 }
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700970
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800971 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(
972 down_cast<mirror::ObjectArray<mirror::Class>*>(
973 spaces[0]->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)));
974 mirror::Class::SetClassClass(class_roots_.Read()->Get(kJavaLangClass));
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700975
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700976 // Special case of setting up the String class early so that we can test arbitrary objects
977 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -0700978 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800979
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700980 ObjPtr<mirror::Class> java_lang_Object = GetClassRoot(kJavaLangObject);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700981 java_lang_Object->SetObjectSize(sizeof(mirror::Object));
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800982 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been
983 // cleared without triggering the read barrier and unintentionally mark the sentinel alive.
Jeff Haodcdc85b2015-12-04 14:06:18 -0800984 runtime->SetSentinel(heap->AllocNonMovableObject<true>(
985 self, java_lang_Object, java_lang_Object->GetObjectSize(), VoidFunctor()));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700986
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800987 // reinit array_iftable_ from any array class instance, they should be ==
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700988 array_iftable_ = GcRoot<mirror::IfTable>(GetClassRoot(kObjectArrayClass)->GetIfTable());
Mathieu Chartier2d721012014-11-10 11:08:06 -0800989 DCHECK_EQ(array_iftable_.Read(), GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800990 // String class root was set above
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700991 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
992 mirror::Field::SetArrayClass(GetClassRoot(kJavaLangReflectFieldArrayClass));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700993 mirror::Constructor::SetClass(GetClassRoot(kJavaLangReflectConstructor));
994 mirror::Constructor::SetArrayClass(GetClassRoot(kJavaLangReflectConstructorArrayClass));
995 mirror::Method::SetClass(GetClassRoot(kJavaLangReflectMethod));
996 mirror::Method::SetArrayClass(GetClassRoot(kJavaLangReflectMethodArrayClass));
Narayan Kamathafa48272016-08-03 12:46:58 +0100997 mirror::MethodType::SetClass(GetClassRoot(kJavaLangInvokeMethodType));
998 mirror::MethodHandleImpl::SetClass(GetClassRoot(kJavaLangInvokeMethodHandleImpl));
Orion Hodsonc069a302017-01-18 09:23:12 +0000999 mirror::MethodHandlesLookup::SetClass(GetClassRoot(kJavaLangInvokeMethodHandlesLookup));
1000 mirror::CallSite::SetClass(GetClassRoot(kJavaLangInvokeCallSite));
Fred Shih4ee7a662014-07-11 09:59:27 -07001001 mirror::Reference::SetClass(GetClassRoot(kJavaLangRefReference));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001002 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1003 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1004 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1005 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1006 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1007 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1008 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1009 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1010 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1011 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Narayan Kamath000e1882016-10-24 17:14:25 +01001012 mirror::EmulatedStackFrame::SetClass(GetClassRoot(kDalvikSystemEmulatedStackFrame));
Alex Lightd6251582016-10-31 11:12:30 -07001013 mirror::ClassExt::SetClass(GetClassRoot(kDalvikSystemClassExt));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001014
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001015 for (gc::space::ImageSpace* image_space : spaces) {
1016 // Boot class loader, use a null handle.
1017 std::vector<std::unique_ptr<const DexFile>> dex_files;
1018 if (!AddImageSpace(image_space,
1019 ScopedNullHandle<mirror::ClassLoader>(),
1020 /*dex_elements*/nullptr,
1021 /*dex_location*/nullptr,
1022 /*out*/&dex_files,
1023 error_msg)) {
1024 return false;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001025 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001026 // Append opened dex files at the end.
1027 boot_dex_files_.insert(boot_dex_files_.end(),
1028 std::make_move_iterator(dex_files.begin()),
1029 std::make_move_iterator(dex_files.end()));
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08001030 }
Ian Rogers98379392014-02-24 16:53:16 -08001031 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001032
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001033 VLOG(startup) << __FUNCTION__ << " exiting";
1034 return true;
1035}
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001036
Jeff Hao5872d7c2016-04-27 11:07:41 -07001037bool ClassLinker::IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001038 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001039 return class_loader == nullptr ||
Mathieu Chartier0795f232016-09-27 18:43:30 -07001040 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader) ==
1041 class_loader->GetClass();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001042}
1043
Andreas Gampe08883de2016-11-08 13:20:52 -08001044static mirror::String* GetDexPathListElementName(ObjPtr<mirror::Object> element)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001045 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001046 ArtField* const dex_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001047 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001048 ArtField* const dex_file_name_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001049 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_fileName);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001050 DCHECK(dex_file_field != nullptr);
1051 DCHECK(dex_file_name_field != nullptr);
1052 DCHECK(element != nullptr);
David Sehr709b0702016-10-13 09:12:37 -07001053 CHECK_EQ(dex_file_field->GetDeclaringClass(), element->GetClass()) << element->PrettyTypeOf();
Mathieu Chartier3398c782016-09-30 10:27:43 -07001054 ObjPtr<mirror::Object> dex_file = dex_file_field->GetObject(element);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001055 if (dex_file == nullptr) {
1056 return nullptr;
1057 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07001058 ObjPtr<mirror::Object> name_object = dex_file_name_field->GetObject(dex_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001059 if (name_object != nullptr) {
1060 return name_object->AsString();
1061 }
1062 return nullptr;
1063}
1064
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001065static bool FlattenPathClassLoader(ObjPtr<mirror::ClassLoader> class_loader,
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001066 std::list<mirror::String*>* out_dex_file_names,
1067 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001068 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001069 DCHECK(out_dex_file_names != nullptr);
1070 DCHECK(error_msg != nullptr);
1071 ScopedObjectAccessUnchecked soa(Thread::Current());
1072 ArtField* const dex_path_list_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001073 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001074 ArtField* const dex_elements_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001075 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001076 CHECK(dex_path_list_field != nullptr);
1077 CHECK(dex_elements_field != nullptr);
Jeff Hao5872d7c2016-04-27 11:07:41 -07001078 while (!ClassLinker::IsBootClassLoader(soa, class_loader)) {
Mathieu Chartier0795f232016-09-27 18:43:30 -07001079 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader) !=
1080 class_loader->GetClass()) {
David Sehr709b0702016-10-13 09:12:37 -07001081 *error_msg = StringPrintf("Unknown class loader type %s",
1082 class_loader->PrettyTypeOf().c_str());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001083 // Unsupported class loader.
1084 return false;
1085 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07001086 ObjPtr<mirror::Object> dex_path_list = dex_path_list_field->GetObject(class_loader);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001087 if (dex_path_list != nullptr) {
1088 // DexPathList has an array dexElements of Elements[] which each contain a dex file.
Mathieu Chartier3398c782016-09-30 10:27:43 -07001089 ObjPtr<mirror::Object> dex_elements_obj = dex_elements_field->GetObject(dex_path_list);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001090 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
1091 // at the mCookie which is a DexFile vector.
1092 if (dex_elements_obj != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001093 ObjPtr<mirror::ObjectArray<mirror::Object>> dex_elements =
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001094 dex_elements_obj->AsObjectArray<mirror::Object>();
1095 // Reverse order since we insert the parent at the front.
1096 for (int32_t i = dex_elements->GetLength() - 1; i >= 0; --i) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001097 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001098 if (element == nullptr) {
1099 *error_msg = StringPrintf("Null dex element at index %d", i);
1100 return false;
1101 }
Andreas Gampe08883de2016-11-08 13:20:52 -08001102 ObjPtr<mirror::String> const name = GetDexPathListElementName(element);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001103 if (name == nullptr) {
1104 *error_msg = StringPrintf("Null name for dex element at index %d", i);
1105 return false;
1106 }
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07001107 out_dex_file_names->push_front(name.Ptr());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001108 }
1109 }
1110 }
1111 class_loader = class_loader->GetParent();
1112 }
1113 return true;
1114}
1115
1116class FixupArtMethodArrayVisitor : public ArtMethodVisitor {
1117 public:
1118 explicit FixupArtMethodArrayVisitor(const ImageHeader& header) : header_(header) {}
1119
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001120 virtual void Visit(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light36121492016-02-22 13:43:29 -08001121 const bool is_copied = method->IsCopied();
Andreas Gampe542451c2016-07-26 09:02:02 -07001122 ArtMethod** resolved_methods = method->GetDexCacheResolvedMethods(kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001123 if (resolved_methods != nullptr) {
1124 bool in_image_space = false;
Alex Light36121492016-02-22 13:43:29 -08001125 if (kIsDebugBuild || is_copied) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001126 in_image_space = header_.GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains(
1127 reinterpret_cast<const uint8_t*>(resolved_methods) - header_.GetImageBegin());
1128 }
1129 // Must be in image space for non-miranda method.
Alex Light36121492016-02-22 13:43:29 -08001130 DCHECK(is_copied || in_image_space)
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001131 << resolved_methods << " is not in image starting at "
1132 << reinterpret_cast<void*>(header_.GetImageBegin());
Alex Light36121492016-02-22 13:43:29 -08001133 if (!is_copied || in_image_space) {
Vladimir Marko6dd14882016-10-25 11:51:35 +01001134 method->SetDexCacheResolvedMethods(method->GetDexCache()->GetResolvedMethods(),
Andreas Gampe542451c2016-07-26 09:02:02 -07001135 kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001136 }
1137 }
1138 }
1139
1140 private:
1141 const ImageHeader& header_;
1142};
1143
1144class VerifyClassInTableArtMethodVisitor : public ArtMethodVisitor {
1145 public:
1146 explicit VerifyClassInTableArtMethodVisitor(ClassTable* table) : table_(table) {}
1147
1148 virtual void Visit(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001149 REQUIRES_SHARED(Locks::mutator_lock_, Locks::classlinker_classes_lock_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001150 ObjPtr<mirror::Class> klass = method->GetDeclaringClass();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001151 if (klass != nullptr && !Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) {
David Sehr709b0702016-10-13 09:12:37 -07001152 CHECK_EQ(table_->LookupByDescriptor(klass), klass) << mirror::Class::PrettyClass(klass);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001153 }
1154 }
1155
1156 private:
1157 ClassTable* const table_;
1158};
1159
Vladimir Markobfb80d22017-02-14 14:08:12 +00001160class VerifyDirectInterfacesInTableClassVisitor {
1161 public:
1162 explicit VerifyDirectInterfacesInTableClassVisitor(ObjPtr<mirror::ClassLoader> class_loader)
1163 : class_loader_(class_loader), self_(Thread::Current()) { }
1164
1165 bool operator()(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) {
1166 if (!klass->IsPrimitive() && klass->GetClassLoader() == class_loader_) {
1167 classes_.push_back(klass);
1168 }
1169 return true;
1170 }
1171
1172 void Check() const REQUIRES_SHARED(Locks::mutator_lock_) {
1173 for (ObjPtr<mirror::Class> klass : classes_) {
1174 for (uint32_t i = 0, num = klass->NumDirectInterfaces(); i != num; ++i) {
1175 CHECK(klass->GetDirectInterface(self_, klass, i) != nullptr)
1176 << klass->PrettyDescriptor() << " iface #" << i
1177 << klass->GetDexFile().StringByTypeIdx(klass->GetDirectInterfaceTypeIdx(i))
1178 << " Bug: 34839984";
1179 }
1180 }
1181 }
1182
1183 private:
1184 ObjPtr<mirror::ClassLoader> class_loader_;
1185 Thread* self_;
1186 std::vector<ObjPtr<mirror::Class>> classes_;
1187};
1188
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001189class VerifyDeclaringClassVisitor : public ArtMethodVisitor {
1190 public:
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001191 VerifyDeclaringClassVisitor() REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_)
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001192 : live_bitmap_(Runtime::Current()->GetHeap()->GetLiveBitmap()) {}
1193
1194 virtual void Visit(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001195 REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001196 ObjPtr<mirror::Class> klass = method->GetDeclaringClassUnchecked();
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001197 if (klass != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001198 CHECK(live_bitmap_->Test(klass.Ptr())) << "Image method has unmarked declaring class";
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001199 }
1200 }
1201
1202 private:
1203 gc::accounting::HeapBitmap* const live_bitmap_;
1204};
1205
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001206// Copies data from one array to another array at the same position
1207// if pred returns false. If there is a page of continuous data in
1208// the src array for which pred consistently returns true then
1209// corresponding page in the dst array will not be touched.
1210// This should reduce number of allocated physical pages.
1211template <class T, class NullPred>
1212static void CopyNonNull(const T* src, size_t count, T* dst, const NullPred& pred) {
1213 for (size_t i = 0; i < count; ++i) {
1214 if (!pred(src[i])) {
1215 dst[i] = src[i];
1216 }
1217 }
1218}
1219
Vladimir Markobfb80d22017-02-14 14:08:12 +00001220template <typename T>
1221static void CopyDexCachePairs(const std::atomic<mirror::DexCachePair<T>>* src,
1222 size_t count,
1223 std::atomic<mirror::DexCachePair<T>>* dst) {
1224 DCHECK_NE(count, 0u);
1225 DCHECK(!src[0].load(std::memory_order_relaxed).object.IsNull() ||
1226 src[0].load(std::memory_order_relaxed).index != 0u);
1227 for (size_t i = 0; i < count; ++i) {
1228 DCHECK_EQ(dst[i].load(std::memory_order_relaxed).index, 0u);
1229 DCHECK(dst[i].load(std::memory_order_relaxed).object.IsNull());
1230 mirror::DexCachePair<T> source = src[i].load(std::memory_order_relaxed);
1231 if (source.index != 0u || !source.object.IsNull()) {
1232 dst[i].store(source, std::memory_order_relaxed);
1233 }
1234 }
1235}
1236
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001237bool ClassLinker::UpdateAppImageClassLoadersAndDexCaches(
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001238 gc::space::ImageSpace* space,
1239 Handle<mirror::ClassLoader> class_loader,
1240 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
Mathieu Chartier69731002016-03-02 16:08:31 -08001241 ClassTable::ClassSet* new_class_set,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001242 bool* out_forward_dex_cache_array,
1243 std::string* out_error_msg) {
1244 DCHECK(out_forward_dex_cache_array != nullptr);
1245 DCHECK(out_error_msg != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001246 Thread* const self = Thread::Current();
1247 gc::Heap* const heap = Runtime::Current()->GetHeap();
1248 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001249 {
1250 // Add image classes into the class table for the class loader, and fixup the dex caches and
1251 // class loader fields.
1252 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001253 // Dex cache array fixup is all or nothing, we must reject app images that have mixed since we
1254 // rely on clobering the dex cache arrays in the image to forward to bss.
1255 size_t num_dex_caches_with_bss_arrays = 0;
1256 const size_t num_dex_caches = dex_caches->GetLength();
1257 for (size_t i = 0; i < num_dex_caches; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001258 ObjPtr<mirror::DexCache> const dex_cache = dex_caches->Get(i);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001259 const DexFile* const dex_file = dex_cache->GetDexFile();
1260 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
1261 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
1262 ++num_dex_caches_with_bss_arrays;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001263 }
1264 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001265 *out_forward_dex_cache_array = num_dex_caches_with_bss_arrays != 0;
1266 if (*out_forward_dex_cache_array) {
1267 if (num_dex_caches_with_bss_arrays != num_dex_caches) {
1268 // Reject application image since we cannot forward only some of the dex cache arrays.
1269 // TODO: We could get around this by having a dedicated forwarding slot. It should be an
1270 // uncommon case.
1271 *out_error_msg = StringPrintf("Dex caches in bss does not match total: %zu vs %zu",
1272 num_dex_caches_with_bss_arrays,
1273 num_dex_caches);
1274 return false;
1275 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001276 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001277 // Only add the classes to the class loader after the points where we can return false.
1278 for (size_t i = 0; i < num_dex_caches; i++) {
Vladimir Marko1bc4b172016-10-24 16:53:39 +00001279 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001280 const DexFile* const dex_file = dex_cache->GetDexFile();
1281 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
1282 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01001283 // If the oat file expects the dex cache arrays to be in the BSS, then allocate there and
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001284 // copy over the arrays.
1285 DCHECK(dex_file != nullptr);
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001286 size_t num_strings = mirror::DexCache::kDexCacheStringCacheSize;
1287 if (dex_file->NumStringIds() < num_strings) {
1288 num_strings = dex_file->NumStringIds();
1289 }
Vladimir Markobfb80d22017-02-14 14:08:12 +00001290 size_t num_types = mirror::DexCache::kDexCacheTypeCacheSize;
1291 if (dex_file->NumTypeIds() < num_types) {
1292 num_types = dex_file->NumTypeIds();
1293 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001294 const size_t num_methods = dex_file->NumMethodIds();
1295 const size_t num_fields = dex_file->NumFieldIds();
Narayan Kamath269cb432016-10-28 10:19:54 +01001296 size_t num_method_types = mirror::DexCache::kDexCacheMethodTypeCacheSize;
1297 if (dex_file->NumProtoIds() < num_method_types) {
1298 num_method_types = dex_file->NumProtoIds();
Narayan Kamath25352fc2016-08-03 12:46:58 +01001299 }
Orion Hodsonc069a302017-01-18 09:23:12 +00001300 const size_t num_call_sites = dex_file->NumCallSiteIds();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001301 CHECK_EQ(num_strings, dex_cache->NumStrings());
1302 CHECK_EQ(num_types, dex_cache->NumResolvedTypes());
1303 CHECK_EQ(num_methods, dex_cache->NumResolvedMethods());
1304 CHECK_EQ(num_fields, dex_cache->NumResolvedFields());
Narayan Kamath25352fc2016-08-03 12:46:58 +01001305 CHECK_EQ(num_method_types, dex_cache->NumResolvedMethodTypes());
Orion Hodsonc069a302017-01-18 09:23:12 +00001306 CHECK_EQ(num_call_sites, dex_cache->NumResolvedCallSites());
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001307 DexCacheArraysLayout layout(image_pointer_size_, dex_file);
1308 uint8_t* const raw_arrays = oat_dex_file->GetDexCacheArrays();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001309 if (num_strings != 0u) {
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001310 mirror::StringDexCacheType* const image_resolved_strings = dex_cache->GetStrings();
1311 mirror::StringDexCacheType* const strings =
1312 reinterpret_cast<mirror::StringDexCacheType*>(raw_arrays + layout.StringsOffset());
Vladimir Markobfb80d22017-02-14 14:08:12 +00001313 CopyDexCachePairs(image_resolved_strings, num_strings, strings);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001314 dex_cache->SetStrings(strings);
1315 }
1316 if (num_types != 0u) {
Vladimir Markobfb80d22017-02-14 14:08:12 +00001317 mirror::TypeDexCacheType* const image_resolved_types = dex_cache->GetResolvedTypes();
1318 mirror::TypeDexCacheType* const types =
1319 reinterpret_cast<mirror::TypeDexCacheType*>(raw_arrays + layout.TypesOffset());
1320 CopyDexCachePairs(image_resolved_types, num_types, types);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001321 dex_cache->SetResolvedTypes(types);
1322 }
1323 if (num_methods != 0u) {
1324 ArtMethod** const methods = reinterpret_cast<ArtMethod**>(
1325 raw_arrays + layout.MethodsOffset());
1326 ArtMethod** const image_resolved_methods = dex_cache->GetResolvedMethods();
1327 for (size_t j = 0; kIsDebugBuild && j < num_methods; ++j) {
1328 DCHECK(methods[j] == nullptr);
1329 }
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001330 CopyNonNull(image_resolved_methods,
1331 num_methods,
1332 methods,
1333 [] (const ArtMethod* method) {
1334 return method == nullptr;
1335 });
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001336 dex_cache->SetResolvedMethods(methods);
1337 }
1338 if (num_fields != 0u) {
1339 ArtField** const fields =
1340 reinterpret_cast<ArtField**>(raw_arrays + layout.FieldsOffset());
1341 for (size_t j = 0; kIsDebugBuild && j < num_fields; ++j) {
1342 DCHECK(fields[j] == nullptr);
1343 }
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001344 CopyNonNull(dex_cache->GetResolvedFields(),
1345 num_fields,
1346 fields,
1347 [] (const ArtField* field) {
1348 return field == nullptr;
1349 });
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001350 dex_cache->SetResolvedFields(fields);
1351 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01001352 if (num_method_types != 0u) {
1353 // NOTE: We currently (Sep 2016) do not resolve any method types at
1354 // compile time, but plan to in the future. This code exists for the
1355 // sake of completeness.
1356 mirror::MethodTypeDexCacheType* const image_resolved_method_types =
1357 dex_cache->GetResolvedMethodTypes();
1358 mirror::MethodTypeDexCacheType* const method_types =
1359 reinterpret_cast<mirror::MethodTypeDexCacheType*>(
1360 raw_arrays + layout.MethodTypesOffset());
Vladimir Markobfb80d22017-02-14 14:08:12 +00001361 CopyDexCachePairs(image_resolved_method_types, num_method_types, method_types);
Narayan Kamath25352fc2016-08-03 12:46:58 +01001362 dex_cache->SetResolvedMethodTypes(method_types);
1363 }
Orion Hodsonc069a302017-01-18 09:23:12 +00001364 if (num_call_sites != 0u) {
1365 GcRoot<mirror::CallSite>* const image_resolved_call_sites =
1366 dex_cache->GetResolvedCallSites();
1367 GcRoot<mirror::CallSite>* const call_sites =
1368 reinterpret_cast<GcRoot<mirror::CallSite>*>(raw_arrays + layout.CallSitesOffset());
1369 for (size_t j = 0; kIsDebugBuild && j < num_call_sites; ++j) {
1370 DCHECK(call_sites[j].IsNull());
1371 }
1372 CopyNonNull(image_resolved_call_sites,
1373 num_call_sites,
1374 call_sites,
1375 [](const GcRoot<mirror::CallSite>& elem) {
1376 return elem.IsNull();
1377 });
1378 dex_cache->SetResolvedCallSites(call_sites);
1379 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001380 }
1381 {
Andreas Gampecc1b5352016-12-01 16:58:38 -08001382 WriterMutexLock mu2(self, *Locks::dex_lock_);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001383 // Make sure to do this after we update the arrays since we store the resolved types array
1384 // in DexCacheData in RegisterDexFileLocked. We need the array pointer to be the one in the
1385 // BSS.
Vladimir Markocd556b02017-02-03 11:47:34 +00001386 CHECK(!FindDexCacheDataLocked(*dex_file).IsValid());
1387 RegisterDexFileLocked(*dex_file, dex_cache, class_loader.Get());
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001388 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001389 if (kIsDebugBuild) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01001390 CHECK(new_class_set != nullptr);
Vladimir Markobfb80d22017-02-14 14:08:12 +00001391 mirror::TypeDexCacheType* const types = dex_cache->GetResolvedTypes();
Vladimir Marko1a1de672016-10-13 12:53:15 +01001392 const size_t num_types = dex_cache->NumResolvedTypes();
Vladimir Markobfb80d22017-02-14 14:08:12 +00001393 for (size_t j = 0; j != num_types; ++j) {
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001394 // The image space is not yet added to the heap, avoid read barriers.
Vladimir Markobfb80d22017-02-14 14:08:12 +00001395 ObjPtr<mirror::Class> klass = types[j].load(std::memory_order_relaxed).object.Read();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001396 if (space->HasAddress(klass.Ptr())) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00001397 DCHECK(!klass->IsErroneous()) << klass->GetStatus();
Mathieu Chartier58c3f6a2016-12-01 14:21:11 -08001398 auto it = new_class_set->Find(ClassTable::TableSlot(klass));
Vladimir Marko1a1de672016-10-13 12:53:15 +01001399 DCHECK(it != new_class_set->end());
1400 DCHECK_EQ(it->Read(), klass);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001401 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Vladimir Marko1a1de672016-10-13 12:53:15 +01001402 if (super_class != nullptr && !heap->ObjectIsInBootImageSpace(super_class)) {
Mathieu Chartier58c3f6a2016-12-01 14:21:11 -08001403 auto it2 = new_class_set->Find(ClassTable::TableSlot(super_class));
Vladimir Marko1a1de672016-10-13 12:53:15 +01001404 DCHECK(it2 != new_class_set->end());
1405 DCHECK_EQ(it2->Read(), super_class);
1406 }
1407 for (ArtMethod& m : klass->GetDirectMethods(kRuntimePointerSize)) {
1408 const void* code = m.GetEntryPointFromQuickCompiledCode();
1409 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
1410 if (!IsQuickResolutionStub(code) &&
1411 !IsQuickGenericJniStub(code) &&
1412 !IsQuickToInterpreterBridge(code) &&
1413 !m.IsNative()) {
David Sehr709b0702016-10-13 09:12:37 -07001414 DCHECK_EQ(code, oat_code) << m.PrettyMethod();
Mathieu Chartier69731002016-03-02 16:08:31 -08001415 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001416 }
Vladimir Marko1a1de672016-10-13 12:53:15 +01001417 for (ArtMethod& m : klass->GetVirtualMethods(kRuntimePointerSize)) {
1418 const void* code = m.GetEntryPointFromQuickCompiledCode();
1419 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
1420 if (!IsQuickResolutionStub(code) &&
1421 !IsQuickGenericJniStub(code) &&
1422 !IsQuickToInterpreterBridge(code) &&
1423 !m.IsNative()) {
David Sehr709b0702016-10-13 09:12:37 -07001424 DCHECK_EQ(code, oat_code) << m.PrettyMethod();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001425 }
1426 }
1427 }
1428 }
1429 }
1430 }
Mathieu Chartiera0b95212016-03-07 16:13:54 -08001431 }
1432 if (*out_forward_dex_cache_array) {
1433 ScopedTrace timing("Fixup ArtMethod dex cache arrays");
1434 FixupArtMethodArrayVisitor visitor(header);
Andreas Gampe542451c2016-07-26 09:02:02 -07001435 header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
Mathieu Chartiera0b95212016-03-07 16:13:54 -08001436 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get());
1437 }
1438 if (kVerifyArtMethodDeclaringClasses) {
1439 ScopedTrace timing("Verify declaring classes");
1440 ReaderMutexLock rmu(self, *Locks::heap_bitmap_lock_);
1441 VerifyDeclaringClassVisitor visitor;
Andreas Gampe542451c2016-07-26 09:02:02 -07001442 header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001443 }
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001444 return true;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001445}
1446
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001447// Update the class loader. Should only be used on classes in the image space.
1448class UpdateClassLoaderVisitor {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001449 public:
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001450 UpdateClassLoaderVisitor(gc::space::ImageSpace* space, ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001451 : space_(space),
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001452 class_loader_(class_loader) {}
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001453
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001454 bool operator()(ObjPtr<mirror::Class> klass) const REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00001455 // Do not update class loader for boot image classes where the app image
1456 // class loader is only the initiating loader but not the defining loader.
1457 if (klass->GetClassLoader() != nullptr) {
1458 klass->SetClassLoader(class_loader_);
1459 }
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001460 return true;
1461 }
1462
1463 gc::space::ImageSpace* const space_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001464 ObjPtr<mirror::ClassLoader> const class_loader_;
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001465};
1466
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001467static std::unique_ptr<const DexFile> OpenOatDexFile(const OatFile* oat_file,
1468 const char* location,
1469 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001470 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001471 DCHECK(error_msg != nullptr);
1472 std::unique_ptr<const DexFile> dex_file;
Richard Uhler9a37efc2016-08-05 16:32:55 -07001473 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(location, nullptr, error_msg);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001474 if (oat_dex_file == nullptr) {
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001475 return std::unique_ptr<const DexFile>();
1476 }
1477 std::string inner_error_msg;
1478 dex_file = oat_dex_file->OpenDexFile(&inner_error_msg);
1479 if (dex_file == nullptr) {
1480 *error_msg = StringPrintf("Failed to open dex file %s from within oat file %s error '%s'",
1481 location,
1482 oat_file->GetLocation().c_str(),
1483 inner_error_msg.c_str());
1484 return std::unique_ptr<const DexFile>();
1485 }
1486
1487 if (dex_file->GetLocationChecksum() != oat_dex_file->GetDexFileLocationChecksum()) {
1488 *error_msg = StringPrintf("Checksums do not match for %s: %x vs %x",
1489 location,
1490 dex_file->GetLocationChecksum(),
1491 oat_dex_file->GetDexFileLocationChecksum());
1492 return std::unique_ptr<const DexFile>();
1493 }
1494 return dex_file;
1495}
1496
1497bool ClassLinker::OpenImageDexFiles(gc::space::ImageSpace* space,
1498 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
1499 std::string* error_msg) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07001500 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001501 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001502 ObjPtr<mirror::Object> dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001503 DCHECK(dex_caches_object != nullptr);
1504 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1505 dex_caches_object->AsObjectArray<mirror::DexCache>();
1506 const OatFile* oat_file = space->GetOatFile();
1507 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001508 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001509 std::string dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
1510 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file,
1511 dex_file_location.c_str(),
1512 error_msg);
1513 if (dex_file == nullptr) {
1514 return false;
1515 }
1516 dex_cache->SetDexFile(dex_file.get());
1517 out_dex_files->push_back(std::move(dex_file));
1518 }
1519 return true;
1520}
1521
Andreas Gampe0793bec2016-12-01 11:37:33 -08001522// Helper class for ArtMethod checks when adding an image. Keeps all required functionality
1523// together and caches some intermediate results.
1524class ImageSanityChecks FINAL {
1525 public:
1526 static void CheckObjects(gc::Heap* heap, ClassLinker* class_linker)
1527 REQUIRES_SHARED(Locks::mutator_lock_) {
1528 ImageSanityChecks isc(heap, class_linker);
1529 heap->VisitObjects(ImageSanityChecks::SanityCheckObjectsCallback, &isc);
1530 }
1531
1532 static void CheckPointerArray(gc::Heap* heap,
1533 ClassLinker* class_linker,
1534 ArtMethod** arr,
1535 size_t size)
1536 REQUIRES_SHARED(Locks::mutator_lock_) {
1537 ImageSanityChecks isc(heap, class_linker);
1538 isc.SanityCheckArtMethodPointerArray(arr, size);
1539 }
1540
1541 static void SanityCheckObjectsCallback(mirror::Object* obj, void* arg)
1542 REQUIRES_SHARED(Locks::mutator_lock_) {
1543 DCHECK(obj != nullptr);
1544 CHECK(obj->GetClass() != nullptr) << "Null class in object " << obj;
1545 CHECK(obj->GetClass()->GetClass() != nullptr) << "Null class class " << obj;
1546 if (obj->IsClass()) {
1547 ImageSanityChecks* isc = reinterpret_cast<ImageSanityChecks*>(arg);
1548
1549 auto klass = obj->AsClass();
1550 for (ArtField& field : klass->GetIFields()) {
1551 CHECK_EQ(field.GetDeclaringClass(), klass);
1552 }
1553 for (ArtField& field : klass->GetSFields()) {
1554 CHECK_EQ(field.GetDeclaringClass(), klass);
1555 }
1556 const auto pointer_size = isc->pointer_size_;
1557 for (auto& m : klass->GetMethods(pointer_size)) {
1558 isc->SanityCheckArtMethod(&m, klass);
1559 }
1560 auto* vtable = klass->GetVTable();
1561 if (vtable != nullptr) {
1562 isc->SanityCheckArtMethodPointerArray(vtable, nullptr);
1563 }
1564 if (klass->ShouldHaveImt()) {
1565 ImTable* imt = klass->GetImt(pointer_size);
1566 for (size_t i = 0; i < ImTable::kSize; ++i) {
1567 isc->SanityCheckArtMethod(imt->Get(i, pointer_size), nullptr);
1568 }
1569 }
1570 if (klass->ShouldHaveEmbeddedVTable()) {
1571 for (int32_t i = 0; i < klass->GetEmbeddedVTableLength(); ++i) {
1572 isc->SanityCheckArtMethod(klass->GetEmbeddedVTableEntry(i, pointer_size), nullptr);
1573 }
1574 }
1575 mirror::IfTable* iftable = klass->GetIfTable();
1576 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
1577 if (iftable->GetMethodArrayCount(i) > 0) {
1578 isc->SanityCheckArtMethodPointerArray(iftable->GetMethodArray(i), nullptr);
1579 }
1580 }
1581 }
1582 }
1583
1584 private:
1585 ImageSanityChecks(gc::Heap* heap, ClassLinker* class_linker)
1586 : spaces_(heap->GetBootImageSpaces()),
1587 pointer_size_(class_linker->GetImagePointerSize()) {
1588 space_begin_.reserve(spaces_.size());
1589 method_sections_.reserve(spaces_.size());
1590 runtime_method_sections_.reserve(spaces_.size());
1591 for (gc::space::ImageSpace* space : spaces_) {
1592 space_begin_.push_back(space->Begin());
1593 auto& header = space->GetImageHeader();
1594 method_sections_.push_back(&header.GetMethodsSection());
1595 runtime_method_sections_.push_back(&header.GetRuntimeMethodsSection());
1596 }
1597 }
1598
1599 void SanityCheckArtMethod(ArtMethod* m, ObjPtr<mirror::Class> expected_class)
1600 REQUIRES_SHARED(Locks::mutator_lock_) {
1601 if (m->IsRuntimeMethod()) {
1602 ObjPtr<mirror::Class> declaring_class = m->GetDeclaringClassUnchecked();
1603 CHECK(declaring_class == nullptr) << declaring_class << " " << m->PrettyMethod();
1604 } else if (m->IsCopied()) {
1605 CHECK(m->GetDeclaringClass() != nullptr) << m->PrettyMethod();
1606 } else if (expected_class != nullptr) {
1607 CHECK_EQ(m->GetDeclaringClassUnchecked(), expected_class) << m->PrettyMethod();
1608 }
1609 if (!spaces_.empty()) {
1610 bool contains = false;
1611 for (size_t i = 0; !contains && i != space_begin_.size(); ++i) {
1612 const size_t offset = reinterpret_cast<uint8_t*>(m) - space_begin_[i];
1613 contains = method_sections_[i]->Contains(offset) ||
1614 runtime_method_sections_[i]->Contains(offset);
1615 }
1616 CHECK(contains) << m << " not found";
1617 }
1618 }
1619
1620 void SanityCheckArtMethodPointerArray(ObjPtr<mirror::PointerArray> arr,
1621 ObjPtr<mirror::Class> expected_class)
1622 REQUIRES_SHARED(Locks::mutator_lock_) {
1623 CHECK(arr != nullptr);
1624 for (int32_t j = 0; j < arr->GetLength(); ++j) {
1625 auto* method = arr->GetElementPtrSize<ArtMethod*>(j, pointer_size_);
1626 // expected_class == null means we are a dex cache.
1627 if (expected_class != nullptr) {
1628 CHECK(method != nullptr);
1629 }
1630 if (method != nullptr) {
1631 SanityCheckArtMethod(method, expected_class);
1632 }
1633 }
1634 }
1635
1636 void SanityCheckArtMethodPointerArray(ArtMethod** arr, size_t size)
1637 REQUIRES_SHARED(Locks::mutator_lock_) {
1638 CHECK_EQ(arr != nullptr, size != 0u);
1639 if (arr != nullptr) {
1640 bool contains = false;
1641 for (auto space : spaces_) {
1642 auto offset = reinterpret_cast<uint8_t*>(arr) - space->Begin();
1643 if (space->GetImageHeader().GetImageSection(
1644 ImageHeader::kSectionDexCacheArrays).Contains(offset)) {
1645 contains = true;
1646 break;
1647 }
1648 }
1649 CHECK(contains);
1650 }
1651 for (size_t j = 0; j < size; ++j) {
1652 ArtMethod* method = mirror::DexCache::GetElementPtrSize(arr, j, pointer_size_);
1653 // expected_class == null means we are a dex cache.
1654 if (method != nullptr) {
1655 SanityCheckArtMethod(method, nullptr);
1656 }
1657 }
1658 }
1659
1660 const std::vector<gc::space::ImageSpace*>& spaces_;
1661 const PointerSize pointer_size_;
1662
1663 // Cached sections from the spaces.
1664 std::vector<const uint8_t*> space_begin_;
1665 std::vector<const ImageSection*> method_sections_;
1666 std::vector<const ImageSection*> runtime_method_sections_;
1667};
1668
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001669bool ClassLinker::AddImageSpace(
1670 gc::space::ImageSpace* space,
1671 Handle<mirror::ClassLoader> class_loader,
1672 jobjectArray dex_elements,
1673 const char* dex_location,
1674 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
1675 std::string* error_msg) {
1676 DCHECK(out_dex_files != nullptr);
1677 DCHECK(error_msg != nullptr);
1678 const uint64_t start_time = NanoTime();
Andreas Gampefa4333d2017-02-14 11:10:34 -08001679 const bool app_image = class_loader != nullptr;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001680 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001681 ObjPtr<mirror::Object> dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001682 DCHECK(dex_caches_object != nullptr);
1683 Runtime* const runtime = Runtime::Current();
1684 gc::Heap* const heap = runtime->GetHeap();
1685 Thread* const self = Thread::Current();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001686 // Check that the image is what we are expecting.
1687 if (image_pointer_size_ != space->GetImageHeader().GetPointerSize()) {
1688 *error_msg = StringPrintf("Application image pointer size does not match runtime: %zu vs %zu",
1689 static_cast<size_t>(space->GetImageHeader().GetPointerSize()),
1690 image_pointer_size_);
1691 return false;
1692 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001693 size_t expected_image_roots = ImageHeader::NumberOfImageRoots(app_image);
1694 if (static_cast<size_t>(header.GetImageRoots()->GetLength()) != expected_image_roots) {
1695 *error_msg = StringPrintf("Expected %zu image roots but got %d",
1696 expected_image_roots,
1697 header.GetImageRoots()->GetLength());
1698 return false;
1699 }
1700 StackHandleScope<3> hs(self);
1701 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches(
1702 hs.NewHandle(dex_caches_object->AsObjectArray<mirror::DexCache>()));
1703 Handle<mirror::ObjectArray<mirror::Class>> class_roots(hs.NewHandle(
1704 header.GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>()));
1705 static_assert(ImageHeader::kClassLoader + 1u == ImageHeader::kImageRootsMax,
1706 "Class loader should be the last image root.");
1707 MutableHandle<mirror::ClassLoader> image_class_loader(hs.NewHandle(
1708 app_image ? header.GetImageRoot(ImageHeader::kClassLoader)->AsClassLoader() : nullptr));
Andreas Gampefa4333d2017-02-14 11:10:34 -08001709 DCHECK(class_roots != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001710 if (class_roots->GetLength() != static_cast<int32_t>(kClassRootsMax)) {
1711 *error_msg = StringPrintf("Expected %d class roots but got %d",
1712 class_roots->GetLength(),
1713 static_cast<int32_t>(kClassRootsMax));
1714 return false;
1715 }
1716 // Check against existing class roots to make sure they match the ones in the boot image.
1717 for (size_t i = 0; i < kClassRootsMax; i++) {
1718 if (class_roots->Get(i) != GetClassRoot(static_cast<ClassRoot>(i))) {
1719 *error_msg = "App image class roots must have pointer equality with runtime ones.";
1720 return false;
1721 }
1722 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001723 const OatFile* oat_file = space->GetOatFile();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001724 if (oat_file->GetOatHeader().GetDexFileCount() !=
1725 static_cast<uint32_t>(dex_caches->GetLength())) {
1726 *error_msg = "Dex cache count and dex file count mismatch while trying to initialize from "
1727 "image";
1728 return false;
1729 }
1730
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001731 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Vladimir Markocd556b02017-02-03 11:47:34 +00001732 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
1733 std::string dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001734 // TODO: Only store qualified paths.
1735 // If non qualified, qualify it.
1736 if (dex_file_location.find('/') == std::string::npos) {
1737 std::string dex_location_path = dex_location;
1738 const size_t pos = dex_location_path.find_last_of('/');
1739 CHECK_NE(pos, std::string::npos);
1740 dex_location_path = dex_location_path.substr(0, pos + 1); // Keep trailing '/'
1741 dex_file_location = dex_location_path + dex_file_location;
1742 }
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001743 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file,
1744 dex_file_location.c_str(),
1745 error_msg);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001746 if (dex_file == nullptr) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001747 return false;
1748 }
1749
1750 if (app_image) {
1751 // The current dex file field is bogus, overwrite it so that we can get the dex file in the
1752 // loop below.
Vladimir Markocd556b02017-02-03 11:47:34 +00001753 dex_cache->SetDexFile(dex_file.get());
Vladimir Markobfb80d22017-02-14 14:08:12 +00001754 mirror::TypeDexCacheType* const types = dex_cache->GetResolvedTypes();
Vladimir Markocd556b02017-02-03 11:47:34 +00001755 for (int32_t j = 0, num_types = dex_cache->NumResolvedTypes(); j < num_types; j++) {
Vladimir Markobfb80d22017-02-14 14:08:12 +00001756 ObjPtr<mirror::Class> klass = types[j].load(std::memory_order_relaxed).object.Read();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001757 if (klass != nullptr) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00001758 DCHECK(!klass->IsErroneous()) << klass->GetStatus();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001759 }
1760 }
1761 } else {
1762 if (kSanityCheckObjects) {
Andreas Gampe0793bec2016-12-01 11:37:33 -08001763 ImageSanityChecks::CheckPointerArray(heap,
1764 this,
Vladimir Markocd556b02017-02-03 11:47:34 +00001765 dex_cache->GetResolvedMethods(),
1766 dex_cache->NumResolvedMethods());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001767 }
1768 // Register dex files, keep track of existing ones that are conflicts.
Vladimir Markocd556b02017-02-03 11:47:34 +00001769 AppendToBootClassPath(*dex_file.get(), dex_cache);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001770 }
1771 out_dex_files->push_back(std::move(dex_file));
1772 }
1773
1774 if (app_image) {
1775 ScopedObjectAccessUnchecked soa(Thread::Current());
1776 // Check that the class loader resolves the same way as the ones in the image.
1777 // Image class loader [A][B][C][image dex files]
1778 // Class loader = [???][dex_elements][image dex files]
1779 // Need to ensure that [???][dex_elements] == [A][B][C].
1780 // For each class loader, PathClassLoader, the laoder checks the parent first. Also the logic
1781 // for PathClassLoader does this by looping through the array of dex files. To ensure they
1782 // resolve the same way, simply flatten the hierarchy in the way the resolution order would be,
1783 // and check that the dex file names are the same.
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001784 if (IsBootClassLoader(soa, image_class_loader.Get())) {
1785 *error_msg = "Unexpected BootClassLoader in app image";
1786 return false;
1787 }
1788 std::list<mirror::String*> image_dex_file_names;
1789 std::string temp_error_msg;
1790 if (!FlattenPathClassLoader(image_class_loader.Get(), &image_dex_file_names, &temp_error_msg)) {
1791 *error_msg = StringPrintf("Failed to flatten image class loader hierarchy '%s'",
1792 temp_error_msg.c_str());
1793 return false;
1794 }
1795 std::list<mirror::String*> loader_dex_file_names;
1796 if (!FlattenPathClassLoader(class_loader.Get(), &loader_dex_file_names, &temp_error_msg)) {
1797 *error_msg = StringPrintf("Failed to flatten class loader hierarchy '%s'",
1798 temp_error_msg.c_str());
1799 return false;
1800 }
1801 // Add the temporary dex path list elements at the end.
1802 auto elements = soa.Decode<mirror::ObjectArray<mirror::Object>>(dex_elements);
1803 for (size_t i = 0, num_elems = elements->GetLength(); i < num_elems; ++i) {
1804 ObjPtr<mirror::Object> element = elements->GetWithoutChecks(i);
1805 if (element != nullptr) {
1806 // If we are somewhere in the middle of the array, there may be nulls at the end.
1807 loader_dex_file_names.push_back(GetDexPathListElementName(element));
Nicolas Geoffray1df3b552016-04-26 18:30:31 +01001808 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001809 }
1810 // Ignore the number of image dex files since we are adding those to the class loader anyways.
1811 CHECK_GE(static_cast<size_t>(image_dex_file_names.size()),
1812 static_cast<size_t>(dex_caches->GetLength()));
1813 size_t image_count = image_dex_file_names.size() - dex_caches->GetLength();
1814 // Check that the dex file names match.
1815 bool equal = image_count == loader_dex_file_names.size();
1816 if (equal) {
1817 auto it1 = image_dex_file_names.begin();
1818 auto it2 = loader_dex_file_names.begin();
1819 for (size_t i = 0; equal && i < image_count; ++i, ++it1, ++it2) {
1820 equal = equal && (*it1)->Equals(*it2);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001821 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001822 }
1823 if (!equal) {
1824 VLOG(image) << "Image dex files " << image_dex_file_names.size();
1825 for (ObjPtr<mirror::String> name : image_dex_file_names) {
1826 VLOG(image) << name->ToModifiedUtf8();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001827 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001828 VLOG(image) << "Loader dex files " << loader_dex_file_names.size();
1829 for (ObjPtr<mirror::String> name : loader_dex_file_names) {
1830 VLOG(image) << name->ToModifiedUtf8();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001831 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001832 *error_msg = "Rejecting application image due to class loader mismatch";
1833 // Ignore class loader mismatch for now since these would just use possibly incorrect
1834 // oat code anyways. The structural class check should be done in the parent.
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001835 }
1836 }
1837
1838 if (kSanityCheckObjects) {
1839 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
1840 auto* dex_cache = dex_caches->Get(i);
1841 for (size_t j = 0; j < dex_cache->NumResolvedFields(); ++j) {
1842 auto* field = dex_cache->GetResolvedField(j, image_pointer_size_);
1843 if (field != nullptr) {
1844 CHECK(field->GetDeclaringClass()->GetClass() != nullptr);
1845 }
1846 }
1847 }
1848 if (!app_image) {
Andreas Gampe0793bec2016-12-01 11:37:33 -08001849 ImageSanityChecks::CheckObjects(heap, this);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001850 }
1851 }
1852
1853 // Set entry point to interpreter if in InterpretOnly mode.
1854 if (!runtime->IsAotCompiler() && runtime->GetInstrumentation()->InterpretOnly()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001855 SetInterpreterEntrypointArtMethodVisitor visitor(image_pointer_size_);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07001856 header.VisitPackedArtMethods(&visitor, space->Begin(), image_pointer_size_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001857 }
1858
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001859 ClassTable* class_table = nullptr;
1860 {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001861 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001862 class_table = InsertClassTableForClassLoader(class_loader.Get());
Mathieu Chartier69731002016-03-02 16:08:31 -08001863 }
1864 // If we have a class table section, read it and use it for verification in
1865 // UpdateAppImageClassLoadersAndDexCaches.
1866 ClassTable::ClassSet temp_set;
1867 const ImageSection& class_table_section = header.GetImageSection(ImageHeader::kSectionClassTable);
1868 const bool added_class_table = class_table_section.Size() > 0u;
1869 if (added_class_table) {
1870 const uint64_t start_time2 = NanoTime();
1871 size_t read_count = 0;
1872 temp_set = ClassTable::ClassSet(space->Begin() + class_table_section.Offset(),
1873 /*make copy*/false,
1874 &read_count);
Mathieu Chartier69731002016-03-02 16:08:31 -08001875 VLOG(image) << "Adding class table classes took " << PrettyDuration(NanoTime() - start_time2);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001876 }
1877 if (app_image) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001878 bool forward_dex_cache_arrays = false;
1879 if (!UpdateAppImageClassLoadersAndDexCaches(space,
1880 class_loader,
1881 dex_caches,
Vladimir Marko1a1de672016-10-13 12:53:15 +01001882 &temp_set,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001883 /*out*/&forward_dex_cache_arrays,
1884 /*out*/error_msg)) {
1885 return false;
1886 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001887 // Update class loader and resolved strings. If added_class_table is false, the resolved
1888 // strings were forwarded UpdateAppImageClassLoadersAndDexCaches.
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001889 UpdateClassLoaderVisitor visitor(space, class_loader.Get());
1890 for (const ClassTable::TableSlot& root : temp_set) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01001891 visitor(root.Read());
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001892 }
Mathieu Chartier8c4f0412016-02-03 16:40:20 -08001893 // forward_dex_cache_arrays is true iff we copied all of the dex cache arrays into the .bss.
1894 // In this case, madvise away the dex cache arrays section of the image to reduce RAM usage and
1895 // mark as PROT_NONE to catch any invalid accesses.
1896 if (forward_dex_cache_arrays) {
1897 const ImageSection& dex_cache_section = header.GetImageSection(
1898 ImageHeader::kSectionDexCacheArrays);
1899 uint8_t* section_begin = AlignUp(space->Begin() + dex_cache_section.Offset(), kPageSize);
1900 uint8_t* section_end = AlignDown(space->Begin() + dex_cache_section.End(), kPageSize);
1901 if (section_begin < section_end) {
1902 madvise(section_begin, section_end - section_begin, MADV_DONTNEED);
1903 mprotect(section_begin, section_end - section_begin, PROT_NONE);
1904 VLOG(image) << "Released and protected dex cache array image section from "
1905 << reinterpret_cast<const void*>(section_begin) << "-"
1906 << reinterpret_cast<const void*>(section_end);
1907 }
1908 }
Vladimir Marko1998cd02017-01-13 13:02:58 +00001909 }
1910 if (!oat_file->GetBssGcRoots().empty()) {
1911 // Insert oat file to class table for visiting .bss GC roots.
1912 class_table->InsertOatFile(oat_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001913 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001914 if (added_class_table) {
1915 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
1916 class_table->AddClassSet(std::move(temp_set));
1917 }
1918 if (kIsDebugBuild && app_image) {
1919 // This verification needs to happen after the classes have been added to the class loader.
1920 // Since it ensures classes are in the class table.
1921 VerifyClassInTableArtMethodVisitor visitor2(class_table);
Andreas Gampe542451c2016-07-26 09:02:02 -07001922 header.VisitPackedArtMethods(&visitor2, space->Begin(), kRuntimePointerSize);
Mathieu Chartier69731002016-03-02 16:08:31 -08001923 }
Vladimir Markobfb80d22017-02-14 14:08:12 +00001924 if (app_image) {
1925 // TODO: Restrict this check to debug builds. Bug: 34839984
1926 VerifyDirectInterfacesInTableClassVisitor visitor(class_loader.Get());
1927 class_table->Visit(visitor);
1928 visitor.Check();
1929 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001930 VLOG(class_linker) << "Adding image space took " << PrettyDuration(NanoTime() - start_time);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001931 return true;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001932}
1933
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001934bool ClassLinker::ClassInClassTable(ObjPtr<mirror::Class> klass) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001935 ClassTable* const class_table = ClassTableForClassLoader(klass->GetClassLoader());
1936 return class_table != nullptr && class_table->Contains(klass);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001937}
1938
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001939void ClassLinker::VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) {
Mathieu Chartier7778b882015-10-05 16:41:10 -07001940 // Acquire tracing_enabled before locking class linker lock to prevent lock order violation. Since
1941 // enabling tracing requires the mutator lock, there are no race conditions here.
1942 const bool tracing_enabled = Trace::IsTracingEnabled();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001943 Thread* const self = Thread::Current();
1944 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Vladimir Marko9b03cb42017-02-16 16:37:03 +00001945 if (kUseReadBarrier) {
1946 // We do not track new roots for CC.
1947 DCHECK_EQ(0, flags & (kVisitRootFlagNewRoots |
1948 kVisitRootFlagClearRootLog |
1949 kVisitRootFlagStartLoggingNewRoots |
1950 kVisitRootFlagStopLoggingNewRoots));
1951 }
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001952 if ((flags & kVisitRootFlagAllRoots) != 0) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001953 // Argument for how root visiting deals with ArtField and ArtMethod roots.
1954 // There is 3 GC cases to handle:
1955 // Non moving concurrent:
1956 // This case is easy to handle since the reference members of ArtMethod and ArtFields are held
Mathieu Chartierda7c6502015-07-23 16:01:26 -07001957 // live by the class and class roots.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001958 //
1959 // Moving non-concurrent:
1960 // This case needs to call visit VisitNativeRoots in case the classes or dex cache arrays move.
1961 // To prevent missing roots, this case needs to ensure that there is no
1962 // suspend points between the point which we allocate ArtMethod arrays and place them in a
1963 // class which is in the class table.
1964 //
1965 // Moving concurrent:
1966 // Need to make sure to not copy ArtMethods without doing read barriers since the roots are
1967 // marked concurrently and we don't hold the classlinker_classes_lock_ when we do the copy.
Mathieu Chartier58c3f6a2016-12-01 14:21:11 -08001968 //
1969 // Use an unbuffered visitor since the class table uses a temporary GcRoot for holding decoded
1970 // ClassTable::TableSlot. The buffered root visiting would access a stale stack location for
1971 // these objects.
1972 UnbufferedRootVisitor root_visitor(visitor, RootInfo(kRootStickyClass));
1973 boot_class_table_.VisitRoots(root_visitor);
Mathieu Chartier7778b882015-10-05 16:41:10 -07001974 // If tracing is enabled, then mark all the class loaders to prevent unloading.
neo.chaea2d1b282016-11-08 08:40:46 +09001975 if ((flags & kVisitRootFlagClassLoader) != 0 || tracing_enabled) {
Mathieu Chartier7778b882015-10-05 16:41:10 -07001976 for (const ClassLoaderData& data : class_loaders_) {
1977 GcRoot<mirror::Object> root(GcRoot<mirror::Object>(self->DecodeJObject(data.weak_root)));
1978 root.VisitRoot(visitor, RootInfo(kRootVMInternal));
1979 }
1980 }
Vladimir Marko9b03cb42017-02-16 16:37:03 +00001981 } else if (!kUseReadBarrier && (flags & kVisitRootFlagNewRoots) != 0) {
Mathieu Chartierc2e20622014-11-03 11:41:47 -08001982 for (auto& root : new_class_roots_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001983 ObjPtr<mirror::Class> old_ref = root.Read<kWithoutReadBarrier>();
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001984 root.VisitRoot(visitor, RootInfo(kRootStickyClass));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001985 ObjPtr<mirror::Class> new_ref = root.Read<kWithoutReadBarrier>();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001986 // Concurrent moving GC marked new roots through the to-space invariant.
1987 CHECK_EQ(new_ref, old_ref);
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001988 }
Vladimir Marko1998cd02017-01-13 13:02:58 +00001989 for (const OatFile* oat_file : new_bss_roots_boot_oat_files_) {
1990 for (GcRoot<mirror::Object>& root : oat_file->GetBssGcRoots()) {
1991 ObjPtr<mirror::Object> old_ref = root.Read<kWithoutReadBarrier>();
1992 if (old_ref != nullptr) {
1993 DCHECK(old_ref->IsClass());
1994 root.VisitRoot(visitor, RootInfo(kRootStickyClass));
1995 ObjPtr<mirror::Object> new_ref = root.Read<kWithoutReadBarrier>();
1996 // Concurrent moving GC marked new roots through the to-space invariant.
1997 CHECK_EQ(new_ref, old_ref);
1998 }
1999 }
2000 }
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002001 }
Vladimir Marko9b03cb42017-02-16 16:37:03 +00002002 if (!kUseReadBarrier && (flags & kVisitRootFlagClearRootLog) != 0) {
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002003 new_class_roots_.clear();
Vladimir Marko1998cd02017-01-13 13:02:58 +00002004 new_bss_roots_boot_oat_files_.clear();
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002005 }
Vladimir Marko9b03cb42017-02-16 16:37:03 +00002006 if (!kUseReadBarrier && (flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
Vladimir Marko1998cd02017-01-13 13:02:58 +00002007 log_new_roots_ = true;
Vladimir Marko9b03cb42017-02-16 16:37:03 +00002008 } else if (!kUseReadBarrier && (flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
Vladimir Marko1998cd02017-01-13 13:02:58 +00002009 log_new_roots_ = false;
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002010 }
2011 // We deliberately ignore the class roots in the image since we
2012 // handle image roots by using the MS/CMS rescanning of dirty cards.
2013}
2014
Brian Carlstroma663ea52011-08-19 23:33:41 -07002015// Keep in sync with InitCallback. Anything we visit, we need to
2016// reinit references to when reinitializing a ClassLinker from a
2017// mapped image.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002018void ClassLinker::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) {
Mathieu Chartier31000802015-06-14 14:14:37 -07002019 class_roots_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002020 VisitClassRoots(visitor, flags);
Mathieu Chartier31000802015-06-14 14:14:37 -07002021 array_iftable_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartier6cfc2c02015-10-12 15:06:16 -07002022 // Instead of visiting the find_array_class_cache_ drop it so that it doesn't prevent class
2023 // unloading if we are marking roots.
2024 DropFindArrayClassCache();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002025}
2026
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002027class VisitClassLoaderClassesVisitor : public ClassLoaderVisitor {
2028 public:
2029 explicit VisitClassLoaderClassesVisitor(ClassVisitor* visitor)
2030 : visitor_(visitor),
2031 done_(false) {}
2032
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002033 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002034 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002035 ClassTable* const class_table = class_loader->GetClassTable();
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002036 if (!done_ && class_table != nullptr) {
2037 DefiningClassLoaderFilterVisitor visitor(class_loader, visitor_);
2038 if (!class_table->Visit(visitor)) {
2039 // If the visitor ClassTable returns false it means that we don't need to continue.
2040 done_ = true;
2041 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002042 }
2043 }
2044
2045 private:
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002046 // Class visitor that limits the class visits from a ClassTable to the classes with
2047 // the provided defining class loader. This filter is used to avoid multiple visits
2048 // of the same class which can be recorded for multiple initiating class loaders.
2049 class DefiningClassLoaderFilterVisitor : public ClassVisitor {
2050 public:
2051 DefiningClassLoaderFilterVisitor(ObjPtr<mirror::ClassLoader> defining_class_loader,
2052 ClassVisitor* visitor)
2053 : defining_class_loader_(defining_class_loader), visitor_(visitor) { }
2054
2055 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
2056 if (klass->GetClassLoader() != defining_class_loader_) {
2057 return true;
2058 }
2059 return (*visitor_)(klass);
2060 }
2061
2062 ObjPtr<mirror::ClassLoader> const defining_class_loader_;
2063 ClassVisitor* const visitor_;
2064 };
2065
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002066 ClassVisitor* const visitor_;
2067 // If done is true then we don't need to do any more visiting.
2068 bool done_;
2069};
2070
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002071void ClassLinker::VisitClassesInternal(ClassVisitor* visitor) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002072 if (boot_class_table_.Visit(*visitor)) {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002073 VisitClassLoaderClassesVisitor loader_visitor(visitor);
2074 VisitClassLoaders(&loader_visitor);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002075 }
2076}
2077
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002078void ClassLinker::VisitClasses(ClassVisitor* visitor) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002079 Thread* const self = Thread::Current();
2080 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
2081 // Not safe to have thread suspension when we are holding a lock.
2082 if (self != nullptr) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002083 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002084 VisitClassesInternal(visitor);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002085 } else {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002086 VisitClassesInternal(visitor);
Elliott Hughesa2155262011-11-16 16:26:58 -08002087 }
2088}
2089
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002090class GetClassesInToVector : public ClassVisitor {
2091 public:
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002092 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002093 classes_.push_back(klass);
2094 return true;
2095 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002096 std::vector<ObjPtr<mirror::Class>> classes_;
Ian Rogersdbf3be02014-08-29 15:40:08 -07002097};
2098
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002099class GetClassInToObjectArray : public ClassVisitor {
2100 public:
2101 explicit GetClassInToObjectArray(mirror::ObjectArray<mirror::Class>* arr)
2102 : arr_(arr), index_(0) {}
2103
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002104 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002105 ++index_;
2106 if (index_ <= arr_->GetLength()) {
2107 arr_->Set(index_ - 1, klass);
2108 return true;
2109 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002110 return false;
2111 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002112
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002113 bool Succeeded() const REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002114 return index_ <= arr_->GetLength();
2115 }
2116
2117 private:
2118 mirror::ObjectArray<mirror::Class>* const arr_;
2119 int32_t index_;
2120};
2121
2122void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002123 // TODO: it may be possible to avoid secondary storage if we iterate over dex caches. The problem
2124 // is avoiding duplicates.
2125 if (!kMovingClasses) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002126 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002127 GetClassesInToVector accumulator;
2128 VisitClasses(&accumulator);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002129 for (ObjPtr<mirror::Class> klass : accumulator.classes_) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002130 if (!visitor->operator()(klass)) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002131 return;
2132 }
2133 }
2134 } else {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002135 Thread* const self = Thread::Current();
Ian Rogersdbf3be02014-08-29 15:40:08 -07002136 StackHandleScope<1> hs(self);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002137 auto classes = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Ian Rogersdbf3be02014-08-29 15:40:08 -07002138 // We size the array assuming classes won't be added to the class table during the visit.
2139 // If this assumption fails we iterate again.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002140 while (true) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002141 size_t class_table_size;
2142 {
Ian Rogers7b078e82014-09-10 14:44:24 -07002143 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002144 // Add 100 in case new classes get loaded when we are filling in the object array.
2145 class_table_size = NumZygoteClasses() + NumNonZygoteClasses() + 100;
Ian Rogersdbf3be02014-08-29 15:40:08 -07002146 }
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07002147 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002148 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
Ian Rogersdbf3be02014-08-29 15:40:08 -07002149 classes.Assign(
2150 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size));
Andreas Gampefa4333d2017-02-14 11:10:34 -08002151 CHECK(classes != nullptr); // OOME.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002152 GetClassInToObjectArray accumulator(classes.Get());
2153 VisitClasses(&accumulator);
2154 if (accumulator.Succeeded()) {
2155 break;
2156 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002157 }
2158 for (int32_t i = 0; i < classes->GetLength(); ++i) {
2159 // If the class table shrank during creation of the clases array we expect null elements. If
2160 // the class table grew then the loop repeats. If classes are created after the loop has
2161 // finished then we don't visit.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002162 ObjPtr<mirror::Class> klass = classes->Get(i);
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002163 if (klass != nullptr && !visitor->operator()(klass)) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002164 return;
2165 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002166 }
2167 }
2168}
2169
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002170ClassLinker::~ClassLinker() {
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002171 mirror::Class::ResetClass();
2172 mirror::Constructor::ResetClass();
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07002173 mirror::Field::ResetClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002174 mirror::Method::ResetClass();
2175 mirror::Reference::ResetClass();
2176 mirror::StackTraceElement::ResetClass();
2177 mirror::String::ResetClass();
2178 mirror::Throwable::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002179 mirror::BooleanArray::ResetArrayClass();
2180 mirror::ByteArray::ResetArrayClass();
2181 mirror::CharArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002182 mirror::Constructor::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002183 mirror::DoubleArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002184 mirror::Field::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002185 mirror::FloatArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002186 mirror::Method::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002187 mirror::IntArray::ResetArrayClass();
2188 mirror::LongArray::ResetArrayClass();
2189 mirror::ShortArray::ResetArrayClass();
Narayan Kamathafa48272016-08-03 12:46:58 +01002190 mirror::MethodType::ResetClass();
2191 mirror::MethodHandleImpl::ResetClass();
Orion Hodsonc069a302017-01-18 09:23:12 +00002192 mirror::MethodHandlesLookup::ResetClass();
2193 mirror::CallSite::ResetClass();
Narayan Kamath000e1882016-10-24 17:14:25 +01002194 mirror::EmulatedStackFrame::ResetClass();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002195 Thread* const self = Thread::Current();
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002196 for (const ClassLoaderData& data : class_loaders_) {
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002197 DeleteClassLoader(self, data);
Mathieu Chartier6b069532015-08-05 15:08:12 -07002198 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002199 class_loaders_.clear();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002200}
2201
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002202void ClassLinker::DeleteClassLoader(Thread* self, const ClassLoaderData& data) {
2203 Runtime* const runtime = Runtime::Current();
2204 JavaVMExt* const vm = runtime->GetJavaVM();
2205 vm->DeleteWeakGlobalRef(self, data.weak_root);
Calin Juravlee5de54c2016-04-20 14:22:09 +01002206 // Notify the JIT that we need to remove the methods and/or profiling info.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002207 if (runtime->GetJit() != nullptr) {
2208 jit::JitCodeCache* code_cache = runtime->GetJit()->GetCodeCache();
2209 if (code_cache != nullptr) {
2210 code_cache->RemoveMethodsIn(self, *data.allocator);
2211 }
2212 }
2213 delete data.allocator;
2214 delete data.class_table;
2215}
2216
Mathieu Chartiere401d142015-04-22 13:56:20 -07002217mirror::PointerArray* ClassLinker::AllocPointerArray(Thread* self, size_t length) {
Andreas Gampe542451c2016-07-26 09:02:02 -07002218 return down_cast<mirror::PointerArray*>(
2219 image_pointer_size_ == PointerSize::k64
2220 ? static_cast<mirror::Array*>(mirror::LongArray::Alloc(self, length))
2221 : static_cast<mirror::Array*>(mirror::IntArray::Alloc(self, length)));
Mathieu Chartiere401d142015-04-22 13:56:20 -07002222}
2223
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002224mirror::DexCache* ClassLinker::AllocDexCache(ObjPtr<mirror::String>* out_location,
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002225 Thread* self,
2226 const DexFile& dex_file) {
2227 StackHandleScope<1> hs(self);
2228 DCHECK(out_location != nullptr);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07002229 auto dex_cache(hs.NewHandle(ObjPtr<mirror::DexCache>::DownCast(
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002230 GetClassRoot(kJavaLangDexCache)->AllocObject(self))));
Andreas Gampefa4333d2017-02-14 11:10:34 -08002231 if (dex_cache == nullptr) {
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002232 self->AssertPendingOOMException();
2233 return nullptr;
2234 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002235 ObjPtr<mirror::String> location = intern_table_->InternStrong(dex_file.GetLocation().c_str());
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002236 if (location == nullptr) {
2237 self->AssertPendingOOMException();
2238 return nullptr;
2239 }
2240 *out_location = location;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002241 return dex_cache.Get();
Brian Carlstroma0808032011-07-18 00:39:23 -07002242}
2243
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002244mirror::DexCache* ClassLinker::AllocAndInitializeDexCache(Thread* self,
2245 const DexFile& dex_file,
2246 LinearAlloc* linear_alloc) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002247 ObjPtr<mirror::String> location = nullptr;
2248 ObjPtr<mirror::DexCache> dex_cache = AllocDexCache(&location, self, dex_file);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002249 if (dex_cache != nullptr) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08002250 WriterMutexLock mu(self, *Locks::dex_lock_);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002251 DCHECK(location != nullptr);
Andreas Gampecc1b5352016-12-01 16:58:38 -08002252 mirror::DexCache::InitializeDexCache(self,
2253 dex_cache,
2254 location,
2255 &dex_file,
2256 linear_alloc,
2257 image_pointer_size_);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002258 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002259 return dex_cache.Ptr();
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002260}
2261
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002262mirror::Class* ClassLinker::AllocClass(Thread* self,
2263 ObjPtr<mirror::Class> java_lang_Class,
Ian Rogers6fac4472014-02-25 17:01:10 -08002264 uint32_t class_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002265 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07002266 gc::Heap* heap = Runtime::Current()->GetHeap();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002267 mirror::Class::InitializeClassVisitor visitor(class_size);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002268 ObjPtr<mirror::Object> k = kMovingClasses ?
Brian Carlstromf3632832014-05-20 15:36:53 -07002269 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) :
2270 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
Ian Rogers6fac4472014-02-25 17:01:10 -08002271 if (UNLIKELY(k == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002272 self->AssertPendingOOMException();
Ian Rogers6fac4472014-02-25 17:01:10 -08002273 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002274 }
Ian Rogers6fac4472014-02-25 17:01:10 -08002275 return k->AsClass();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07002276}
2277
Ian Rogers6fac4472014-02-25 17:01:10 -08002278mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07002279 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07002280}
2281
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002282mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002283 Thread* self,
2284 size_t length) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002285 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
2286 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07002287}
2288
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002289mirror::Class* ClassLinker::EnsureResolved(Thread* self,
2290 const char* descriptor,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002291 ObjPtr<mirror::Class> klass) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002292 DCHECK(klass != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002293 if (kIsDebugBuild) {
2294 StackHandleScope<1> hs(self);
2295 HandleWrapperObjPtr<mirror::Class> h = hs.NewHandleWrapper(&klass);
2296 Thread::PoisonObjectPointersIfDebug();
2297 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002298
2299 // For temporary classes we must wait for them to be retired.
2300 if (init_done_ && klass->IsTemp()) {
2301 CHECK(!klass->IsResolved());
Vladimir Marko72ab6842017-01-20 19:32:50 +00002302 if (klass->IsErroneousUnresolved()) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002303 ThrowEarlierClassFailure(klass);
2304 return nullptr;
2305 }
2306 StackHandleScope<1> hs(self);
2307 Handle<mirror::Class> h_class(hs.NewHandle(klass));
2308 ObjectLock<mirror::Class> lock(self, h_class);
2309 // Loop and wait for the resolving thread to retire this class.
Vladimir Marko72ab6842017-01-20 19:32:50 +00002310 while (!h_class->IsRetired() && !h_class->IsErroneousUnresolved()) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002311 lock.WaitIgnoringInterrupts();
2312 }
Vladimir Marko72ab6842017-01-20 19:32:50 +00002313 if (h_class->IsErroneousUnresolved()) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002314 ThrowEarlierClassFailure(h_class.Get());
2315 return nullptr;
2316 }
2317 CHECK(h_class->IsRetired());
2318 // Get the updated class from class table.
Andreas Gampe34ee6842014-12-02 15:43:52 -08002319 klass = LookupClass(self, descriptor, h_class.Get()->GetClassLoader());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002320 }
2321
Brian Carlstromaded5f72011-10-07 17:15:04 -07002322 // Wait for the class if it has not already been linked.
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002323 size_t index = 0;
2324 // Maximum number of yield iterations until we start sleeping.
2325 static const size_t kNumYieldIterations = 1000;
2326 // How long each sleep is in us.
2327 static const size_t kSleepDurationUS = 1000; // 1 ms.
Vladimir Marko72ab6842017-01-20 19:32:50 +00002328 while (!klass->IsResolved() && !klass->IsErroneousUnresolved()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002329 StackHandleScope<1> hs(self);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002330 HandleWrapperObjPtr<mirror::Class> h_class(hs.NewHandleWrapper(&klass));
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002331 {
2332 ObjectTryLock<mirror::Class> lock(self, h_class);
2333 // Can not use a monitor wait here since it may block when returning and deadlock if another
2334 // thread has locked klass.
2335 if (lock.Acquired()) {
2336 // Check for circular dependencies between classes, the lock is required for SetStatus.
2337 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) {
2338 ThrowClassCircularityError(h_class.Get());
Vladimir Marko72ab6842017-01-20 19:32:50 +00002339 mirror::Class::SetStatus(h_class, mirror::Class::kStatusErrorUnresolved, self);
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002340 return nullptr;
2341 }
2342 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002343 }
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002344 {
2345 // Handle wrapper deals with klass moving.
2346 ScopedThreadSuspension sts(self, kSuspended);
2347 if (index < kNumYieldIterations) {
2348 sched_yield();
2349 } else {
2350 usleep(kSleepDurationUS);
2351 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002352 }
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002353 ++index;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002354 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002355
Vladimir Marko72ab6842017-01-20 19:32:50 +00002356 if (klass->IsErroneousUnresolved()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002357 ThrowEarlierClassFailure(klass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002358 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002359 }
2360 // Return the loaded class. No exceptions should be pending.
David Sehr709b0702016-10-13 09:12:37 -07002361 CHECK(klass->IsResolved()) << klass->PrettyClass();
Ian Rogers62d6c772013-02-27 08:32:07 -08002362 self->AssertNoPendingException();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002363 return klass.Ptr();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002364}
2365
Ian Rogers68b56852014-08-29 20:19:11 -07002366typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry;
2367
2368// Search a collection of DexFiles for a descriptor
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002369ClassPathEntry FindInClassPath(const char* descriptor,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002370 size_t hash, const std::vector<const DexFile*>& class_path) {
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002371 for (const DexFile* dex_file : class_path) {
David Sehr9aa352e2016-09-15 18:13:52 -07002372 const DexFile::ClassDef* dex_class_def = OatDexFile::FindClassDef(*dex_file, descriptor, hash);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002373 if (dex_class_def != nullptr) {
Ian Rogers68b56852014-08-29 20:19:11 -07002374 return ClassPathEntry(dex_file, dex_class_def);
2375 }
2376 }
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002377 return ClassPathEntry(nullptr, nullptr);
Ian Rogers68b56852014-08-29 20:19:11 -07002378}
2379
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002380bool ClassLinker::FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
2381 Thread* self,
2382 const char* descriptor,
2383 size_t hash,
2384 Handle<mirror::ClassLoader> class_loader,
2385 ObjPtr<mirror::Class>* result) {
Andreas Gampef865ea92015-04-13 22:14:19 -07002386 // Termination case: boot class-loader.
2387 if (IsBootClassLoader(soa, class_loader.Get())) {
2388 // The boot class loader, search the boot class path.
2389 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_);
2390 if (pair.second != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002391 ObjPtr<mirror::Class> klass = LookupClass(self, descriptor, hash, nullptr);
Andreas Gampef865ea92015-04-13 22:14:19 -07002392 if (klass != nullptr) {
2393 *result = EnsureResolved(self, descriptor, klass);
2394 } else {
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002395 *result = DefineClass(self,
2396 descriptor,
2397 hash,
2398 ScopedNullHandle<mirror::ClassLoader>(),
2399 *pair.first,
2400 *pair.second);
Andreas Gampef865ea92015-04-13 22:14:19 -07002401 }
2402 if (*result == nullptr) {
2403 CHECK(self->IsExceptionPending()) << descriptor;
2404 self->ClearException();
2405 }
Ian Rogers32427292014-11-19 14:05:21 -08002406 } else {
Andreas Gampef865ea92015-04-13 22:14:19 -07002407 *result = nullptr;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002408 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002409 return true;
2410 }
2411
2412 // Unsupported class-loader?
Mathieu Chartier0795f232016-09-27 18:43:30 -07002413 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader) !=
2414 class_loader->GetClass()) {
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002415 // PathClassLoader is the most common case, so it's the one we check first. For secondary dex
2416 // files, we also check DexClassLoader here.
2417 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DexClassLoader) !=
2418 class_loader->GetClass()) {
2419 *result = nullptr;
2420 return false;
2421 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002422 }
2423
2424 // Handles as RegisterDexFile may allocate dex caches (and cause thread suspension).
2425 StackHandleScope<4> hs(self);
2426 Handle<mirror::ClassLoader> h_parent(hs.NewHandle(class_loader->GetParent()));
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002427 bool recursive_result = FindClassInBaseDexClassLoader(soa,
2428 self,
2429 descriptor,
2430 hash,
2431 h_parent,
2432 result);
Andreas Gampef865ea92015-04-13 22:14:19 -07002433
2434 if (!recursive_result) {
2435 // Something wrong up the chain.
2436 return false;
2437 }
2438
2439 if (*result != nullptr) {
2440 // Found the class up the chain.
2441 return true;
2442 }
2443
2444 // Handle this step.
2445 // Handle as if this is the child PathClassLoader.
2446 // The class loader is a PathClassLoader which inherits from BaseDexClassLoader.
2447 // We need to get the DexPathList and loop through it.
Andreas Gampe08883de2016-11-08 13:20:52 -08002448 ArtField* const cookie_field =
2449 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
Andreas Gampef865ea92015-04-13 22:14:19 -07002450 ArtField* const dex_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08002451 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002452 ObjPtr<mirror::Object> dex_path_list =
Andreas Gampe08883de2016-11-08 13:20:52 -08002453 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList)->
2454 GetObject(class_loader.Get());
Andreas Gampef865ea92015-04-13 22:14:19 -07002455 if (dex_path_list != nullptr && dex_file_field != nullptr && cookie_field != nullptr) {
2456 // DexPathList has an array dexElements of Elements[] which each contain a dex file.
Mathieu Chartier3398c782016-09-30 10:27:43 -07002457 ObjPtr<mirror::Object> dex_elements_obj =
Andreas Gampe08883de2016-11-08 13:20:52 -08002458 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements)->
Andreas Gampef865ea92015-04-13 22:14:19 -07002459 GetObject(dex_path_list);
2460 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
2461 // at the mCookie which is a DexFile vector.
2462 if (dex_elements_obj != nullptr) {
2463 Handle<mirror::ObjectArray<mirror::Object>> dex_elements =
2464 hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>());
2465 for (int32_t i = 0; i < dex_elements->GetLength(); ++i) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07002466 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
Andreas Gampef865ea92015-04-13 22:14:19 -07002467 if (element == nullptr) {
2468 // Should never happen, fall back to java code to throw a NPE.
2469 break;
2470 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07002471 ObjPtr<mirror::Object> dex_file = dex_file_field->GetObject(element);
Andreas Gampef865ea92015-04-13 22:14:19 -07002472 if (dex_file != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07002473 ObjPtr<mirror::LongArray> long_array = cookie_field->GetObject(dex_file)->AsLongArray();
Andreas Gampef865ea92015-04-13 22:14:19 -07002474 if (long_array == nullptr) {
2475 // This should never happen so log a warning.
2476 LOG(WARNING) << "Null DexFile::mCookie for " << descriptor;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002477 break;
2478 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002479 int32_t long_array_size = long_array->GetLength();
Mathieu Chartiere58991b2015-10-13 07:59:34 -07002480 // First element is the oat file.
2481 for (int32_t j = kDexFileIndexStart; j < long_array_size; ++j) {
Andreas Gampef865ea92015-04-13 22:14:19 -07002482 const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(
2483 long_array->GetWithoutChecks(j)));
David Sehr9aa352e2016-09-15 18:13:52 -07002484 const DexFile::ClassDef* dex_class_def =
2485 OatDexFile::FindClassDef(*cp_dex_file, descriptor, hash);
Andreas Gampef865ea92015-04-13 22:14:19 -07002486 if (dex_class_def != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002487 ObjPtr<mirror::Class> klass = DefineClass(self,
Mathieu Chartiere58991b2015-10-13 07:59:34 -07002488 descriptor,
2489 hash,
2490 class_loader,
2491 *cp_dex_file,
2492 *dex_class_def);
Andreas Gampef865ea92015-04-13 22:14:19 -07002493 if (klass == nullptr) {
2494 CHECK(self->IsExceptionPending()) << descriptor;
2495 self->ClearException();
2496 // TODO: Is it really right to break here, and not check the other dex files?
2497 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002498 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002499 *result = klass;
2500 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002501 }
2502 }
2503 }
2504 }
2505 }
Ian Rogers32427292014-11-19 14:05:21 -08002506 self->AssertNoPendingException();
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002507 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002508
2509 // Result is still null from the parent call, no need to set it again...
2510 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002511}
2512
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002513mirror::Class* ClassLinker::FindClass(Thread* self,
2514 const char* descriptor,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07002515 Handle<mirror::ClassLoader> class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08002516 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Ian Rogers98379392014-02-24 16:53:16 -08002517 DCHECK(self != nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002518 self->AssertNoPendingException();
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07002519 self->PoisonObjectPointers(); // For DefineClass, CreateArrayClass, etc...
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002520 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002521 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
2522 // for primitive classes that aren't backed by dex files.
2523 return FindPrimitiveClass(descriptor[0]);
2524 }
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002525 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002526 // Find the class in the loaded classes table.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002527 ObjPtr<mirror::Class> klass = LookupClass(self, descriptor, hash, class_loader.Get());
Ian Rogers68b56852014-08-29 20:19:11 -07002528 if (klass != nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002529 return EnsureResolved(self, descriptor, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002530 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002531 // Class is not yet loaded.
Andreas Gampefa4333d2017-02-14 11:10:34 -08002532 if (descriptor[0] != '[' && class_loader == nullptr) {
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002533 // Non-array class and the boot class loader, search the boot class path.
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002534 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_);
Ian Rogers68b56852014-08-29 20:19:11 -07002535 if (pair.second != nullptr) {
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002536 return DefineClass(self,
2537 descriptor,
2538 hash,
2539 ScopedNullHandle<mirror::ClassLoader>(),
2540 *pair.first,
Ian Rogers7b078e82014-09-10 14:44:24 -07002541 *pair.second);
Ian Rogers63557452014-06-04 16:57:15 -07002542 } else {
2543 // The boot class loader is searched ahead of the application class loader, failures are
2544 // expected and will be wrapped in a ClassNotFoundException. Use the pre-allocated error to
2545 // trigger the chaining with a proper stack trace.
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002546 ObjPtr<mirror::Throwable> pre_allocated =
2547 Runtime::Current()->GetPreAllocatedNoClassDefFoundError();
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002548 self->SetException(pre_allocated);
Ian Rogers63557452014-06-04 16:57:15 -07002549 return nullptr;
Jesse Wilson47daf872011-11-23 11:42:45 -05002550 }
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002551 }
2552 ObjPtr<mirror::Class> result_ptr;
2553 bool descriptor_equals;
2554 if (descriptor[0] == '[') {
2555 result_ptr = CreateArrayClass(self, descriptor, hash, class_loader);
2556 DCHECK_EQ(result_ptr == nullptr, self->IsExceptionPending());
2557 DCHECK(result_ptr == nullptr || result_ptr->DescriptorEquals(descriptor));
2558 descriptor_equals = true;
Jesse Wilson47daf872011-11-23 11:42:45 -05002559 } else {
Ian Rogers98379392014-02-24 16:53:16 -08002560 ScopedObjectAccessUnchecked soa(self);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002561 bool known_hierarchy =
2562 FindClassInBaseDexClassLoader(soa, self, descriptor, hash, class_loader, &result_ptr);
2563 if (result_ptr != nullptr) {
2564 // The chain was understood and we found the class. We still need to add the class to
2565 // the class table to protect from racy programs that can try and redefine the path list
2566 // which would change the Class<?> returned for subsequent evaluation of const-class.
2567 DCHECK(known_hierarchy);
2568 DCHECK(result_ptr->DescriptorEquals(descriptor));
2569 descriptor_equals = true;
2570 } else {
2571 // Either the chain wasn't understood or the class wasn't found.
2572 //
2573 // If the chain was understood but we did not find the class, let the Java-side
2574 // rediscover all this and throw the exception with the right stack trace. Note that
2575 // the Java-side could still succeed for racy programs if another thread is actively
2576 // modifying the class loader's path list.
Andreas Gampef865ea92015-04-13 22:14:19 -07002577
Calin Juravleccd56952016-12-15 17:57:38 +00002578 if (!self->CanCallIntoJava()) {
2579 // Oops, we can't call into java so we can't run actual class-loader code.
2580 // This is true for e.g. for the compiler (jit or aot).
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002581 ObjPtr<mirror::Throwable> pre_allocated =
2582 Runtime::Current()->GetPreAllocatedNoClassDefFoundError();
2583 self->SetException(pre_allocated);
Vladimir Marko2c8c6b62016-12-01 17:42:00 +00002584 return nullptr;
2585 }
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002586
2587 ScopedLocalRef<jobject> class_loader_object(
2588 soa.Env(), soa.AddLocalReference<jobject>(class_loader.Get()));
2589 std::string class_name_string(DescriptorToDot(descriptor));
2590 ScopedLocalRef<jobject> result(soa.Env(), nullptr);
2591 {
2592 ScopedThreadStateChange tsc(self, kNative);
2593 ScopedLocalRef<jobject> class_name_object(
2594 soa.Env(), soa.Env()->NewStringUTF(class_name_string.c_str()));
2595 if (class_name_object.get() == nullptr) {
2596 DCHECK(self->IsExceptionPending()); // OOME.
2597 return nullptr;
2598 }
2599 CHECK(class_loader_object.get() != nullptr);
2600 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
2601 WellKnownClasses::java_lang_ClassLoader_loadClass,
2602 class_name_object.get()));
2603 }
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002604 if (result.get() == nullptr && !self->IsExceptionPending()) {
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002605 // broken loader - throw NPE to be compatible with Dalvik
2606 ThrowNullPointerException(StringPrintf("ClassLoader.loadClass returned null for %s",
2607 class_name_string.c_str()).c_str());
2608 return nullptr;
2609 }
2610 result_ptr = soa.Decode<mirror::Class>(result.get());
2611 // Check the name of the returned class.
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002612 descriptor_equals = (result_ptr != nullptr) && result_ptr->DescriptorEquals(descriptor);
Vladimir Marko2c8c6b62016-12-01 17:42:00 +00002613 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002614 }
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002615
2616 if (self->IsExceptionPending()) {
2617 // If the ClassLoader threw or array class allocation failed, pass that exception up.
2618 // However, to comply with the RI behavior, first check if another thread succeeded.
2619 result_ptr = LookupClass(self, descriptor, hash, class_loader.Get());
2620 if (result_ptr != nullptr && !result_ptr->IsErroneous()) {
2621 self->ClearException();
2622 return EnsureResolved(self, descriptor, result_ptr);
2623 }
2624 return nullptr;
2625 }
2626
2627 // Try to insert the class to the class table, checking for mismatch.
2628 ObjPtr<mirror::Class> old;
2629 {
2630 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2631 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader.Get());
2632 old = class_table->Lookup(descriptor, hash);
2633 if (old == nullptr) {
2634 old = result_ptr; // For the comparison below, after releasing the lock.
2635 if (descriptor_equals) {
2636 class_table->InsertWithHash(result_ptr.Ptr(), hash);
2637 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get());
2638 } // else throw below, after releasing the lock.
2639 }
2640 }
2641 if (UNLIKELY(old != result_ptr)) {
2642 // Return `old` (even if `!descriptor_equals`) to mimic the RI behavior for parallel
2643 // capable class loaders. (All class loaders are considered parallel capable on Android.)
2644 mirror::Class* loader_class = class_loader->GetClass();
2645 const char* loader_class_name =
2646 loader_class->GetDexFile().StringByTypeIdx(loader_class->GetDexTypeIndex());
2647 LOG(WARNING) << "Initiating class loader of type " << DescriptorToDot(loader_class_name)
2648 << " is not well-behaved; it returned a different Class for racing loadClass(\""
2649 << DescriptorToDot(descriptor) << "\").";
2650 return EnsureResolved(self, descriptor, old);
2651 }
2652 if (UNLIKELY(!descriptor_equals)) {
2653 std::string result_storage;
2654 const char* result_name = result_ptr->GetDescriptor(&result_storage);
2655 std::string loader_storage;
2656 const char* loader_class_name = class_loader->GetClass()->GetDescriptor(&loader_storage);
2657 ThrowNoClassDefFoundError(
2658 "Initiating class loader of type %s returned class %s instead of %s.",
2659 DescriptorToDot(loader_class_name).c_str(),
2660 DescriptorToDot(result_name).c_str(),
2661 DescriptorToDot(descriptor).c_str());
2662 return nullptr;
2663 }
2664 // success, return mirror::Class*
2665 return result_ptr.Ptr();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002666}
2667
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002668mirror::Class* ClassLinker::DefineClass(Thread* self,
2669 const char* descriptor,
2670 size_t hash,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07002671 Handle<mirror::ClassLoader> class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002672 const DexFile& dex_file,
2673 const DexFile::ClassDef& dex_class_def) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002674 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002675 auto klass = hs.NewHandle<mirror::Class>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002676
Brian Carlstromaded5f72011-10-07 17:15:04 -07002677 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002678 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002679 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002680 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002681 klass.Assign(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002682 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002683 klass.Assign(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002684 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002685 klass.Assign(GetClassRoot(kJavaLangString));
Fred Shih4ee7a662014-07-11 09:59:27 -07002686 } else if (strcmp(descriptor, "Ljava/lang/ref/Reference;") == 0) {
2687 klass.Assign(GetClassRoot(kJavaLangRefReference));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002688 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002689 klass.Assign(GetClassRoot(kJavaLangDexCache));
Alex Lightd6251582016-10-31 11:12:30 -07002690 } else if (strcmp(descriptor, "Ldalvik/system/ClassExt;") == 0) {
2691 klass.Assign(GetClassRoot(kDalvikSystemClassExt));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002692 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002693 }
2694
Andreas Gampefa4333d2017-02-14 11:10:34 -08002695 if (klass == nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002696 // Allocate a class with the status of not ready.
2697 // Interface object should get the right size here. Regular class will
2698 // figure out the right size later and be replaced with one of the right
2699 // size when the class becomes resolved.
2700 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002701 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08002702 if (UNLIKELY(klass == nullptr)) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002703 self->AssertPendingOOMException();
Ian Rogersc114b5f2014-07-21 08:55:01 -07002704 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002705 }
Alex Lightb0f11922017-01-23 14:25:17 -08002706 // Get the real dex file. This will return the input if there aren't any callbacks or they do
2707 // nothing.
2708 DexFile const* new_dex_file = nullptr;
2709 DexFile::ClassDef const* new_class_def = nullptr;
2710 // TODO We should ideally figure out some way to move this after we get a lock on the klass so it
2711 // will only be called once.
2712 Runtime::Current()->GetRuntimeCallbacks()->ClassPreDefine(descriptor,
2713 klass,
2714 class_loader,
2715 dex_file,
2716 dex_class_def,
2717 &new_dex_file,
2718 &new_class_def);
Alex Light440b5d92017-01-24 15:32:25 -08002719 // Check to see if an exception happened during runtime callbacks. Return if so.
2720 if (self->IsExceptionPending()) {
2721 return nullptr;
2722 }
Alex Lightb0f11922017-01-23 14:25:17 -08002723 ObjPtr<mirror::DexCache> dex_cache = RegisterDexFile(*new_dex_file, class_loader.Get());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002724 if (dex_cache == nullptr) {
Vladimir Markocd556b02017-02-03 11:47:34 +00002725 self->AssertPendingException();
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002726 return nullptr;
2727 }
2728 klass->SetDexCache(dex_cache);
Alex Lightb0f11922017-01-23 14:25:17 -08002729 SetupClass(*new_dex_file, *new_class_def, klass, class_loader.Get());
Mathieu Chartierc7853442015-03-27 14:35:38 -07002730
Jeff Hao848f70a2014-01-15 13:49:50 -08002731 // Mark the string class by setting its access flag.
2732 if (UNLIKELY(!init_done_)) {
2733 if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
2734 klass->SetStringClass();
2735 }
2736 }
2737
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07002738 ObjectLock<mirror::Class> lock(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002739 klass->SetClinitThreadId(self->GetTid());
Mathieu Chartier1e4841e2016-12-15 14:21:04 -08002740 // Make sure we have a valid empty iftable even if there are errors.
2741 klass->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002742
Mathieu Chartier590fee92013-09-13 13:46:47 -07002743 // Add the newly loaded class to the loaded classes table.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002744 ObjPtr<mirror::Class> existing = InsertClass(descriptor, klass.Get(), hash);
Ian Rogersc114b5f2014-07-21 08:55:01 -07002745 if (existing != nullptr) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002746 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
2747 // this thread to block.
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002748 return EnsureResolved(self, descriptor, existing);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002749 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002750
Mathieu Chartierc7853442015-03-27 14:35:38 -07002751 // Load the fields and other things after we are inserted in the table. This is so that we don't
2752 // end up allocating unfree-able linear alloc resources and then lose the race condition. The
2753 // other reason is that the field roots are only visited from the class table. So we need to be
2754 // inserted before we allocate / fill in these fields.
Alex Lightb0f11922017-01-23 14:25:17 -08002755 LoadClass(self, *new_dex_file, *new_class_def, klass);
Mathieu Chartierc7853442015-03-27 14:35:38 -07002756 if (self->IsExceptionPending()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002757 VLOG(class_linker) << self->GetException()->Dump();
Mathieu Chartierc7853442015-03-27 14:35:38 -07002758 // An exception occured during load, set status to erroneous while holding klass' lock in case
2759 // notification is necessary.
2760 if (!klass->IsErroneous()) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00002761 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Mathieu Chartierc7853442015-03-27 14:35:38 -07002762 }
2763 return nullptr;
2764 }
2765
Brian Carlstromaded5f72011-10-07 17:15:04 -07002766 // Finish loading (if necessary) by finding parents
2767 CHECK(!klass->IsLoaded());
Alex Lightb0f11922017-01-23 14:25:17 -08002768 if (!LoadSuperAndInterfaces(klass, *new_dex_file)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002769 // Loading failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002770 if (!klass->IsErroneous()) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00002771 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002772 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002773 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002774 }
2775 CHECK(klass->IsLoaded());
Andreas Gampe0f01b582017-01-18 15:22:37 -08002776
2777 // At this point the class is loaded. Publish a ClassLoad even.
2778 // Note: this may be a temporary class. It is a listener's responsibility to handle this.
Andreas Gampeac30fa22017-01-18 21:02:36 -08002779 Runtime::Current()->GetRuntimeCallbacks()->ClassLoad(klass);
Andreas Gampe0f01b582017-01-18 15:22:37 -08002780
Brian Carlstromaded5f72011-10-07 17:15:04 -07002781 // Link the class (if necessary)
2782 CHECK(!klass->IsResolved());
Mathieu Chartier590fee92013-09-13 13:46:47 -07002783 // TODO: Use fast jobjects?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002784 auto interfaces = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002785
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002786 MutableHandle<mirror::Class> h_new_class = hs.NewHandle<mirror::Class>(nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002787 if (!LinkClass(self, descriptor, klass, interfaces, &h_new_class)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002788 // Linking failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002789 if (!klass->IsErroneous()) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00002790 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002791 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002792 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002793 }
Mathieu Chartier524507a2014-08-27 15:28:28 -07002794 self->AssertNoPendingException();
Andreas Gampefa4333d2017-02-14 11:10:34 -08002795 CHECK(h_new_class != nullptr) << descriptor;
Vladimir Marko72ab6842017-01-20 19:32:50 +00002796 CHECK(h_new_class->IsResolved() && !h_new_class->IsErroneousResolved()) << descriptor;
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002797
Sebastien Hertza8a697f2015-01-15 12:28:47 +01002798 // Instrumentation may have updated entrypoints for all methods of all
2799 // classes. However it could not update methods of this class while we
2800 // were loading it. Now the class is resolved, we can update entrypoints
2801 // as required by instrumentation.
2802 if (Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
2803 // We must be in the kRunnable state to prevent instrumentation from
2804 // suspending all threads to update entrypoints while we are doing it
2805 // for this class.
2806 DCHECK_EQ(self->GetState(), kRunnable);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002807 Runtime::Current()->GetInstrumentation()->InstallStubsForClass(h_new_class.Get());
Sebastien Hertza8a697f2015-01-15 12:28:47 +01002808 }
2809
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002810 /*
2811 * We send CLASS_PREPARE events to the debugger from here. The
2812 * definition of "preparation" is creating the static fields for a
2813 * class and initializing them to the standard default values, but not
2814 * executing any code (that comes later, during "initialization").
2815 *
2816 * We did the static preparation in LinkClass.
2817 *
2818 * The class has been prepared and resolved but possibly not yet verified
2819 * at this point.
2820 */
Andreas Gampeac30fa22017-01-18 21:02:36 -08002821 Runtime::Current()->GetRuntimeCallbacks()->ClassPrepare(klass, h_new_class);
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002822
Tamas Berghammer160e6df2016-01-05 14:29:02 +00002823 // Notify native debugger of the new class and its layout.
2824 jit::Jit::NewTypeLoadedIfUsingJit(h_new_class.Get());
2825
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002826 return h_new_class.Get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002827}
2828
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002829uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
2830 const DexFile::ClassDef& dex_class_def) {
Ian Rogers13735952014-10-08 12:43:28 -07002831 const uint8_t* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002832 size_t num_ref = 0;
Fred Shih37f05ef2014-07-16 18:38:08 -07002833 size_t num_8 = 0;
2834 size_t num_16 = 0;
Brian Carlstrom4873d462011-08-21 15:23:39 -07002835 size_t num_32 = 0;
2836 size_t num_64 = 0;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002837 if (class_data != nullptr) {
Vladimir Marko879d27b2016-03-15 20:31:50 +00002838 // We allow duplicate definitions of the same field in a class_data_item
2839 // but ignore the repeated indexes here, b/21868015.
2840 uint32_t last_field_idx = DexFile::kDexNoIndex;
Ian Rogers0571d352011-11-03 19:51:38 -07002841 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
Vladimir Marko879d27b2016-03-15 20:31:50 +00002842 uint32_t field_idx = it.GetMemberIndex();
2843 // Ordering enforced by DexFileVerifier.
2844 DCHECK(last_field_idx == DexFile::kDexNoIndex || last_field_idx <= field_idx);
2845 if (UNLIKELY(field_idx == last_field_idx)) {
2846 continue;
2847 }
2848 last_field_idx = field_idx;
2849 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002850 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002851 char c = descriptor[0];
Fred Shih37f05ef2014-07-16 18:38:08 -07002852 switch (c) {
2853 case 'L':
2854 case '[':
2855 num_ref++;
2856 break;
2857 case 'J':
2858 case 'D':
2859 num_64++;
2860 break;
2861 case 'I':
2862 case 'F':
2863 num_32++;
2864 break;
2865 case 'S':
2866 case 'C':
2867 num_16++;
2868 break;
2869 case 'B':
2870 case 'Z':
2871 num_8++;
2872 break;
2873 default:
2874 LOG(FATAL) << "Unknown descriptor: " << c;
Ian Rogerse0a02da2014-12-02 14:10:53 -08002875 UNREACHABLE();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002876 }
2877 }
2878 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002879 return mirror::Class::ComputeClassSize(false,
2880 0,
2881 num_8,
2882 num_16,
2883 num_32,
2884 num_64,
2885 num_ref,
Mathieu Chartiere401d142015-04-22 13:56:20 -07002886 image_pointer_size_);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002887}
2888
TDYa12785321912012-04-01 15:24:56 -07002889// Special case to get oat code without overwriting a trampoline.
Mathieu Chartiere401d142015-04-22 13:56:20 -07002890const void* ClassLinker::GetQuickOatCodeFor(ArtMethod* method) {
David Sehr709b0702016-10-13 09:12:37 -07002891 CHECK(method->IsInvokable()) << method->PrettyMethod();
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00002892 if (method->IsProxyMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002893 return GetQuickProxyInvokeHandler();
Jeff Hao8df6cea2013-07-29 13:54:48 -07002894 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002895 auto* code = method->GetOatMethodQuickCode(GetImagePointerSize());
2896 if (code != nullptr) {
2897 return code;
Mathieu Chartier2535abe2015-02-17 10:38:49 -08002898 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002899 if (method->IsNative()) {
2900 // No code and native? Use generic trampoline.
2901 return GetQuickGenericJniStub();
2902 }
2903 return GetQuickToInterpreterBridge();
TDYa12785321912012-04-01 15:24:56 -07002904}
2905
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002906bool ClassLinker::ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) {
2907 if (UNLIKELY(method->IsNative() || method->IsProxyMethod())) {
2908 return false;
2909 }
2910
Elliott Hughes956af0f2014-12-11 14:34:28 -08002911 if (quick_code == nullptr) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002912 return true;
2913 }
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002914
2915 Runtime* runtime = Runtime::Current();
2916 instrumentation::Instrumentation* instr = runtime->GetInstrumentation();
2917 if (instr->InterpretOnly()) {
2918 return true;
2919 }
2920
2921 if (runtime->GetClassLinker()->IsQuickToInterpreterBridge(quick_code)) {
2922 // Doing this check avoids doing compiled/interpreter transitions.
2923 return true;
2924 }
2925
2926 if (Dbg::IsForcedInterpreterNeededForCalling(Thread::Current(), method)) {
2927 // Force the use of interpreter when it is required by the debugger.
2928 return true;
2929 }
2930
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002931 if (runtime->IsJavaDebuggable()) {
2932 // For simplicity, we ignore precompiled code and go to the interpreter
2933 // assuming we don't already have jitted code.
2934 // We could look at the oat file where `quick_code` is being defined,
2935 // and check whether it's been compiled debuggable, but we decided to
2936 // only rely on the JIT for debuggable apps.
Alex Light6b16d892016-11-11 11:21:04 -08002937 jit::Jit* jit = Runtime::Current()->GetJit();
2938 return (jit == nullptr) || !jit->GetCodeCache()->ContainsPc(quick_code);
2939 }
2940
David Srbeckyf4480162016-03-16 00:06:24 +00002941 if (runtime->IsNativeDebuggable()) {
Calin Juravlee5de54c2016-04-20 14:22:09 +01002942 DCHECK(runtime->UseJitCompilation() && runtime->GetJit()->JitAtFirstUse());
David Srbeckyf4480162016-03-16 00:06:24 +00002943 // If we are doing native debugging, ignore application's AOT code,
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002944 // since we want to JIT it (at first use) with extra stackmaps for native
2945 // debugging. We keep however all AOT code from the boot image,
2946 // since the JIT-at-first-use is blocking and would result in non-negligible
2947 // startup performance impact.
David Srbeckyf4480162016-03-16 00:06:24 +00002948 return !runtime->GetHeap()->IsInBootImageOatFile(quick_code);
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002949 }
2950
2951 return false;
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002952}
2953
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002954void ClassLinker::FixupStaticTrampolines(ObjPtr<mirror::Class> klass) {
David Sehr709b0702016-10-13 09:12:37 -07002955 DCHECK(klass->IsInitialized()) << klass->PrettyDescriptor();
Ian Rogers1c829822013-09-30 18:18:50 -07002956 if (klass->NumDirectMethods() == 0) {
2957 return; // No direct methods => no static methods.
Ian Rogers19846512012-02-24 11:42:47 -08002958 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002959 Runtime* runtime = Runtime::Current();
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07002960 if (!runtime->IsStarted()) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002961 if (runtime->IsAotCompiler() || runtime->GetHeap()->HasBootImageSpace()) {
Alex Light64ad14d2014-08-19 14:23:13 -07002962 return; // OAT file unavailable.
2963 }
Ian Rogers19846512012-02-24 11:42:47 -08002964 }
Alex Light64ad14d2014-08-19 14:23:13 -07002965
Mathieu Chartierf8322842014-05-16 10:59:25 -07002966 const DexFile& dex_file = klass->GetDexFile();
2967 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Ian Rogers1c829822013-09-30 18:18:50 -07002968 CHECK(dex_class_def != nullptr);
Ian Rogers13735952014-10-08 12:43:28 -07002969 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
Ian Rogers1c829822013-09-30 18:18:50 -07002970 // There should always be class data if there were direct methods.
David Sehr709b0702016-10-13 09:12:37 -07002971 CHECK(class_data != nullptr) << klass->PrettyDescriptor();
Ian Rogers19846512012-02-24 11:42:47 -08002972 ClassDataItemIterator it(dex_file, class_data);
2973 // Skip fields
2974 while (it.HasNextStaticField()) {
2975 it.Next();
2976 }
2977 while (it.HasNextInstanceField()) {
2978 it.Next();
2979 }
Ian Rogers97b52f82014-08-14 11:34:07 -07002980 bool has_oat_class;
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002981 OatFile::OatClass oat_class = OatFile::FindOatClass(dex_file,
2982 klass->GetDexClassDefIndex(),
2983 &has_oat_class);
Ian Rogers1c829822013-09-30 18:18:50 -07002984 // Link the code of methods skipped by LinkCode.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002985 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002986 ArtMethod* method = klass->GetDirectMethod(method_index, image_pointer_size_);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002987 if (!method->IsStatic()) {
2988 // Only update static methods.
2989 continue;
Ian Rogers19846512012-02-24 11:42:47 -08002990 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01002991 const void* quick_code = nullptr;
2992 if (has_oat_class) {
2993 OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01002994 quick_code = oat_method.GetQuickCode();
2995 }
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002996 // Check whether the method is native, in which case it's generic JNI.
2997 if (quick_code == nullptr && method->IsNative()) {
2998 quick_code = GetQuickGenericJniStub();
2999 } else if (ShouldUseInterpreterEntrypoint(method, quick_code)) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003000 // Use interpreter entry point.
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003001 quick_code = GetQuickToInterpreterBridge();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003002 }
Elliott Hughes956af0f2014-12-11 14:34:28 -08003003 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code);
Ian Rogers19846512012-02-24 11:42:47 -08003004 }
Ian Rogers62d6c772013-02-27 08:32:07 -08003005 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08003006}
3007
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003008// Does anything needed to make sure that the compiler will not generate a direct invoke to this
3009// method. Should only be called on non-invokable methods.
3010inline void EnsureThrowsInvocationError(ClassLinker* class_linker, ArtMethod* method) {
Alex Light9139e002015-10-09 15:59:48 -07003011 DCHECK(method != nullptr);
3012 DCHECK(!method->IsInvokable());
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003013 method->SetEntryPointFromQuickCompiledCodePtrSize(
3014 class_linker->GetQuickToInterpreterBridgeTrampoline(),
3015 class_linker->GetImagePointerSize());
Alex Light9139e002015-10-09 15:59:48 -07003016}
3017
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003018static void LinkCode(ClassLinker* class_linker,
3019 ArtMethod* method,
3020 const OatFile::OatClass* oat_class,
3021 uint32_t class_def_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003022 Runtime* const runtime = Runtime::Current();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08003023 if (runtime->IsAotCompiler()) {
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003024 // The following code only applies to a non-compiler runtime.
3025 return;
3026 }
Ian Rogers62d6c772013-02-27 08:32:07 -08003027 // Method shouldn't have already been linked.
Ian Rogersef7d42f2014-01-06 12:55:46 -08003028 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003029 if (oat_class != nullptr) {
3030 // Every kind of method should at least get an invoke stub from the oat_method.
3031 // non-abstract methods also get their code pointers.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07003032 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003033 oat_method.LinkMethod(method);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003034 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07003035
Tamas Berghammer3a98aae2016-02-08 20:21:54 +00003036 // Install entry point from interpreter.
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003037 const void* quick_code = method->GetEntryPointFromQuickCompiledCode();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003038 bool enter_interpreter = class_linker->ShouldUseInterpreterEntrypoint(method, quick_code);
Jeff Hao16743632013-05-08 10:59:04 -07003039
Alex Light9139e002015-10-09 15:59:48 -07003040 if (!method->IsInvokable()) {
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003041 EnsureThrowsInvocationError(class_linker, method);
Brian Carlstrom92827a52011-10-10 15:50:01 -07003042 return;
3043 }
Ian Rogers19846512012-02-24 11:42:47 -08003044
3045 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003046 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003047 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
3048 // after initializing class (see ClassLinker::InitializeClass method).
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003049 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub());
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003050 } else if (quick_code == nullptr && method->IsNative()) {
3051 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniStub());
Tamas Berghammer3a98aae2016-02-08 20:21:54 +00003052 } else if (enter_interpreter) {
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003053 // Set entry point from compiled code if there's no code or in interpreter only mode.
3054 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08003055 }
jeffhao26c0a1a2012-01-17 16:28:33 -08003056
Ian Rogers62d6c772013-02-27 08:32:07 -08003057 if (method->IsNative()) {
3058 // Unregistering restores the dlsym lookup stub.
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003059 method->UnregisterNative();
Andreas Gampe90546832014-03-12 18:07:19 -07003060
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003061 if (enter_interpreter || quick_code == nullptr) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003062 // We have a native method here without code. Then it should have either the generic JNI
3063 // trampoline as entrypoint (non-static), or the resolution trampoline (static).
3064 // TODO: this doesn't handle all the cases where trampolines may be installed.
3065 const void* entry_point = method->GetEntryPointFromQuickCompiledCode();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003066 DCHECK(class_linker->IsQuickGenericJniStub(entry_point) ||
3067 class_linker->IsQuickResolutionStub(entry_point));
Andreas Gampe90546832014-03-12 18:07:19 -07003068 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07003069 }
3070}
3071
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003072void ClassLinker::SetupClass(const DexFile& dex_file,
3073 const DexFile::ClassDef& dex_class_def,
3074 Handle<mirror::Class> klass,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003075 ObjPtr<mirror::ClassLoader> class_loader) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08003076 CHECK(klass != nullptr);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003077 CHECK(klass->GetDexCache() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003078 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07003079 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003080 CHECK(descriptor != nullptr);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003081
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003082 klass->SetClass(GetClassRoot(kJavaLangClass));
Andreas Gampe51829322014-08-25 15:05:04 -07003083 uint32_t access_flags = dex_class_def.GetJavaAccessFlags();
Brian Carlstrom8e3fb142013-10-09 21:00:27 -07003084 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003085 klass->SetAccessFlags(access_flags);
3086 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08003087 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003088 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, nullptr);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003089
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003090 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003091 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Mathieu Chartierc7853442015-03-27 14:35:38 -07003092}
Brian Carlstrom934486c2011-07-12 23:42:50 -07003093
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003094void ClassLinker::LoadClass(Thread* self,
3095 const DexFile& dex_file,
Mathieu Chartierc7853442015-03-27 14:35:38 -07003096 const DexFile::ClassDef& dex_class_def,
3097 Handle<mirror::Class> klass) {
Ian Rogers13735952014-10-08 12:43:28 -07003098 const uint8_t* class_data = dex_file.GetClassData(dex_class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003099 if (class_data == nullptr) {
Ian Rogers0571d352011-11-03 19:51:38 -07003100 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07003101 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003102 LoadClassMembers(self, dex_file, class_data, klass);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01003103}
3104
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003105LengthPrefixedArray<ArtField>* ClassLinker::AllocArtFieldArray(Thread* self,
3106 LinearAlloc* allocator,
3107 size_t length) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003108 if (length == 0) {
3109 return nullptr;
3110 }
Vladimir Markocf36d492015-08-12 19:27:26 +01003111 // If the ArtField alignment changes, review all uses of LengthPrefixedArray<ArtField>.
3112 static_assert(alignof(ArtField) == 4, "ArtField alignment is expected to be 4.");
3113 size_t storage_size = LengthPrefixedArray<ArtField>::ComputeSize(length);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003114 void* array_storage = allocator->Alloc(self, storage_size);
Vladimir Markocf36d492015-08-12 19:27:26 +01003115 auto* ret = new(array_storage) LengthPrefixedArray<ArtField>(length);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003116 CHECK(ret != nullptr);
3117 std::uninitialized_fill_n(&ret->At(0), length, ArtField());
3118 return ret;
Mathieu Chartierc7853442015-03-27 14:35:38 -07003119}
3120
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003121LengthPrefixedArray<ArtMethod>* ClassLinker::AllocArtMethodArray(Thread* self,
3122 LinearAlloc* allocator,
3123 size_t length) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003124 if (length == 0) {
3125 return nullptr;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003126 }
Vladimir Marko14632852015-08-17 12:07:23 +01003127 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_);
3128 const size_t method_size = ArtMethod::Size(image_pointer_size_);
Vladimir Markocf36d492015-08-12 19:27:26 +01003129 const size_t storage_size =
3130 LengthPrefixedArray<ArtMethod>::ComputeSize(length, method_size, method_alignment);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003131 void* array_storage = allocator->Alloc(self, storage_size);
Vladimir Markocf36d492015-08-12 19:27:26 +01003132 auto* ret = new (array_storage) LengthPrefixedArray<ArtMethod>(length);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003133 CHECK(ret != nullptr);
3134 for (size_t i = 0; i < length; ++i) {
Vladimir Markocf36d492015-08-12 19:27:26 +01003135 new(reinterpret_cast<void*>(&ret->At(i, method_size, method_alignment))) ArtMethod;
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003136 }
3137 return ret;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003138}
3139
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003140LinearAlloc* ClassLinker::GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003141 if (class_loader == nullptr) {
3142 return Runtime::Current()->GetLinearAlloc();
3143 }
3144 LinearAlloc* allocator = class_loader->GetAllocator();
3145 DCHECK(allocator != nullptr);
3146 return allocator;
3147}
3148
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003149LinearAlloc* ClassLinker::GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003150 if (class_loader == nullptr) {
3151 return Runtime::Current()->GetLinearAlloc();
3152 }
3153 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3154 LinearAlloc* allocator = class_loader->GetAllocator();
3155 if (allocator == nullptr) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08003156 RegisterClassLoader(class_loader);
3157 allocator = class_loader->GetAllocator();
3158 CHECK(allocator != nullptr);
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003159 }
3160 return allocator;
3161}
3162
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003163void ClassLinker::LoadClassMembers(Thread* self,
3164 const DexFile& dex_file,
Ian Rogers13735952014-10-08 12:43:28 -07003165 const uint8_t* class_data,
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003166 Handle<mirror::Class> klass) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003167 {
3168 // Note: We cannot have thread suspension until the field and method arrays are setup or else
3169 // Class::VisitFieldRoots may miss some fields or methods.
Mathieu Chartier268764d2016-09-13 12:09:38 -07003170 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003171 // Load static fields.
Vladimir Marko23682bf2015-06-24 14:28:03 +01003172 // We allow duplicate definitions of the same field in a class_data_item
3173 // but ignore the repeated indexes here, b/21868015.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003174 LinearAlloc* const allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
Mathieu Chartiere401d142015-04-22 13:56:20 -07003175 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003176 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self,
3177 allocator,
3178 it.NumStaticFields());
Vladimir Marko23682bf2015-06-24 14:28:03 +01003179 size_t num_sfields = 0;
3180 uint32_t last_field_idx = 0u;
3181 for (; it.HasNextStaticField(); it.Next()) {
3182 uint32_t field_idx = it.GetMemberIndex();
3183 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier.
3184 if (num_sfields == 0 || LIKELY(field_idx > last_field_idx)) {
3185 DCHECK_LT(num_sfields, it.NumStaticFields());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003186 LoadField(it, klass, &sfields->At(num_sfields));
Vladimir Marko23682bf2015-06-24 14:28:03 +01003187 ++num_sfields;
3188 last_field_idx = field_idx;
3189 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003190 }
Orion Hodsonc069a302017-01-18 09:23:12 +00003191
Mathieu Chartiere401d142015-04-22 13:56:20 -07003192 // Load instance fields.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003193 LengthPrefixedArray<ArtField>* ifields = AllocArtFieldArray(self,
3194 allocator,
3195 it.NumInstanceFields());
Vladimir Marko23682bf2015-06-24 14:28:03 +01003196 size_t num_ifields = 0u;
3197 last_field_idx = 0u;
3198 for (; it.HasNextInstanceField(); it.Next()) {
3199 uint32_t field_idx = it.GetMemberIndex();
3200 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier.
3201 if (num_ifields == 0 || LIKELY(field_idx > last_field_idx)) {
3202 DCHECK_LT(num_ifields, it.NumInstanceFields());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003203 LoadField(it, klass, &ifields->At(num_ifields));
Vladimir Marko23682bf2015-06-24 14:28:03 +01003204 ++num_ifields;
3205 last_field_idx = field_idx;
3206 }
3207 }
Orion Hodsonc069a302017-01-18 09:23:12 +00003208
Vladimir Marko23682bf2015-06-24 14:28:03 +01003209 if (UNLIKELY(num_sfields != it.NumStaticFields()) ||
3210 UNLIKELY(num_ifields != it.NumInstanceFields())) {
David Sehr709b0702016-10-13 09:12:37 -07003211 LOG(WARNING) << "Duplicate fields in class " << klass->PrettyDescriptor()
Vladimir Marko23682bf2015-06-24 14:28:03 +01003212 << " (unique static fields: " << num_sfields << "/" << it.NumStaticFields()
3213 << ", unique instance fields: " << num_ifields << "/" << it.NumInstanceFields() << ")";
Vladimir Marko81819db2015-11-05 15:30:12 +00003214 // NOTE: Not shrinking the over-allocated sfields/ifields, just setting size.
3215 if (sfields != nullptr) {
3216 sfields->SetSize(num_sfields);
3217 }
3218 if (ifields != nullptr) {
3219 ifields->SetSize(num_ifields);
3220 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003221 }
Vladimir Marko81819db2015-11-05 15:30:12 +00003222 // Set the field arrays.
3223 klass->SetSFieldsPtr(sfields);
3224 DCHECK_EQ(klass->NumStaticFields(), num_sfields);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003225 klass->SetIFieldsPtr(ifields);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003226 DCHECK_EQ(klass->NumInstanceFields(), num_ifields);
3227 // Load methods.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003228 bool has_oat_class = false;
3229 const OatFile::OatClass oat_class =
3230 (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler())
3231 ? OatFile::FindOatClass(dex_file, klass->GetDexClassDefIndex(), &has_oat_class)
3232 : OatFile::OatClass::Invalid();
3233 const OatFile::OatClass* oat_class_ptr = has_oat_class ? &oat_class : nullptr;
Alex Lighte64300b2015-12-15 15:02:47 -08003234 klass->SetMethodsPtr(
3235 AllocArtMethodArray(self, allocator, it.NumDirectMethods() + it.NumVirtualMethods()),
3236 it.NumDirectMethods(),
3237 it.NumVirtualMethods());
Mathieu Chartiere401d142015-04-22 13:56:20 -07003238 size_t class_def_method_index = 0;
3239 uint32_t last_dex_method_index = DexFile::kDexNoIndex;
3240 size_t last_class_def_method_index = 0;
Alex Lighte64300b2015-12-15 15:02:47 -08003241 // TODO These should really use the iterators.
Mathieu Chartiere401d142015-04-22 13:56:20 -07003242 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
3243 ArtMethod* method = klass->GetDirectMethodUnchecked(i, image_pointer_size_);
Mathieu Chartier268764d2016-09-13 12:09:38 -07003244 LoadMethod(dex_file, it, klass, method);
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003245 LinkCode(this, method, oat_class_ptr, class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003246 uint32_t it_method_index = it.GetMemberIndex();
3247 if (last_dex_method_index == it_method_index) {
3248 // duplicate case
3249 method->SetMethodIndex(last_class_def_method_index);
3250 } else {
3251 method->SetMethodIndex(class_def_method_index);
3252 last_dex_method_index = it_method_index;
3253 last_class_def_method_index = class_def_method_index;
3254 }
3255 class_def_method_index++;
3256 }
3257 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
3258 ArtMethod* method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
Mathieu Chartier268764d2016-09-13 12:09:38 -07003259 LoadMethod(dex_file, it, klass, method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003260 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003261 LinkCode(this, method, oat_class_ptr, class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003262 class_def_method_index++;
3263 }
3264 DCHECK(!it.HasNext());
Ian Rogers0571d352011-11-03 19:51:38 -07003265 }
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07003266 // Ensure that the card is marked so that remembered sets pick up native roots.
3267 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass.Get());
Mathieu Chartierf3f2a7a2015-04-14 15:43:10 -07003268 self->AllowThreadSuspension();
Brian Carlstrom934486c2011-07-12 23:42:50 -07003269}
3270
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003271void ClassLinker::LoadField(const ClassDataItemIterator& it,
3272 Handle<mirror::Class> klass,
Mathieu Chartierc7853442015-03-27 14:35:38 -07003273 ArtField* dst) {
3274 const uint32_t field_idx = it.GetMemberIndex();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003275 dst->SetDexFieldIndex(field_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003276 dst->SetDeclaringClass(klass.Get());
Andreas Gampe51829322014-08-25 15:05:04 -07003277 dst->SetAccessFlags(it.GetFieldAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07003278}
3279
Mathieu Chartier268764d2016-09-13 12:09:38 -07003280void ClassLinker::LoadMethod(const DexFile& dex_file,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003281 const ClassDataItemIterator& it,
3282 Handle<mirror::Class> klass,
3283 ArtMethod* dst) {
Ian Rogers19846512012-02-24 11:42:47 -08003284 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08003285 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07003286 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07003287
Mathieu Chartier268764d2016-09-13 12:09:38 -07003288 ScopedAssertNoThreadSuspension ants("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07003289 dst->SetDexMethodIndex(dex_method_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003290 dst->SetDeclaringClass(klass.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07003291 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Brian Carlstrom934486c2011-07-12 23:42:50 -07003292
Vladimir Marko05792b92015-08-03 11:56:49 +01003293 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods(), image_pointer_size_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07003294
Andreas Gampe51829322014-08-25 15:05:04 -07003295 uint32_t access_flags = it.GetMethodAccessFlags();
Ian Rogers241b5de2013-10-09 17:58:57 -07003296
Ian Rogersdfb325e2013-10-30 01:00:44 -07003297 if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07003298 // Set finalizable flag on declaring class.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003299 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
3300 // Void return type.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003301 if (klass->GetClassLoader() != nullptr) { // All non-boot finalizer methods are flagged.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003302 klass->SetFinalizable();
3303 } else {
Ian Rogers1ff3c982014-08-12 02:30:58 -07003304 std::string temp;
3305 const char* klass_descriptor = klass->GetDescriptor(&temp);
Ian Rogersdfb325e2013-10-30 01:00:44 -07003306 // The Enum class declares a "final" finalize() method to prevent subclasses from
3307 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
3308 // subclasses, so we exclude it here.
3309 // We also want to avoid setting the flag on Object, where we know that finalize() is
3310 // empty.
Ian Rogers1ff3c982014-08-12 02:30:58 -07003311 if (strcmp(klass_descriptor, "Ljava/lang/Object;") != 0 &&
3312 strcmp(klass_descriptor, "Ljava/lang/Enum;") != 0) {
Ian Rogers241b5de2013-10-09 17:58:57 -07003313 klass->SetFinalizable();
Ian Rogers241b5de2013-10-09 17:58:57 -07003314 }
3315 }
3316 }
3317 } else if (method_name[0] == '<') {
3318 // Fix broken access flags for initializers. Bug 11157540.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003319 bool is_init = (strcmp("<init>", method_name) == 0);
3320 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
Ian Rogers241b5de2013-10-09 17:58:57 -07003321 if (UNLIKELY(!is_init && !is_clinit)) {
3322 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
3323 } else {
3324 if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
3325 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
David Sehr709b0702016-10-13 09:12:37 -07003326 << klass->PrettyDescriptor() << " in dex file " << dex_file.GetLocation();
Ian Rogers241b5de2013-10-09 17:58:57 -07003327 access_flags |= kAccConstructor;
3328 }
3329 }
3330 }
3331 dst->SetAccessFlags(access_flags);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003332}
3333
Ian Rogers7b078e82014-09-10 14:44:24 -07003334void ClassLinker::AppendToBootClassPath(Thread* self, const DexFile& dex_file) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003335 ObjPtr<mirror::DexCache> dex_cache = AllocAndInitializeDexCache(
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003336 self,
3337 dex_file,
Vladimir Markocd556b02017-02-03 11:47:34 +00003338 Runtime::Current()->GetLinearAlloc());
3339 CHECK(dex_cache != nullptr) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003340 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07003341}
3342
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003343void ClassLinker::AppendToBootClassPath(const DexFile& dex_file,
Vladimir Markocd556b02017-02-03 11:47:34 +00003344 ObjPtr<mirror::DexCache> dex_cache) {
3345 CHECK(dex_cache != nullptr) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003346 boot_class_path_.push_back(&dex_file);
Vladimir Markocd556b02017-02-03 11:47:34 +00003347 RegisterBootClassPathDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003348}
3349
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003350void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file,
Vladimir Markocd556b02017-02-03 11:47:34 +00003351 ObjPtr<mirror::DexCache> dex_cache,
3352 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003353 Thread* const self = Thread::Current();
Andreas Gampecc1b5352016-12-01 16:58:38 -08003354 Locks::dex_lock_->AssertExclusiveHeld(self);
Vladimir Markocd556b02017-02-03 11:47:34 +00003355 CHECK(dex_cache != nullptr) << dex_file.GetLocation();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003356 // For app images, the dex cache location may be a suffix of the dex file location since the
3357 // dex file location is an absolute path.
Mathieu Chartier76172162016-01-26 14:54:06 -08003358 const std::string dex_cache_location = dex_cache->GetLocation()->ToModifiedUtf8();
3359 const size_t dex_cache_length = dex_cache_location.length();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003360 CHECK_GT(dex_cache_length, 0u) << dex_file.GetLocation();
3361 std::string dex_file_location = dex_file.GetLocation();
3362 CHECK_GE(dex_file_location.length(), dex_cache_length)
Mathieu Chartier76172162016-01-26 14:54:06 -08003363 << dex_cache_location << " " << dex_file.GetLocation();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003364 // Take suffix.
3365 const std::string dex_file_suffix = dex_file_location.substr(
3366 dex_file_location.length() - dex_cache_length,
3367 dex_cache_length);
3368 // Example dex_cache location is SettingsProvider.apk and
3369 // dex file location is /system/priv-app/SettingsProvider/SettingsProvider.apk
Mathieu Chartier76172162016-01-26 14:54:06 -08003370 CHECK_EQ(dex_cache_location, dex_file_suffix);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003371 // Clean up pass to remove null dex caches.
3372 // Null dex caches can occur due to class unloading and we are lazily removing null entries.
3373 JavaVMExt* const vm = self->GetJniEnv()->vm;
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003374 for (auto it = dex_caches_.begin(); it != dex_caches_.end(); ) {
3375 DexCacheData data = *it;
3376 if (self->IsJWeakCleared(data.weak_root)) {
3377 vm->DeleteWeakGlobalRef(self, data.weak_root);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003378 it = dex_caches_.erase(it);
3379 } else {
3380 ++it;
3381 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003382 }
Vladimir Markocd556b02017-02-03 11:47:34 +00003383 jweak dex_cache_jweak = vm->AddWeakGlobalRef(self, dex_cache);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003384 dex_cache->SetDexFile(&dex_file);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003385 DexCacheData data;
3386 data.weak_root = dex_cache_jweak;
3387 data.dex_file = dex_cache->GetDexFile();
Vladimir Marko942fd312017-01-16 20:52:19 +00003388 data.resolved_methods = dex_cache->GetResolvedMethods();
Vladimir Markocd556b02017-02-03 11:47:34 +00003389 data.class_table = ClassTableForClassLoader(class_loader);
3390 DCHECK(data.class_table != nullptr);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003391 dex_caches_.push_back(data);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003392}
3393
Vladimir Markocd556b02017-02-03 11:47:34 +00003394ObjPtr<mirror::DexCache> ClassLinker::DecodeDexCache(Thread* self, const DexCacheData& data) {
3395 return data.IsValid()
3396 ? ObjPtr<mirror::DexCache>::DownCast(self->DecodeJObject(data.weak_root))
3397 : nullptr;
3398}
3399
3400ObjPtr<mirror::DexCache> ClassLinker::EnsureSameClassLoader(
3401 Thread* self,
3402 ObjPtr<mirror::DexCache> dex_cache,
3403 const DexCacheData& data,
3404 ObjPtr<mirror::ClassLoader> class_loader) {
3405 DCHECK_EQ(dex_cache->GetDexFile(), data.dex_file);
3406 if (data.class_table != ClassTableForClassLoader(class_loader)) {
3407 self->ThrowNewExceptionF("Ljava/lang/InternalError;",
3408 "Attempt to register dex file %s with multiple class loaders",
3409 data.dex_file->GetLocation().c_str());
3410 return nullptr;
3411 }
3412 return dex_cache;
3413}
3414
3415ObjPtr<mirror::DexCache> ClassLinker::RegisterDexFile(const DexFile& dex_file,
3416 ObjPtr<mirror::ClassLoader> class_loader) {
Ian Rogers1f539342012-10-03 21:09:42 -07003417 Thread* self = Thread::Current();
Vladimir Markocd556b02017-02-03 11:47:34 +00003418 DexCacheData old_data;
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003419 {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003420 ReaderMutexLock mu(self, *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003421 old_data = FindDexCacheDataLocked(dex_file);
3422 }
3423 ObjPtr<mirror::DexCache> old_dex_cache = DecodeDexCache(self, old_data);
3424 if (old_dex_cache != nullptr) {
3425 return EnsureSameClassLoader(self, old_dex_cache, old_data, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003426 }
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003427 LinearAlloc* const linear_alloc = GetOrCreateAllocatorForClassLoader(class_loader);
3428 DCHECK(linear_alloc != nullptr);
3429 ClassTable* table;
3430 {
3431 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
3432 table = InsertClassTableForClassLoader(class_loader);
3433 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003434 // Don't alloc while holding the lock, since allocation may need to
3435 // suspend all threads and another thread may need the dex_lock_ to
3436 // get to a suspend point.
Vladimir Markocd556b02017-02-03 11:47:34 +00003437 StackHandleScope<3> hs(self);
3438 Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(class_loader));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003439 ObjPtr<mirror::String> location;
Mathieu Chartier6c60d842016-09-15 10:24:43 -07003440 Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(AllocDexCache(/*out*/&location,
3441 self,
3442 dex_file)));
3443 Handle<mirror::String> h_location(hs.NewHandle(location));
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003444 {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003445 WriterMutexLock mu(self, *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003446 old_data = FindDexCacheDataLocked(dex_file);
3447 old_dex_cache = DecodeDexCache(self, old_data);
Andreas Gampefa4333d2017-02-14 11:10:34 -08003448 if (old_dex_cache == nullptr && h_dex_cache != nullptr) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003449 // Do InitializeDexCache while holding dex lock to make sure two threads don't call it at the
3450 // same time with the same dex cache. Since the .bss is shared this can cause failing DCHECK
3451 // that the arrays are null.
3452 mirror::DexCache::InitializeDexCache(self,
3453 h_dex_cache.Get(),
3454 h_location.Get(),
3455 &dex_file,
3456 linear_alloc,
3457 image_pointer_size_);
3458 RegisterDexFileLocked(dex_file, h_dex_cache.Get(), h_class_loader.Get());
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003459 }
Vladimir Markocd556b02017-02-03 11:47:34 +00003460 }
3461 if (old_dex_cache != nullptr) {
3462 // Another thread managed to initialize the dex cache faster, so use that DexCache.
3463 // If this thread encountered OOME, ignore it.
Andreas Gampefa4333d2017-02-14 11:10:34 -08003464 DCHECK_EQ(h_dex_cache == nullptr, self->IsExceptionPending());
Vladimir Markocd556b02017-02-03 11:47:34 +00003465 self->ClearException();
3466 // We cannot call EnsureSameClassLoader() while holding the dex_lock_.
3467 return EnsureSameClassLoader(self, old_dex_cache, old_data, h_class_loader.Get());
3468 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08003469 if (h_dex_cache == nullptr) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003470 self->AssertPendingOOMException();
3471 return nullptr;
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003472 }
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003473 table->InsertStrongRoot(h_dex_cache.Get());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003474 return h_dex_cache.Get();
Brian Carlstromaded5f72011-10-07 17:15:04 -07003475}
3476
Vladimir Markocd556b02017-02-03 11:47:34 +00003477void ClassLinker::RegisterBootClassPathDexFile(const DexFile& dex_file,
3478 ObjPtr<mirror::DexCache> dex_cache) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003479 WriterMutexLock mu(Thread::Current(), *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003480 RegisterDexFileLocked(dex_file, dex_cache, /* class_loader */ nullptr);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003481}
3482
Vladimir Markocd556b02017-02-03 11:47:34 +00003483bool ClassLinker::IsDexFileRegistered(Thread* self, const DexFile& dex_file) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003484 ReaderMutexLock mu(self, *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003485 return DecodeDexCache(self, FindDexCacheDataLocked(dex_file)) != nullptr;
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003486}
3487
Vladimir Markocd556b02017-02-03 11:47:34 +00003488ObjPtr<mirror::DexCache> ClassLinker::FindDexCache(Thread* self, const DexFile& dex_file) {
3489 ReaderMutexLock mu(self, *Locks::dex_lock_);
3490 ObjPtr<mirror::DexCache> dex_cache = DecodeDexCache(self, FindDexCacheDataLocked(dex_file));
3491 if (dex_cache != nullptr) {
3492 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003493 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003494 // Failure, dump diagnostic and abort.
Vladimir Markocd556b02017-02-03 11:47:34 +00003495 std::string location(dex_file.GetLocation());
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003496 for (const DexCacheData& data : dex_caches_) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003497 if (DecodeDexCache(self, data) != nullptr) {
3498 LOG(ERROR) << "Registered dex file " << data.dex_file->GetLocation();
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003499 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003500 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003501 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Ian Rogerse0a02da2014-12-02 14:10:53 -08003502 UNREACHABLE();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003503}
3504
Vladimir Markocd556b02017-02-03 11:47:34 +00003505ClassTable* ClassLinker::FindClassTable(Thread* self, ObjPtr<mirror::DexCache> dex_cache) {
3506 const DexFile* dex_file = dex_cache->GetDexFile();
3507 DCHECK(dex_file != nullptr);
3508 ReaderMutexLock mu(self, *Locks::dex_lock_);
3509 // Search assuming unique-ness of dex file.
3510 for (const DexCacheData& data : dex_caches_) {
3511 // Avoid decoding (and read barriers) other unrelated dex caches.
3512 if (data.dex_file == dex_file) {
3513 ObjPtr<mirror::DexCache> registered_dex_cache = DecodeDexCache(self, data);
3514 if (registered_dex_cache != nullptr) {
3515 CHECK_EQ(registered_dex_cache, dex_cache) << dex_file->GetLocation();
3516 return data.class_table;
3517 }
3518 }
3519 }
3520 return nullptr;
3521}
3522
3523ClassLinker::DexCacheData ClassLinker::FindDexCacheDataLocked(const DexFile& dex_file) {
3524 // Search assuming unique-ness of dex file.
3525 for (const DexCacheData& data : dex_caches_) {
3526 // Avoid decoding (and read barriers) other unrelated dex caches.
3527 if (data.dex_file == &dex_file) {
3528 return data;
3529 }
3530 }
3531 return DexCacheData();
3532}
3533
Mathieu Chartiere401d142015-04-22 13:56:20 -07003534void ClassLinker::FixupDexCaches(ArtMethod* resolution_method) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003535 Thread* const self = Thread::Current();
Andreas Gampecc1b5352016-12-01 16:58:38 -08003536 ReaderMutexLock mu(self, *Locks::dex_lock_);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003537 for (const DexCacheData& data : dex_caches_) {
3538 if (!self->IsJWeakCleared(data.weak_root)) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003539 ObjPtr<mirror::DexCache> dex_cache = ObjPtr<mirror::DexCache>::DownCast(
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003540 self->DecodeJObject(data.weak_root));
3541 if (dex_cache != nullptr) {
3542 dex_cache->Fixup(resolution_method, image_pointer_size_);
3543 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003544 }
Ian Rogers19846512012-02-24 11:42:47 -08003545 }
3546}
3547
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003548mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Mathieu Chartier6beced42016-11-15 15:51:31 -08003549 ObjPtr<mirror::Class> klass =
3550 AllocClass(self, mirror::Class::PrimitiveClassSize(image_pointer_size_));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003551 if (UNLIKELY(klass == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003552 self->AssertPendingOOMException();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003553 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003554 }
3555 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003556}
3557
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003558mirror::Class* ClassLinker::InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003559 Primitive::Type type) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003560 CHECK(primitive_class != nullptr);
Ian Rogers1f539342012-10-03 21:09:42 -07003561 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003562 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003563 StackHandleScope<1> hs(self);
3564 Handle<mirror::Class> h_class(hs.NewHandle(primitive_class));
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003565 ObjectLock<mirror::Class> lock(self, h_class);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003566 h_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
3567 h_class->SetPrimitiveType(type);
Mathieu Chartier6beced42016-11-15 15:51:31 -08003568 h_class->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003569 mirror::Class::SetStatus(h_class, mirror::Class::kStatusInitialized, self);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003570 const char* descriptor = Primitive::Descriptor(type);
Mathieu Chartier6beced42016-11-15 15:51:31 -08003571 ObjPtr<mirror::Class> existing = InsertClass(descriptor,
3572 h_class.Get(),
3573 ComputeModifiedUtf8Hash(descriptor));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003574 CHECK(existing == nullptr) << "InitPrimitiveClass(" << type << ") failed";
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003575 return h_class.Get();
Carl Shapiro565f5072011-07-10 13:39:43 -07003576}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003577
Brian Carlstrombe977852011-07-19 14:54:54 -07003578// Create an array class (i.e. the class object for the array, not the
3579// array itself). "descriptor" looks like "[C" or "[[[[B" or
3580// "[Ljava/lang/String;".
3581//
3582// If "descriptor" refers to an array of primitives, look up the
3583// primitive type's internally-generated class object.
3584//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003585// "class_loader" is the class loader of the class that's referring to
3586// us. It's used to ensure that we're looking for the element type in
3587// the right context. It does NOT become the class loader for the
3588// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07003589//
Mathieu Chartier2cebb242015-04-21 16:50:40 -07003590// Returns null with an exception raised on failure.
Igor Murashkinb1d8c312015-08-04 11:18:43 -07003591mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor, size_t hash,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003592 Handle<mirror::ClassLoader> class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003593 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003594 CHECK_EQ('[', descriptor[0]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003595 StackHandleScope<2> hs(self);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003596 MutableHandle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1,
3597 class_loader)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003598 if (component_type == nullptr) {
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003599 DCHECK(self->IsExceptionPending());
Andreas Gampedc13d7d2014-07-23 20:18:36 -07003600 // We need to accept erroneous classes as component types.
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08003601 const size_t component_hash = ComputeModifiedUtf8Hash(descriptor + 1);
3602 component_type.Assign(LookupClass(self, descriptor + 1, component_hash, class_loader.Get()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003603 if (component_type == nullptr) {
Andreas Gampedc13d7d2014-07-23 20:18:36 -07003604 DCHECK(self->IsExceptionPending());
3605 return nullptr;
3606 } else {
3607 self->ClearException();
3608 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003609 }
Ian Rogers2d10b202014-05-12 19:15:18 -07003610 if (UNLIKELY(component_type->IsPrimitiveVoid())) {
3611 ThrowNoClassDefFoundError("Attempt to create array of void primitive type");
3612 return nullptr;
3613 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003614 // See if the component type is already loaded. Array classes are
3615 // always associated with the class loader of their underlying
3616 // element type -- an array of Strings goes with the loader for
3617 // java/lang/String -- so we need to look for it there. (The
3618 // caller should have checked for the existence of the class
3619 // before calling here, but they did so with *their* class loader,
3620 // not the component type's loader.)
3621 //
3622 // If we find it, the caller adds "loader" to the class' initiating
3623 // loader list, which should prevent us from going through this again.
3624 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003625 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003626 // are the same, because our caller (FindClass) just did the
3627 // lookup. (Even if we get this wrong we still have correct behavior,
3628 // because we effectively do this lookup again when we add the new
3629 // class to the hash table --- necessary because of possible races with
3630 // other threads.)
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003631 if (class_loader.Get() != component_type->GetClassLoader()) {
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00003632 ObjPtr<mirror::Class> new_class =
3633 LookupClass(self, descriptor, hash, component_type->GetClassLoader());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003634 if (new_class != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003635 return new_class.Ptr();
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003636 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003637 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003638
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003639 // Fill out the fields in the Class.
3640 //
3641 // It is possible to execute some methods against arrays, because
3642 // all arrays are subclasses of java_lang_Object_, so we need to set
3643 // up a vtable. We can just point at the one in java_lang_Object_.
3644 //
3645 // Array classes are simple enough that we don't need to do a full
3646 // link step.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003647 auto new_class = hs.NewHandle<mirror::Class>(nullptr);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003648 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003649 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003650 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003651 new_class.Assign(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003652 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003653 new_class.Assign(GetClassRoot(kObjectArrayClass));
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003654 } else if (strcmp(descriptor, GetClassRootDescriptor(kJavaLangStringArrayClass)) == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003655 new_class.Assign(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003656 } else if (strcmp(descriptor, "[C") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003657 new_class.Assign(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003658 } else if (strcmp(descriptor, "[I") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003659 new_class.Assign(GetClassRoot(kIntArrayClass));
Mathieu Chartierc7853442015-03-27 14:35:38 -07003660 } else if (strcmp(descriptor, "[J") == 0) {
3661 new_class.Assign(GetClassRoot(kLongArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003662 }
3663 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08003664 if (new_class == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003665 new_class.Assign(AllocClass(self, mirror::Array::ClassSize(image_pointer_size_)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003666 if (new_class == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003667 self->AssertPendingOOMException();
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003668 return nullptr;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003669 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003670 new_class->SetComponentType(component_type.Get());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003671 }
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003672 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003673 DCHECK(new_class->GetComponentType() != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003674 ObjPtr<mirror::Class> java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003675 new_class->SetSuperClass(java_lang_Object);
3676 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003677 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003678 new_class->SetClassLoader(component_type->GetClassLoader());
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07003679 if (component_type->IsPrimitive()) {
3680 new_class->SetClassFlags(mirror::kClassFlagNoReferenceFields);
3681 } else {
3682 new_class->SetClassFlags(mirror::kClassFlagObjectArray);
3683 }
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003684 mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self);
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00003685 new_class->PopulateEmbeddedVTable(image_pointer_size_);
3686 ImTable* object_imt = java_lang_Object->GetImt(image_pointer_size_);
3687 new_class->SetImt(object_imt, image_pointer_size_);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003688 mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003689 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07003690 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003691
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003692 // All arrays have java/lang/Cloneable and java/io/Serializable as
3693 // interfaces. We need to set that up here, so that stuff like
3694 // "instanceof" works right.
3695 //
3696 // Note: The GC could run during the call to FindSystemClass,
3697 // so we need to make sure the class object is GC-valid while we're in
3698 // there. Do this by clearing the interface list so the GC will just
3699 // think that the entries are null.
3700
3701
3702 // Use the single, global copies of "interfaces" and "iftable"
3703 // (remember not to free them for arrays).
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003704 {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003705 ObjPtr<mirror::IfTable> array_iftable = array_iftable_.Read();
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003706 CHECK(array_iftable != nullptr);
3707 new_class->SetIfTable(array_iftable);
3708 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003709
Elliott Hughes00626c22013-06-14 15:04:14 -07003710 // Inherit access flags from the component type.
3711 int access_flags = new_class->GetComponentType()->GetAccessFlags();
3712 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
3713 access_flags &= kAccJavaFlagsMask;
3714 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003715 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07003716 access_flags |= kAccAbstract | kAccFinal;
3717 access_flags &= ~kAccInterface;
3718
3719 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003720
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003721 ObjPtr<mirror::Class> existing = InsertClass(descriptor, new_class.Get(), hash);
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003722 if (existing == nullptr) {
Tamas Berghammer160e6df2016-01-05 14:29:02 +00003723 jit::Jit::NewTypeLoadedIfUsingJit(new_class.Get());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003724 return new_class.Get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003725 }
3726 // Another thread must have loaded the class after we
3727 // started but before we finished. Abandon what we've
3728 // done.
3729 //
3730 // (Yes, this happens.)
3731
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003732 return existing.Ptr();
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003733}
3734
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003735mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Ian Rogers62f05122014-03-21 11:21:29 -07003736 switch (type) {
3737 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003738 return GetClassRoot(kPrimitiveByte);
Ian Rogers62f05122014-03-21 11:21:29 -07003739 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003740 return GetClassRoot(kPrimitiveChar);
Ian Rogers62f05122014-03-21 11:21:29 -07003741 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003742 return GetClassRoot(kPrimitiveDouble);
Ian Rogers62f05122014-03-21 11:21:29 -07003743 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003744 return GetClassRoot(kPrimitiveFloat);
Ian Rogers62f05122014-03-21 11:21:29 -07003745 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003746 return GetClassRoot(kPrimitiveInt);
Ian Rogers62f05122014-03-21 11:21:29 -07003747 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003748 return GetClassRoot(kPrimitiveLong);
Ian Rogers62f05122014-03-21 11:21:29 -07003749 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003750 return GetClassRoot(kPrimitiveShort);
Ian Rogers62f05122014-03-21 11:21:29 -07003751 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003752 return GetClassRoot(kPrimitiveBoolean);
Ian Rogers62f05122014-03-21 11:21:29 -07003753 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003754 return GetClassRoot(kPrimitiveVoid);
Ian Rogers62f05122014-03-21 11:21:29 -07003755 default:
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003756 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07003757 }
Elliott Hughesbd935992011-08-22 11:59:34 -07003758 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003759 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003760 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003761}
3762
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003763mirror::Class* ClassLinker::InsertClass(const char* descriptor, ObjPtr<mirror::Class> klass, size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08003764 if (VLOG_IS_ON(class_linker)) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003765 ObjPtr<mirror::DexCache> dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08003766 std::string source;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003767 if (dex_cache != nullptr) {
Brian Carlstromae826982011-11-09 01:33:42 -08003768 source += " from ";
3769 source += dex_cache->GetLocation()->ToModifiedUtf8();
3770 }
3771 LOG(INFO) << "Loaded class " << descriptor << source;
3772 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003773 {
3774 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003775 ObjPtr<mirror::ClassLoader> const class_loader = klass->GetClassLoader();
Mathieu Chartier65975772016-08-05 10:46:36 -07003776 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003777 ObjPtr<mirror::Class> existing = class_table->Lookup(descriptor, hash);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003778 if (existing != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003779 return existing.Ptr();
Mathieu Chartier65975772016-08-05 10:46:36 -07003780 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003781 VerifyObject(klass);
3782 class_table->InsertWithHash(klass, hash);
3783 if (class_loader != nullptr) {
3784 // This is necessary because we need to have the card dirtied for remembered sets.
3785 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
3786 }
Vladimir Marko1998cd02017-01-13 13:02:58 +00003787 if (log_new_roots_) {
Mathieu Chartier65975772016-08-05 10:46:36 -07003788 new_class_roots_.push_back(GcRoot<mirror::Class>(klass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003789 }
3790 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003791 if (kIsDebugBuild) {
3792 // Test that copied methods correctly can find their holder.
3793 for (ArtMethod& method : klass->GetCopiedMethods(image_pointer_size_)) {
3794 CHECK_EQ(GetHoldingClassOfCopiedMethod(&method), klass);
3795 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08003796 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003797 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003798}
3799
Vladimir Marko1998cd02017-01-13 13:02:58 +00003800void ClassLinker::WriteBarrierForBootOatFileBssRoots(const OatFile* oat_file) {
Vladimir Marko9b03cb42017-02-16 16:37:03 +00003801 if (!kUseReadBarrier) {
3802 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3803 DCHECK(!oat_file->GetBssGcRoots().empty()) << oat_file->GetLocation();
3804 if (log_new_roots_ && !ContainsElement(new_bss_roots_boot_oat_files_, oat_file)) {
3805 new_bss_roots_boot_oat_files_.push_back(oat_file);
3806 }
3807 } else {
3808 LOG(FATAL) << "UNREACHABLE";
Vladimir Marko1998cd02017-01-13 13:02:58 +00003809 }
3810}
3811
Alex Lighte64300b2015-12-15 15:02:47 -08003812// TODO This should really be in mirror::Class.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003813void ClassLinker::UpdateClassMethods(ObjPtr<mirror::Class> klass,
Alex Lighte64300b2015-12-15 15:02:47 -08003814 LengthPrefixedArray<ArtMethod>* new_methods) {
3815 klass->SetMethodsPtrUnchecked(new_methods,
3816 klass->NumDirectMethods(),
3817 klass->NumDeclaredVirtualMethods());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003818 // Need to mark the card so that the remembered sets and mod union tables get updated.
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07003819 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003820}
3821
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003822mirror::Class* ClassLinker::LookupClass(Thread* self,
3823 const char* descriptor,
3824 size_t hash,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003825 ObjPtr<mirror::ClassLoader> class_loader) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01003826 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
3827 ClassTable* const class_table = ClassTableForClassLoader(class_loader);
3828 if (class_table != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003829 ObjPtr<mirror::Class> result = class_table->Lookup(descriptor, hash);
Vladimir Marko1a1de672016-10-13 12:53:15 +01003830 if (result != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003831 return result.Ptr();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003832 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07003833 }
Vladimir Marko1a1de672016-10-13 12:53:15 +01003834 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003835}
3836
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003837class MoveClassTableToPreZygoteVisitor : public ClassLoaderVisitor {
3838 public:
3839 explicit MoveClassTableToPreZygoteVisitor() {}
3840
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003841 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003842 REQUIRES(Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003843 REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003844 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier6b069532015-08-05 15:08:12 -07003845 if (class_table != nullptr) {
3846 class_table->FreezeSnapshot();
3847 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07003848 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003849};
3850
3851void ClassLinker::MoveClassTableToPreZygote() {
3852 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3853 boot_class_table_.FreezeSnapshot();
3854 MoveClassTableToPreZygoteVisitor visitor;
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003855 VisitClassLoaders(&visitor);
Mathieu Chartierc2e20622014-11-03 11:41:47 -08003856}
3857
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003858// Look up classes by hash and descriptor and put all matching ones in the result array.
3859class LookupClassesVisitor : public ClassLoaderVisitor {
3860 public:
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003861 LookupClassesVisitor(const char* descriptor,
3862 size_t hash,
3863 std::vector<ObjPtr<mirror::Class>>* result)
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003864 : descriptor_(descriptor),
3865 hash_(hash),
3866 result_(result) {}
3867
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003868 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003869 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003870 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003871 ObjPtr<mirror::Class> klass = class_table->Lookup(descriptor_, hash_);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00003872 // Add `klass` only if `class_loader` is its defining (not just initiating) class loader.
3873 if (klass != nullptr && klass->GetClassLoader() == class_loader) {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003874 result_->push_back(klass);
3875 }
3876 }
3877
3878 private:
3879 const char* const descriptor_;
3880 const size_t hash_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003881 std::vector<ObjPtr<mirror::Class>>* const result_;
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003882};
3883
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003884void ClassLinker::LookupClasses(const char* descriptor,
3885 std::vector<ObjPtr<mirror::Class>>& result) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003886 result.clear();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003887 Thread* const self = Thread::Current();
3888 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003889 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003890 ObjPtr<mirror::Class> klass = boot_class_table_.Lookup(descriptor, hash);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003891 if (klass != nullptr) {
Vladimir Markoc5798bf2016-12-09 10:20:54 +00003892 DCHECK(klass->GetClassLoader() == nullptr);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003893 result.push_back(klass);
3894 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003895 LookupClassesVisitor visitor(descriptor, hash, &result);
3896 VisitClassLoaders(&visitor);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08003897}
3898
Alex Lightf1f10492015-10-07 16:08:36 -07003899bool ClassLinker::AttemptSupertypeVerification(Thread* self,
3900 Handle<mirror::Class> klass,
3901 Handle<mirror::Class> supertype) {
3902 DCHECK(self != nullptr);
Andreas Gampefa4333d2017-02-14 11:10:34 -08003903 DCHECK(klass != nullptr);
3904 DCHECK(supertype != nullptr);
Alex Lightf1f10492015-10-07 16:08:36 -07003905
Alex Lightf1f10492015-10-07 16:08:36 -07003906 if (!supertype->IsVerified() && !supertype->IsErroneous()) {
3907 VerifyClass(self, supertype);
3908 }
3909 if (supertype->IsCompileTimeVerified()) {
3910 // Either we are verified or we soft failed and need to retry at runtime.
3911 return true;
3912 }
3913 // If we got this far then we have a hard failure.
3914 std::string error_msg =
3915 StringPrintf("Rejecting class %s that attempts to sub-type erroneous class %s",
David Sehr709b0702016-10-13 09:12:37 -07003916 klass->PrettyDescriptor().c_str(),
3917 supertype->PrettyDescriptor().c_str());
Alex Lightf1f10492015-10-07 16:08:36 -07003918 LOG(WARNING) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003919 StackHandleScope<1> hs(self);
Alex Lightf1f10492015-10-07 16:08:36 -07003920 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003921 if (cause != nullptr) {
Alex Lightf1f10492015-10-07 16:08:36 -07003922 // Set during VerifyClass call (if at all).
3923 self->ClearException();
3924 }
3925 // Change into a verify error.
3926 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
Andreas Gampefa4333d2017-02-14 11:10:34 -08003927 if (cause != nullptr) {
Alex Lightf1f10492015-10-07 16:08:36 -07003928 self->GetException()->SetCause(cause.Get());
3929 }
3930 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex());
3931 if (Runtime::Current()->IsAotCompiler()) {
3932 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref);
3933 }
Andreas Gampe884f3b82016-03-30 19:52:58 -07003934 // Need to grab the lock to change status.
3935 ObjectLock<mirror::Class> super_lock(self, klass);
Vladimir Marko72ab6842017-01-20 19:32:50 +00003936 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Alex Lightf1f10492015-10-07 16:08:36 -07003937 return false;
3938}
3939
Andreas Gampecc1b5352016-12-01 16:58:38 -08003940// Ensures that methods have the kAccSkipAccessChecks bit set. We use the
3941// kAccVerificationAttempted bit on the class access flags to determine whether this has been done
3942// before.
3943static void EnsureSkipAccessChecksMethods(Handle<mirror::Class> klass, PointerSize pointer_size)
3944 REQUIRES_SHARED(Locks::mutator_lock_) {
3945 if (!klass->WasVerificationAttempted()) {
3946 klass->SetSkipAccessChecksFlagOnAllMethods(pointer_size);
3947 klass->SetVerificationAttempted();
3948 }
3949}
3950
Nicolas Geoffray08025182016-10-25 17:20:18 +01003951verifier::MethodVerifier::FailureKind ClassLinker::VerifyClass(
3952 Thread* self, Handle<mirror::Class> klass, verifier::HardFailLogMode log_level) {
Andreas Gampe884f3b82016-03-30 19:52:58 -07003953 {
3954 // TODO: assert that the monitor on the Class is held
3955 ObjectLock<mirror::Class> lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08003956
Andreas Gampe884f3b82016-03-30 19:52:58 -07003957 // Is somebody verifying this now?
3958 mirror::Class::Status old_status = klass->GetStatus();
3959 while (old_status == mirror::Class::kStatusVerifying ||
3960 old_status == mirror::Class::kStatusVerifyingAtRuntime) {
3961 lock.WaitIgnoringInterrupts();
Alex Light06039ba2016-04-04 13:23:14 -07003962 CHECK(klass->IsErroneous() || (klass->GetStatus() > old_status))
David Sehr709b0702016-10-13 09:12:37 -07003963 << "Class '" << klass->PrettyClass()
3964 << "' performed an illegal verification state transition from " << old_status
3965 << " to " << klass->GetStatus();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003966 old_status = klass->GetStatus();
3967 }
jeffhao98eacac2011-09-14 16:11:53 -07003968
Andreas Gampe884f3b82016-03-30 19:52:58 -07003969 // The class might already be erroneous, for example at compile time if we attempted to verify
3970 // this class as a parent to another.
3971 if (klass->IsErroneous()) {
3972 ThrowEarlierClassFailure(klass.Get());
Nicolas Geoffray08025182016-10-25 17:20:18 +01003973 return verifier::MethodVerifier::kHardFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003974 }
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08003975
Andreas Gampe884f3b82016-03-30 19:52:58 -07003976 // Don't attempt to re-verify if already sufficiently verified.
3977 if (klass->IsVerified()) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003978 EnsureSkipAccessChecksMethods(klass, image_pointer_size_);
Nicolas Geoffray08025182016-10-25 17:20:18 +01003979 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003980 }
3981 if (klass->IsCompileTimeVerified() && Runtime::Current()->IsAotCompiler()) {
Nicolas Geoffray08025182016-10-25 17:20:18 +01003982 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003983 }
jeffhao98eacac2011-09-14 16:11:53 -07003984
Andreas Gampe884f3b82016-03-30 19:52:58 -07003985 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
3986 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifying, self);
3987 } else {
3988 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
David Sehr709b0702016-10-13 09:12:37 -07003989 << klass->PrettyClass();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003990 CHECK(!Runtime::Current()->IsAotCompiler());
3991 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifyingAtRuntime, self);
3992 }
3993
3994 // Skip verification if disabled.
3995 if (!Runtime::Current()->IsVerificationEnabled()) {
3996 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Andreas Gampecc1b5352016-12-01 16:58:38 -08003997 EnsureSkipAccessChecksMethods(klass, image_pointer_size_);
Nicolas Geoffray08025182016-10-25 17:20:18 +01003998 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003999 }
Jeff Hao4a200f52014-04-01 14:58:49 -07004000 }
4001
Ian Rogers9ffb0392012-09-10 11:56:50 -07004002 // Verify super class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004003 StackHandleScope<2> hs(self);
Alex Lightf1f10492015-10-07 16:08:36 -07004004 MutableHandle<mirror::Class> supertype(hs.NewHandle(klass->GetSuperClass()));
4005 // If we have a superclass and we get a hard verification failure we can return immediately.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004006 if (supertype != nullptr && !AttemptSupertypeVerification(self, klass, supertype)) {
Alex Lightf1f10492015-10-07 16:08:36 -07004007 CHECK(self->IsExceptionPending()) << "Verification error should be pending.";
Nicolas Geoffray08025182016-10-25 17:20:18 +01004008 return verifier::MethodVerifier::kHardFailure;
Alex Lightf1f10492015-10-07 16:08:36 -07004009 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08004010
Alex Lightf1f10492015-10-07 16:08:36 -07004011 // Verify all default super-interfaces.
4012 //
4013 // (1) Don't bother if the superclass has already had a soft verification failure.
4014 //
4015 // (2) Interfaces shouldn't bother to do this recursive verification because they cannot cause
4016 // recursive initialization by themselves. This is because when an interface is initialized
4017 // directly it must not initialize its superinterfaces. We are allowed to verify regardless
4018 // but choose not to for an optimization. If the interfaces is being verified due to a class
4019 // initialization (which would need all the default interfaces to be verified) the class code
4020 // will trigger the recursive verification anyway.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004021 if ((supertype == nullptr || supertype->IsVerified()) // See (1)
Alex Lightf1f10492015-10-07 16:08:36 -07004022 && !klass->IsInterface()) { // See (2)
4023 int32_t iftable_count = klass->GetIfTableCount();
4024 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
4025 // Loop through all interfaces this class has defined. It doesn't matter the order.
4026 for (int32_t i = 0; i < iftable_count; i++) {
4027 iface.Assign(klass->GetIfTable()->GetInterface(i));
Andreas Gampefa4333d2017-02-14 11:10:34 -08004028 DCHECK(iface != nullptr);
Alex Lightf1f10492015-10-07 16:08:36 -07004029 // We only care if we have default interfaces and can skip if we are already verified...
4030 if (LIKELY(!iface->HasDefaultMethods() || iface->IsVerified())) {
4031 continue;
4032 } else if (UNLIKELY(!AttemptSupertypeVerification(self, klass, iface))) {
4033 // We had a hard failure while verifying this interface. Just return immediately.
4034 CHECK(self->IsExceptionPending()) << "Verification error should be pending.";
Nicolas Geoffray08025182016-10-25 17:20:18 +01004035 return verifier::MethodVerifier::kHardFailure;
Alex Lightf1f10492015-10-07 16:08:36 -07004036 } else if (UNLIKELY(!iface->IsVerified())) {
4037 // We softly failed to verify the iface. Stop checking and clean up.
4038 // Put the iface into the supertype handle so we know what caused us to fail.
4039 supertype.Assign(iface.Get());
4040 break;
Ian Rogers1c5eb702012-02-01 09:18:34 -08004041 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08004042 }
4043 }
4044
Alex Lightf1f10492015-10-07 16:08:36 -07004045 // At this point if verification failed, then supertype is the "first" supertype that failed
4046 // verification (without a specific order). If verification succeeded, then supertype is either
4047 // null or the original superclass of klass and is verified.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004048 DCHECK(supertype == nullptr ||
Alex Lightf1f10492015-10-07 16:08:36 -07004049 supertype.Get() == klass->GetSuperClass() ||
4050 !supertype->IsVerified());
4051
Elliott Hughes634eb2e2012-03-22 16:06:28 -07004052 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07004053 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004054 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004055 bool preverified = VerifyClassUsingOatFile(dex_file, klass.Get(), oat_file_class_status);
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004056 // If the oat file says the class had an error, re-run the verifier. That way we will get a
4057 // precise error message. To ensure a rerun, test:
Vladimir Marko72ab6842017-01-20 19:32:50 +00004058 // mirror::Class::IsErroneous(oat_file_class_status) => !preverified
4059 DCHECK(!mirror::Class::IsErroneous(oat_file_class_status) || !preverified);
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004060
Ian Rogers62d6c772013-02-27 08:32:07 -08004061 std::string error_msg;
Nicolas Geoffray08025182016-10-25 17:20:18 +01004062 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
jeffhaof1e6b7c2012-06-05 18:33:30 -07004063 if (!preverified) {
Andreas Gampe53e32d12015-12-09 21:03:23 -08004064 Runtime* runtime = Runtime::Current();
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004065 verifier_failure = verifier::MethodVerifier::VerifyClass(self,
4066 klass.Get(),
Andreas Gampe53e32d12015-12-09 21:03:23 -08004067 runtime->GetCompilerCallbacks(),
4068 runtime->IsAotCompiler(),
Andreas Gampe7fe30232016-03-25 16:58:00 -07004069 log_level,
Ian Rogers8b2c0b92013-09-19 02:56:49 -07004070 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07004071 }
Andreas Gampe884f3b82016-03-30 19:52:58 -07004072
4073 // Verification is done, grab the lock again.
4074 ObjectLock<mirror::Class> lock(self, klass);
4075
jeffhaof1e6b7c2012-06-05 18:33:30 -07004076 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07004077 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
David Sehr709b0702016-10-13 09:12:37 -07004078 VLOG(class_linker) << "Soft verification failure in class "
4079 << klass->PrettyDescriptor()
4080 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
4081 << " because: " << error_msg;
Ian Rogers529781d2012-07-23 17:24:29 -07004082 }
Ian Rogers1f539342012-10-03 21:09:42 -07004083 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004084 // Make sure all classes referenced by catch blocks are resolved.
Alex Light5a559862016-01-29 12:24:48 -08004085 ResolveClassExceptionHandlerTypes(klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004086 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Alex Lightf1f10492015-10-07 16:08:36 -07004087 // Even though there were no verifier failures we need to respect whether the super-class and
4088 // super-default-interfaces were verified or requiring runtime reverification.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004089 if (supertype == nullptr || supertype->IsVerified()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004090 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004091 } else {
Alex Lightf1f10492015-10-07 16:08:36 -07004092 CHECK_EQ(supertype->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004093 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
Alex Lightf1f10492015-10-07 16:08:36 -07004094 // Pretend a soft failure occurred so that we don't consider the class verified below.
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004095 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004096 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004097 } else {
4098 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
4099 // Soft failures at compile time should be retried at runtime. Soft
4100 // failures at runtime will be handled by slow paths in the generated
4101 // code. Set status accordingly.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004102 if (Runtime::Current()->IsAotCompiler()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004103 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004104 } else {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004105 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Igor Murashkindf707e42016-02-02 16:56:50 -08004106 // As this is a fake verified status, make sure the methods are _not_ marked
4107 // kAccSkipAccessChecks later.
4108 klass->SetVerificationAttempted();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004109 }
4110 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07004111 } else {
David Sehr709b0702016-10-13 09:12:37 -07004112 VLOG(verifier) << "Verification failed on class " << klass->PrettyDescriptor()
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004113 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
4114 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004115 self->AssertNoPendingException();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004116 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
Vladimir Marko72ab6842017-01-20 19:32:50 +00004117 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07004118 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004119 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004120 // Class is verified so we don't need to do any access check on its methods.
Igor Murashkindf707e42016-02-02 16:56:50 -08004121 // Let the interpreter know it by setting the kAccSkipAccessChecks flag onto each
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004122 // method.
4123 // Note: we're going here during compilation and at runtime. When we set the
Igor Murashkindf707e42016-02-02 16:56:50 -08004124 // kAccSkipAccessChecks flag when compiling image classes, the flag is recorded
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004125 // in the image and is set when loading the image.
Igor Murashkindf707e42016-02-02 16:56:50 -08004126
4127 if (UNLIKELY(Runtime::Current()->IsVerificationSoftFail())) {
4128 // Never skip access checks if the verification soft fail is forced.
4129 // Mark the class as having a verification attempt to avoid re-running the verifier.
4130 klass->SetVerificationAttempted();
4131 } else {
Andreas Gampecc1b5352016-12-01 16:58:38 -08004132 EnsureSkipAccessChecksMethods(klass, image_pointer_size_);
Igor Murashkindf707e42016-02-02 16:56:50 -08004133 }
Andreas Gampe48498592014-09-10 19:48:05 -07004134 }
Nicolas Geoffray08025182016-10-25 17:20:18 +01004135 return verifier_failure;
Andreas Gampe48498592014-09-10 19:48:05 -07004136}
4137
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004138bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004139 ObjPtr<mirror::Class> klass,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004140 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004141 // If we're compiling, we can only verify the class using the oat file if
4142 // we are not compiling the image or if the class we're verifying is not part of
4143 // the app. In other words, we will only check for preverification of bootclasspath
4144 // classes.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004145 if (Runtime::Current()->IsAotCompiler()) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004146 // Are we compiling the bootclasspath?
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07004147 if (Runtime::Current()->GetCompilerCallbacks()->IsBootImage()) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004148 return false;
4149 }
4150 // We are compiling an app (not the image).
4151
4152 // Is this an app class? (I.e. not a bootclasspath class)
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004153 if (klass->GetClassLoader() != nullptr) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004154 return false;
4155 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004156 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004157
Richard Uhler07b3c232015-03-31 15:57:54 -07004158 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004159 // In case we run without an image there won't be a backing oat file.
Mathieu Chartier1b868492016-11-16 16:22:37 -08004160 if (oat_dex_file == nullptr || oat_dex_file->GetOatFile() == nullptr) {
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07004161 return false;
4162 }
4163
Andreas Gampe76bd8802014-12-10 16:43:58 -08004164 // We may be running with a preopted oat file but without image. In this case,
Igor Murashkindf707e42016-02-02 16:56:50 -08004165 // we don't skip verification of skip_access_checks classes to ensure we initialize
Andreas Gampe76bd8802014-12-10 16:43:58 -08004166 // dex caches with all types resolved during verification.
4167 // We need to trust image classes, as these might be coming out of a pre-opted, quickened boot
4168 // image (that we just failed loading), and the verifier can't be run on quickened opcodes when
4169 // the runtime isn't started. On the other hand, app classes can be re-verified even if they are
4170 // already pre-opted, as then the runtime is started.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004171 if (!Runtime::Current()->IsAotCompiler() &&
Jeff Haodcdc85b2015-12-04 14:06:18 -08004172 !Runtime::Current()->GetHeap()->HasBootImageSpace() &&
Andreas Gampe76bd8802014-12-10 16:43:58 -08004173 klass->GetClassLoader() != nullptr) {
4174 return false;
4175 }
4176
Ian Rogers8b2c0b92013-09-19 02:56:49 -07004177 uint16_t class_def_index = klass->GetDexClassDefIndex();
Vladimir Markod3c5beb2014-04-11 16:32:51 +01004178 oat_file_class_status = oat_dex_file->GetOatClass(class_def_index).GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004179 if (oat_file_class_status == mirror::Class::kStatusVerified ||
4180 oat_file_class_status == mirror::Class::kStatusInitialized) {
Mathieu Chartiera079e3a2016-03-16 19:08:31 -07004181 return true;
4182 }
4183 // If we only verified a subset of the classes at compile time, we can end up with classes that
4184 // were resolved by the verifier.
4185 if (oat_file_class_status == mirror::Class::kStatusResolved) {
4186 return false;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004187 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004188 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07004189 // Compile time verification failed with a soft error. Compile time verification can fail
4190 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08004191 // class ... {
4192 // Foo x;
4193 // .... () {
4194 // if (...) {
4195 // v1 gets assigned a type of resolved class Foo
4196 // } else {
4197 // v1 gets assigned a type of unresolved class Bar
4198 // }
4199 // iput x = v1
4200 // } }
4201 // when we merge v1 following the if-the-else it results in Conflict
4202 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
4203 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
4204 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
4205 // at compile time).
4206 return false;
4207 }
Vladimir Marko72ab6842017-01-20 19:32:50 +00004208 if (mirror::Class::IsErroneous(oat_file_class_status)) {
jeffhao1ac29442012-03-26 11:37:32 -07004209 // Compile time verification failed with a hard error. This is caused by invalid instructions
4210 // in the class. These errors are unrecoverable.
4211 return false;
4212 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004213 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08004214 // Status is uninitialized if we couldn't determine the status at compile time, for example,
4215 // not loading the class.
4216 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
4217 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004218 return false;
4219 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07004220 std::string temp;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07004221 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
David Sehr709b0702016-10-13 09:12:37 -07004222 << " " << dex_file.GetLocation() << " " << klass->PrettyClass() << " "
Ian Rogers1ff3c982014-08-12 02:30:58 -07004223 << klass->GetDescriptor(&temp);
Ian Rogerse0a02da2014-12-02 14:10:53 -08004224 UNREACHABLE();
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004225}
4226
Alex Light5a559862016-01-29 12:24:48 -08004227void ClassLinker::ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass) {
Alex Light51a64d52015-12-17 13:55:59 -08004228 for (ArtMethod& method : klass->GetMethods(image_pointer_size_)) {
Alex Light5a559862016-01-29 12:24:48 -08004229 ResolveMethodExceptionHandlerTypes(&method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004230 }
4231}
4232
Alex Light5a559862016-01-29 12:24:48 -08004233void ClassLinker::ResolveMethodExceptionHandlerTypes(ArtMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004234 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
Alex Light5a559862016-01-29 12:24:48 -08004235 const DexFile::CodeItem* code_item =
4236 method->GetDexFile()->GetCodeItem(method->GetCodeItemOffset());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004237 if (code_item == nullptr) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004238 return; // native or abstract method
4239 }
4240 if (code_item->tries_size_ == 0) {
4241 return; // nothing to process
4242 }
Ian Rogers13735952014-10-08 12:43:28 -07004243 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004244 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004245 for (uint32_t idx = 0; idx < handlers_size; idx++) {
4246 CatchHandlerIterator iterator(handlers_ptr);
4247 for (; iterator.HasNext(); iterator.Next()) {
4248 // Ensure exception types are resolved so that they don't need resolution to be delivered,
4249 // unresolved exception types will be ignored by exception delivery
Andreas Gampea5b09a62016-11-17 15:21:22 -08004250 if (iterator.GetHandlerTypeIndex().IsValid()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004251 ObjPtr<mirror::Class> exception_type = ResolveType(iterator.GetHandlerTypeIndex(), method);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004252 if (exception_type == nullptr) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004253 DCHECK(Thread::Current()->IsExceptionPending());
4254 Thread::Current()->ClearException();
4255 }
4256 }
4257 }
4258 handlers_ptr = iterator.EndDataPointer();
4259 }
4260}
4261
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004262mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa,
4263 jstring name,
4264 jobjectArray interfaces,
4265 jobject loader,
4266 jobjectArray methods,
4267 jobjectArray throws) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004268 Thread* self = soa.Self();
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004269 StackHandleScope<10> hs(self);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07004270 MutableHandle<mirror::Class> klass(hs.NewHandle(
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004271 AllocClass(self, GetClassRoot(kJavaLangClass), sizeof(mirror::Class))));
Andreas Gampefa4333d2017-02-14 11:10:34 -08004272 if (klass == nullptr) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004273 CHECK(self->IsExceptionPending()); // OOME.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004274 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07004275 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004276 DCHECK(klass->GetClass() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004277 klass->SetObjectSize(sizeof(mirror::Proxy));
Igor Murashkindf707e42016-02-02 16:56:50 -08004278 // Set the class access flags incl. VerificationAttempted, so we do not try to set the flag on
4279 // the methods.
4280 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal | kAccVerificationAttempted);
Mathieu Chartier1a5337f2016-10-13 13:48:23 -07004281 klass->SetClassLoader(soa.Decode<mirror::ClassLoader>(loader));
Ian Rogersc2b44472011-12-14 21:17:17 -08004282 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Mathieu Chartier1a5337f2016-10-13 13:48:23 -07004283 klass->SetName(soa.Decode<mirror::String>(name));
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004284 klass->SetDexCache(GetClassRoot(kJavaLangReflectProxy)->GetDexCache());
Mathieu Chartier6beced42016-11-15 15:51:31 -08004285 // Object has an empty iftable, copy it for that reason.
4286 klass->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004287 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, self);
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004288 std::string descriptor(GetDescriptorForProxy(klass.Get()));
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07004289 const size_t hash = ComputeModifiedUtf8Hash(descriptor.c_str());
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004290
Mathieu Chartierd57d4542015-10-14 10:55:30 -07004291 // Needs to be before we insert the class so that the allocator field is set.
4292 LinearAlloc* const allocator = GetOrCreateAllocatorForClassLoader(klass->GetClassLoader());
4293
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004294 // Insert the class before loading the fields as the field roots
4295 // (ArtField::declaring_class_) are only visited from the class
4296 // table. There can't be any suspend points between inserting the
4297 // class and setting the field arrays below.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004298 ObjPtr<mirror::Class> existing = InsertClass(descriptor.c_str(), klass.Get(), hash);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004299 CHECK(existing == nullptr);
Ian Rogersc2b44472011-12-14 21:17:17 -08004300
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004301 // Instance fields are inherited, but we add a couple of static fields...
Mathieu Chartierc7853442015-03-27 14:35:38 -07004302 const size_t num_fields = 2;
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07004303 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self, allocator, num_fields);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004304 klass->SetSFieldsPtr(sfields);
Mathieu Chartierc7853442015-03-27 14:35:38 -07004305
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004306 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
4307 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004308 ArtField& interfaces_sfield = sfields->At(0);
4309 interfaces_sfield.SetDexFieldIndex(0);
4310 interfaces_sfield.SetDeclaringClass(klass.Get());
4311 interfaces_sfield.SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Mathieu Chartierc7853442015-03-27 14:35:38 -07004312
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004313 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004314 ArtField& throws_sfield = sfields->At(1);
4315 throws_sfield.SetDexFieldIndex(1);
4316 throws_sfield.SetDeclaringClass(klass.Get());
4317 throws_sfield.SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04004318
Ian Rogers466bb252011-10-14 03:29:56 -07004319 // Proxies have 1 direct method, the constructor
Alex Lighte64300b2015-12-15 15:02:47 -08004320 const size_t num_direct_methods = 1;
Jesse Wilson95caa792011-10-12 18:14:17 -04004321
Alex Lighte64300b2015-12-15 15:02:47 -08004322 // They have as many virtual methods as the array
Mathieu Chartier0795f232016-09-27 18:43:30 -07004323 auto h_methods = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Method>>(methods));
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004324 DCHECK_EQ(h_methods->GetClass(), mirror::Method::ArrayClass())
David Sehr709b0702016-10-13 09:12:37 -07004325 << mirror::Class::PrettyClass(h_methods->GetClass());
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004326 const size_t num_virtual_methods = h_methods->GetLength();
Alex Lighte64300b2015-12-15 15:02:47 -08004327
4328 // Create the methods array.
4329 LengthPrefixedArray<ArtMethod>* proxy_class_methods = AllocArtMethodArray(
4330 self, allocator, num_direct_methods + num_virtual_methods);
Mathieu Chartiere401d142015-04-22 13:56:20 -07004331 // Currently AllocArtMethodArray cannot return null, but the OOM logic is left there in case we
4332 // want to throw OOM in the future.
Alex Lighte64300b2015-12-15 15:02:47 -08004333 if (UNLIKELY(proxy_class_methods == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004334 self->AssertPendingOOMException();
4335 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07004336 }
Alex Lighte64300b2015-12-15 15:02:47 -08004337 klass->SetMethodsPtr(proxy_class_methods, num_direct_methods, num_virtual_methods);
4338
4339 // Create the single direct method.
4340 CreateProxyConstructor(klass, klass->GetDirectMethodUnchecked(0, image_pointer_size_));
4341
4342 // Create virtual method using specified prototypes.
4343 // TODO These should really use the iterators.
Jesse Wilson95caa792011-10-12 18:14:17 -04004344 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004345 auto* virtual_method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
4346 auto* prototype = h_methods->Get(i)->GetArtMethod();
4347 CreateProxyMethod(klass, prototype, virtual_method);
4348 DCHECK(virtual_method->GetDeclaringClass() != nullptr);
4349 DCHECK(prototype->GetDeclaringClass() != nullptr);
Jesse Wilson95caa792011-10-12 18:14:17 -04004350 }
Ian Rogersc2b44472011-12-14 21:17:17 -08004351
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004352 // The super class is java.lang.reflect.Proxy
4353 klass->SetSuperClass(GetClassRoot(kJavaLangReflectProxy));
4354 // Now effectively in the loaded state.
4355 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, self);
Ian Rogers62d6c772013-02-27 08:32:07 -08004356 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08004357
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004358 MutableHandle<mirror::Class> new_class = hs.NewHandle<mirror::Class>(nullptr);
Ian Rogersc8982582012-09-07 16:53:25 -07004359 {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004360 // Must hold lock on object when resolved.
4361 ObjectLock<mirror::Class> resolution_lock(self, klass);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004362 // Link the fields and virtual methods, creating vtable and iftables.
4363 // The new class will replace the old one in the class table.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004364 Handle<mirror::ObjectArray<mirror::Class>> h_interfaces(
Mathieu Chartier0795f232016-09-27 18:43:30 -07004365 hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces)));
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004366 if (!LinkClass(self, descriptor.c_str(), klass, h_interfaces, &new_class)) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00004367 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004368 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004369 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004370 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004371 CHECK(klass->IsRetired());
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004372 CHECK_NE(klass.Get(), new_class.Get());
4373 klass.Assign(new_class.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004374
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004375 CHECK_EQ(interfaces_sfield.GetDeclaringClass(), klass.Get());
Mathieu Chartier0795f232016-09-27 18:43:30 -07004376 interfaces_sfield.SetObject<false>(
4377 klass.Get(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004378 soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces));
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004379 CHECK_EQ(throws_sfield.GetDeclaringClass(), klass.Get());
4380 throws_sfield.SetObject<false>(
Mathieu Chartier0795f232016-09-27 18:43:30 -07004381 klass.Get(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004382 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>>(throws));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004383
4384 {
4385 // Lock on klass is released. Lock new class object.
4386 ObjectLock<mirror::Class> initialization_lock(self, klass);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004387 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
Ian Rogersc8982582012-09-07 16:53:25 -07004388 }
Ian Rogersc2b44472011-12-14 21:17:17 -08004389
4390 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07004391 if (kIsDebugBuild) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004392 CHECK(klass->GetIFieldsPtr() == nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07004393 CheckProxyConstructor(klass->GetDirectMethod(0, image_pointer_size_));
4394
Ian Rogersc2b44472011-12-14 21:17:17 -08004395 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004396 auto* virtual_method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
4397 auto* prototype = h_methods->Get(i++)->GetArtMethod();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004398 CheckProxyMethod(virtual_method, prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08004399 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004400
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004401 StackHandleScope<1> hs2(self);
Mathieu Chartier0795f232016-09-27 18:43:30 -07004402 Handle<mirror::String> decoded_name = hs2.NewHandle(soa.Decode<mirror::String>(name));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004403 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
Mathieu Chartier590fee92013-09-13 13:46:47 -07004404 decoded_name->ToModifiedUtf8().c_str()));
David Sehr709b0702016-10-13 09:12:37 -07004405 CHECK_EQ(ArtField::PrettyField(klass->GetStaticField(0)), interfaces_field_name);
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004406
4407 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
Mathieu Chartier590fee92013-09-13 13:46:47 -07004408 decoded_name->ToModifiedUtf8().c_str()));
David Sehr709b0702016-10-13 09:12:37 -07004409 CHECK_EQ(ArtField::PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08004410
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004411 CHECK_EQ(klass.Get()->GetInterfaces(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004412 soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces));
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004413 CHECK_EQ(klass.Get()->GetThrows(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004414 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>>(throws));
Ian Rogersc2b44472011-12-14 21:17:17 -08004415 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004416 return klass.Get();
Jesse Wilson95caa792011-10-12 18:14:17 -04004417}
4418
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004419std::string ClassLinker::GetDescriptorForProxy(ObjPtr<mirror::Class> proxy_class) {
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004420 DCHECK(proxy_class->IsProxyClass());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004421 ObjPtr<mirror::String> name = proxy_class->GetName();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004422 DCHECK(name != nullptr);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004423 return DotToDescriptor(name->ToModifiedUtf8().c_str());
4424}
4425
Mathieu Chartiere401d142015-04-22 13:56:20 -07004426void ClassLinker::CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out) {
4427 // Create constructor for Proxy that must initialize the method.
Przemyslaw Szczepaniakf11cd292016-08-17 17:46:38 +01004428 CHECK_EQ(GetClassRoot(kJavaLangReflectProxy)->NumDirectMethods(), 23u);
4429
Mathieu Chartiere401d142015-04-22 13:56:20 -07004430 ArtMethod* proxy_constructor = GetClassRoot(kJavaLangReflectProxy)->GetDirectMethodUnchecked(
Przemyslaw Szczepaniakf11cd292016-08-17 17:46:38 +01004431 8, image_pointer_size_);
Igor Murashkine3d4ff52016-02-02 10:46:42 -08004432 DCHECK_EQ(std::string(proxy_constructor->GetName()), "<init>");
Sebastien Hertzae94e352014-08-27 15:32:56 +02004433 // Ensure constructor is in dex cache so that we can use the dex cache to look up the overridden
4434 // constructor method.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004435 GetClassRoot(kJavaLangReflectProxy)->GetDexCache()->SetResolvedMethod(
Mathieu Chartiere401d142015-04-22 13:56:20 -07004436 proxy_constructor->GetDexMethodIndex(), proxy_constructor, image_pointer_size_);
Jeff Haodb8a6642014-08-14 17:18:52 -07004437 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
4438 // code_ too)
Mathieu Chartiere401d142015-04-22 13:56:20 -07004439 DCHECK(out != nullptr);
4440 out->CopyFrom(proxy_constructor, image_pointer_size_);
Ian Rogers466bb252011-10-14 03:29:56 -07004441 // Make this constructor public and fix the class to be our Proxy version
Mathieu Chartiere401d142015-04-22 13:56:20 -07004442 out->SetAccessFlags((out->GetAccessFlags() & ~kAccProtected) | kAccPublic);
4443 out->SetDeclaringClass(klass.Get());
Ian Rogersc2b44472011-12-14 21:17:17 -08004444}
4445
Mathieu Chartiere401d142015-04-22 13:56:20 -07004446void ClassLinker::CheckProxyConstructor(ArtMethod* constructor) const {
Ian Rogers466bb252011-10-14 03:29:56 -07004447 CHECK(constructor->IsConstructor());
Mathieu Chartiere401d142015-04-22 13:56:20 -07004448 auto* np = constructor->GetInterfaceMethodIfProxy(image_pointer_size_);
4449 CHECK_STREQ(np->GetName(), "<init>");
4450 CHECK_STREQ(np->GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V");
Ian Rogers466bb252011-10-14 03:29:56 -07004451 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04004452}
4453
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004454void ClassLinker::CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004455 ArtMethod* out) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004456 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
4457 // prototype method
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004458 auto* dex_cache = prototype->GetDeclaringClass()->GetDexCache();
4459 // Avoid dirtying the dex cache unless we need to.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004460 if (dex_cache->GetResolvedMethod(prototype->GetDexMethodIndex(), image_pointer_size_) !=
4461 prototype) {
4462 dex_cache->SetResolvedMethod(
4463 prototype->GetDexMethodIndex(), prototype, image_pointer_size_);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004464 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004465 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07004466 // as necessary
Mathieu Chartiere401d142015-04-22 13:56:20 -07004467 DCHECK(out != nullptr);
4468 out->CopyFrom(prototype, image_pointer_size_);
Ian Rogers466bb252011-10-14 03:29:56 -07004469
Alex Lighte9dd04f2016-03-16 16:09:45 -07004470 // Set class to be the concrete proxy class.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004471 out->SetDeclaringClass(klass.Get());
Alex Lighte9dd04f2016-03-16 16:09:45 -07004472 // Clear the abstract, default and conflict flags to ensure that defaults aren't picked in
4473 // preference to the invocation handler.
4474 const uint32_t kRemoveFlags = kAccAbstract | kAccDefault | kAccDefaultConflict;
4475 // Make the method final.
4476 const uint32_t kAddFlags = kAccFinal;
4477 out->SetAccessFlags((out->GetAccessFlags() & ~kRemoveFlags) | kAddFlags);
4478
4479 // Clear the dex_code_item_offset_. It needs to be 0 since proxy methods have no CodeItems but the
4480 // method they copy might (if it's a default method).
4481 out->SetCodeItemOffset(0);
Jesse Wilson95caa792011-10-12 18:14:17 -04004482
Ian Rogers466bb252011-10-14 03:29:56 -07004483 // At runtime the method looks like a reference and argument saving method, clone the code
4484 // related parameters from this method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004485 out->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler());
Ian Rogersc2b44472011-12-14 21:17:17 -08004486}
Jesse Wilson95caa792011-10-12 18:14:17 -04004487
Mathieu Chartiere401d142015-04-22 13:56:20 -07004488void ClassLinker::CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const {
Ian Rogers466bb252011-10-14 03:29:56 -07004489 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004490 CHECK(!prototype->IsFinal());
4491 CHECK(method->IsFinal());
Alex Light9139e002015-10-09 15:59:48 -07004492 CHECK(method->IsInvokable());
Ian Rogers19846512012-02-24 11:42:47 -08004493
4494 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
4495 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
Vladimir Marko05792b92015-08-03 11:56:49 +01004496 CHECK(prototype->HasSameDexCacheResolvedMethods(method, image_pointer_size_));
Mathieu Chartiere401d142015-04-22 13:56:20 -07004497 auto* np = method->GetInterfaceMethodIfProxy(image_pointer_size_);
4498 CHECK_EQ(prototype->GetDeclaringClass()->GetDexCache(), np->GetDexCache());
Ian Rogers19846512012-02-24 11:42:47 -08004499 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
4500
Mathieu Chartiere401d142015-04-22 13:56:20 -07004501 CHECK_STREQ(np->GetName(), prototype->GetName());
4502 CHECK_STREQ(np->GetShorty(), prototype->GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07004503 // More complex sanity - via dex cache
Vladimir Marko942fd312017-01-16 20:52:19 +00004504 CHECK_EQ(np->GetReturnType(true /* resolve */), prototype->GetReturnType(true /* resolve */));
Jesse Wilson95caa792011-10-12 18:14:17 -04004505}
4506
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004507bool ClassLinker::CanWeInitializeClass(ObjPtr<mirror::Class> klass, bool can_init_statics,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004508 bool can_init_parents) {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08004509 if (can_init_statics && can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004510 return true;
4511 }
4512 if (!can_init_statics) {
4513 // Check if there's a class initializer.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004514 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004515 if (clinit != nullptr) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004516 return false;
4517 }
4518 // Check if there are encoded static values needing initialization.
4519 if (klass->NumStaticFields() != 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004520 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004521 DCHECK(dex_class_def != nullptr);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004522 if (dex_class_def->static_values_off_ != 0) {
4523 return false;
4524 }
4525 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004526 // If we are a class we need to initialize all interfaces with default methods when we are
4527 // initialized. Check all of them.
4528 if (!klass->IsInterface()) {
4529 size_t num_interfaces = klass->GetIfTableCount();
4530 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004531 ObjPtr<mirror::Class> iface = klass->GetIfTable()->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07004532 if (iface->HasDefaultMethods() &&
4533 !CanWeInitializeClass(iface, can_init_statics, can_init_parents)) {
4534 return false;
4535 }
4536 }
4537 }
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004538 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07004539 if (klass->IsInterface() || !klass->HasSuperClass()) {
4540 return true;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004541 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004542 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Mathieu Chartiere401d142015-04-22 13:56:20 -07004543 if (!can_init_parents && !super_class->IsInitialized()) {
4544 return false;
4545 }
4546 return CanWeInitializeClass(super_class, can_init_statics, can_init_parents);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004547}
4548
Vladimir Markobfb80d22017-02-14 14:08:12 +00004549std::string DescribeSpace(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) {
4550 std::ostringstream oss;
4551 gc::Heap* heap = Runtime::Current()->GetHeap();
4552 gc::space::ContinuousSpace* cs = heap->FindContinuousSpaceFromAddress(klass.Ptr());
4553 if (cs != nullptr) {
4554 if (cs->IsImageSpace()) {
4555 oss << "image/" << cs->GetName() << "/" << cs->AsImageSpace()->GetImageFilename();
4556 } else {
4557 oss << "continuous/" << cs->GetName();
4558 }
4559 } else {
4560 gc::space::DiscontinuousSpace* ds =
4561 heap->FindDiscontinuousSpaceFromObject(klass, /* fail_ok */ true);
4562 if (ds != nullptr) {
4563 oss << "discontinuous/" << ds->GetName();
4564 } else {
4565 oss << "invalid";
4566 }
4567 }
4568 return oss.str();
4569}
4570
4571std::string DescribeLoaders(ObjPtr<mirror::Class> klass, const char* iface_descriptor)
4572 REQUIRES_SHARED(Locks::mutator_lock_) {
4573 std::ostringstream oss;
4574 uint32_t hash = ComputeModifiedUtf8Hash(iface_descriptor);
4575 ScopedObjectAccessUnchecked soa(Thread::Current());
4576 ObjPtr<mirror::Class> path_class_loader =
4577 soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader);
4578 ObjPtr<mirror::Class> dex_class_loader =
4579 soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DexClassLoader);
4580
4581 // Print the class loader chain.
4582 bool found_iface;
4583 const char* loader_separator = "";
4584 for (ObjPtr<mirror::ClassLoader> loader = klass->GetClassLoader();
4585 loader != nullptr;
4586 loader = loader->GetParent()) {
4587 oss << loader_separator << loader->GetClass()->PrettyDescriptor();
4588 loader_separator = ";";
4589 // If we didn't find the interface yet, try to find it in the current class loader.
4590 if (!found_iface) {
4591 ClassTable* table = Runtime::Current()->GetClassLinker()->ClassTableForClassLoader(loader);
4592 ObjPtr<mirror::Class> iface =
4593 (table != nullptr) ? table->Lookup(iface_descriptor, hash) : nullptr;
4594 if (iface != nullptr) {
4595 found_iface = true;
4596 oss << "[hit:" << DescribeSpace(iface) << "]";
4597 }
4598 }
4599
4600 // For PathClassLoader or DexClassLoader also dump the dex file locations.
4601 if (loader->GetClass() == path_class_loader || loader->GetClass() == dex_class_loader) {
4602 ArtField* const cookie_field =
4603 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
4604 ArtField* const dex_file_field =
4605 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
4606 ObjPtr<mirror::Object> dex_path_list =
4607 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList)->
4608 GetObject(loader);
4609 if (dex_path_list != nullptr && dex_file_field != nullptr && cookie_field != nullptr) {
4610 ObjPtr<mirror::Object> dex_elements_obj =
4611 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements)->
4612 GetObject(dex_path_list);
4613 if (dex_elements_obj != nullptr) {
4614 ObjPtr<mirror::ObjectArray<mirror::Object>> dex_elements =
4615 dex_elements_obj->AsObjectArray<mirror::Object>();
4616 oss << "(";
4617 const char* path_separator = "";
4618 for (int32_t i = 0; i != dex_elements->GetLength(); ++i) {
4619 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
4620 ObjPtr<mirror::Object> dex_file =
4621 (element != nullptr) ? dex_file_field->GetObject(element) : nullptr;
4622 ObjPtr<mirror::LongArray> long_array =
4623 (dex_file != nullptr) ? cookie_field->GetObject(dex_file)->AsLongArray() : nullptr;
4624 if (long_array != nullptr) {
4625 int32_t long_array_size = long_array->GetLength();
4626 // First element is the oat file.
4627 for (int32_t j = kDexFileIndexStart; j < long_array_size; ++j) {
4628 const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(
4629 static_cast<uintptr_t>(long_array->GetWithoutChecks(j)));
4630 oss << path_separator << cp_dex_file->GetLocation();
4631 path_separator = ":";
4632 }
4633 }
4634 }
4635 oss << ")";
4636 }
4637 }
4638 }
4639 }
4640
4641 // Do a paranoid check that the `klass` itself is in the class table.
4642 ClassTable* table =
4643 Runtime::Current()->GetClassLinker()->ClassTableForClassLoader(klass->GetClassLoader());
4644 ObjPtr<mirror::Class> k = (table != nullptr) ? table->LookupByDescriptor(klass) : nullptr;
4645 if (k != klass) {
4646 oss << "{FAIL:" << k.Ptr() << "!=" << klass.Ptr() << "}";
4647 }
4648 return oss.str();
4649}
4650
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004651bool ClassLinker::InitializeClass(Thread* self, Handle<mirror::Class> klass,
4652 bool can_init_statics, bool can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004653 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
4654
4655 // Are we already initialized and therefore done?
4656 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
4657 // an initialized class will never change its state.
4658 if (klass->IsInitialized()) {
4659 return true;
4660 }
4661
4662 // Fast fail if initialization requires a full runtime. Not part of the JLS.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004663 if (!CanWeInitializeClass(klass.Get(), can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004664 return false;
4665 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004666
Ian Rogers7b078e82014-09-10 14:44:24 -07004667 self->AllowThreadSuspension();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004668 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004669 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004670 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004671
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004672 // Re-check under the lock in case another thread initialized ahead of us.
4673 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004674 return true;
4675 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004676
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004677 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07004678 if (klass->IsErroneous()) {
Andreas Gampecb086952015-11-02 16:20:00 -08004679 ThrowEarlierClassFailure(klass.Get(), true);
Brian Carlstromb23eab12014-10-08 17:55:21 -07004680 VlogClassInitializationFailure(klass);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004681 return false;
4682 }
4683
Vladimir Marko72ab6842017-01-20 19:32:50 +00004684 CHECK(klass->IsResolved() && !klass->IsErroneousResolved())
4685 << klass->PrettyClass() << ": state=" << klass->GetStatus();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004686
4687 if (!klass->IsVerified()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004688 VerifyClass(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004689 if (!klass->IsVerified()) {
4690 // We failed to verify, expect either the klass to be erroneous or verification failed at
4691 // compile time.
4692 if (klass->IsErroneous()) {
Andreas Gampefc49fa02016-04-21 12:21:55 -07004693 // The class is erroneous. This may be a verifier error, or another thread attempted
4694 // verification and/or initialization and failed. We can distinguish those cases by
4695 // whether an exception is already pending.
4696 if (self->IsExceptionPending()) {
4697 // Check that it's a VerifyError.
4698 DCHECK_EQ("java.lang.Class<java.lang.VerifyError>",
David Sehr709b0702016-10-13 09:12:37 -07004699 mirror::Class::PrettyClass(self->GetException()->GetClass()));
Andreas Gampefc49fa02016-04-21 12:21:55 -07004700 } else {
4701 // Check that another thread attempted initialization.
4702 DCHECK_NE(0, klass->GetClinitThreadId());
4703 DCHECK_NE(self->GetTid(), klass->GetClinitThreadId());
4704 // Need to rethrow the previous failure now.
4705 ThrowEarlierClassFailure(klass.Get(), true);
4706 }
Brian Carlstromb23eab12014-10-08 17:55:21 -07004707 VlogClassInitializationFailure(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004708 } else {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004709 CHECK(Runtime::Current()->IsAotCompiler());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004710 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07004711 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004712 return false;
Mathieu Chartier524507a2014-08-27 15:28:28 -07004713 } else {
4714 self->AssertNoPendingException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004715 }
Andreas Gampefc49fa02016-04-21 12:21:55 -07004716
4717 // A separate thread could have moved us all the way to initialized. A "simple" example
4718 // involves a subclass of the current class being initialized at the same time (which
4719 // will implicitly initialize the superclass, if scheduled that way). b/28254258
Vladimir Marko72ab6842017-01-20 19:32:50 +00004720 DCHECK(!klass->IsErroneous()) << klass->GetStatus();
Andreas Gampefc49fa02016-04-21 12:21:55 -07004721 if (klass->IsInitialized()) {
4722 return true;
4723 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004724 }
4725
Brian Carlstromd1422f82011-09-28 11:37:09 -07004726 // If the class is kStatusInitializing, either this thread is
4727 // initializing higher up the stack or another thread has beat us
4728 // to initializing and we need to wait. Either way, this
4729 // invocation of InitializeClass will not be responsible for
4730 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004731 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Mathieu Chartier524507a2014-08-27 15:28:28 -07004732 // Could have got an exception during verification.
4733 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004734 VlogClassInitializationFailure(klass);
Mathieu Chartier524507a2014-08-27 15:28:28 -07004735 return false;
4736 }
Elliott Hughes005ab2e2011-09-11 17:15:31 -07004737 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07004738 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004739 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004740 return true;
4741 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07004742 // No. That's fine. Wait for another thread to finish initializing.
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004743 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004744 }
4745
4746 if (!ValidateSuperClassDescriptors(klass)) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00004747 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004748 return false;
4749 }
Ian Rogers7b078e82014-09-10 14:44:24 -07004750 self->AllowThreadSuspension();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004751
David Sehr709b0702016-10-13 09:12:37 -07004752 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << klass->PrettyClass()
Andreas Gampe9510ccd2016-04-20 09:55:25 -07004753 << " self.tid=" << self->GetTid() << " clinit.tid=" << klass->GetClinitThreadId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004754
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004755 // From here out other threads may observe that we're initializing and so changes of state
4756 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07004757 klass->SetClinitThreadId(self->GetTid());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004758 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004759
4760 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004761 }
4762
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004763 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004764 if (!klass->IsInterface() && klass->HasSuperClass()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004765 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004766 if (!super_class->IsInitialized()) {
4767 CHECK(!super_class->IsInterface());
4768 CHECK(can_init_parents);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004769 StackHandleScope<1> hs(self);
4770 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class));
Ian Rogers7b078e82014-09-10 14:44:24 -07004771 bool super_initialized = InitializeClass(self, handle_scope_super, can_init_statics, true);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004772 if (!super_initialized) {
4773 // The super class was verified ahead of entering initializing, we should only be here if
4774 // the super class became erroneous due to initialization.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004775 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending())
Brian Carlstromf3632832014-05-20 15:36:53 -07004776 << "Super class initialization failed for "
David Sehr709b0702016-10-13 09:12:37 -07004777 << handle_scope_super->PrettyDescriptor()
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004778 << " that has unexpected status " << handle_scope_super->GetStatus()
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004779 << "\nPending exception:\n"
Nicolas Geoffray14691c52015-03-05 10:40:17 +00004780 << (self->GetException() != nullptr ? self->GetException()->Dump() : "");
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004781 ObjectLock<mirror::Class> lock(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004782 // Initialization failed because the super-class is erroneous.
Vladimir Marko72ab6842017-01-20 19:32:50 +00004783 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004784 return false;
4785 }
Ian Rogers1bddec32012-02-04 12:27:34 -08004786 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004787 }
4788
Alex Lighteb7c1442015-08-31 13:17:42 -07004789 if (!klass->IsInterface()) {
4790 // Initialize interfaces with default methods for the JLS.
4791 size_t num_direct_interfaces = klass->NumDirectInterfaces();
Alex Light56a40f52015-10-14 11:07:41 -07004792 // Only setup the (expensive) handle scope if we actually need to.
4793 if (UNLIKELY(num_direct_interfaces > 0)) {
Alex Lighteb7c1442015-08-31 13:17:42 -07004794 StackHandleScope<1> hs_iface(self);
Alex Light56a40f52015-10-14 11:07:41 -07004795 MutableHandle<mirror::Class> handle_scope_iface(hs_iface.NewHandle<mirror::Class>(nullptr));
4796 for (size_t i = 0; i < num_direct_interfaces; i++) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00004797 handle_scope_iface.Assign(mirror::Class::GetDirectInterface(self, klass.Get(), i));
Vladimir Markobfb80d22017-02-14 14:08:12 +00004798 if (UNLIKELY(handle_scope_iface == nullptr)) {
4799 const char* iface_descriptor =
4800 klass->GetDexFile().StringByTypeIdx(klass->GetDirectInterfaceTypeIdx(i));
4801 LOG(FATAL) << "Check failed: handle_scope_iface != nullptr "
4802 << "Debug data for bug 34839984: "
4803 << klass->PrettyDescriptor() << " iface #" << i << " " << iface_descriptor
4804 << " space: " << DescribeSpace(klass.Get())
4805 << " loaders: " << DescribeLoaders(klass.Get(), iface_descriptor);
4806 }
Alex Light56a40f52015-10-14 11:07:41 -07004807 CHECK(handle_scope_iface->IsInterface());
4808 if (handle_scope_iface->HasBeenRecursivelyInitialized()) {
4809 // We have already done this for this interface. Skip it.
4810 continue;
4811 }
4812 // We cannot just call initialize class directly because we need to ensure that ALL
4813 // interfaces with default methods are initialized. Non-default interface initialization
4814 // will not affect other non-default super-interfaces.
4815 bool iface_initialized = InitializeDefaultInterfaceRecursive(self,
4816 handle_scope_iface,
4817 can_init_statics,
4818 can_init_parents);
4819 if (!iface_initialized) {
4820 ObjectLock<mirror::Class> lock(self, klass);
4821 // Initialization failed because one of our interfaces with default methods is erroneous.
Vladimir Marko72ab6842017-01-20 19:32:50 +00004822 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Alex Light56a40f52015-10-14 11:07:41 -07004823 return false;
4824 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004825 }
4826 }
4827 }
4828
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004829 const size_t num_static_fields = klass->NumStaticFields();
4830 if (num_static_fields > 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004831 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004832 CHECK(dex_class_def != nullptr);
Mathieu Chartierf8322842014-05-16 10:59:25 -07004833 const DexFile& dex_file = klass->GetDexFile();
Hiroshi Yamauchi67ef46a2014-08-21 15:59:43 -07004834 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004835 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
Mathieu Chartierf8322842014-05-16 10:59:25 -07004836 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache()));
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004837
4838 // Eagerly fill in static fields so that the we don't have to do as many expensive
4839 // Class::FindStaticField in ResolveField.
4840 for (size_t i = 0; i < num_static_fields; ++i) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004841 ArtField* field = klass->GetStaticField(i);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004842 const uint32_t field_idx = field->GetDexFieldIndex();
Mathieu Chartierc7853442015-03-27 14:35:38 -07004843 ArtField* resolved_field = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004844 if (resolved_field == nullptr) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004845 dex_cache->SetResolvedField(field_idx, field, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07004846 } else {
4847 DCHECK_EQ(field, resolved_field);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004848 }
4849 }
4850
David Sehr9323e6e2016-09-13 08:58:35 -07004851 annotations::RuntimeEncodedStaticFieldValueIterator value_it(dex_file,
4852 &dex_cache,
4853 &class_loader,
4854 this,
4855 *dex_class_def);
Ian Rogers13735952014-10-08 12:43:28 -07004856 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004857 ClassDataItemIterator field_it(dex_file, class_data);
4858 if (value_it.HasNext()) {
4859 DCHECK(field_it.HasNextStaticField());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004860 CHECK(can_init_statics);
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004861 for ( ; value_it.HasNext(); value_it.Next(), field_it.Next()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004862 ArtField* field = ResolveField(
4863 dex_file, field_it.GetMemberIndex(), dex_cache, class_loader, true);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004864 if (Runtime::Current()->IsActiveTransaction()) {
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004865 value_it.ReadValueToField<true>(field);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004866 } else {
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004867 value_it.ReadValueToField<false>(field);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004868 }
Mathieu Chartierda595be2016-08-10 13:57:39 -07004869 if (self->IsExceptionPending()) {
4870 break;
4871 }
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004872 DCHECK(!value_it.HasNext() || field_it.HasNextStaticField());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004873 }
4874 }
4875 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004876
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004877
Mathieu Chartierda595be2016-08-10 13:57:39 -07004878 if (!self->IsExceptionPending()) {
4879 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
4880 if (clinit != nullptr) {
4881 CHECK(can_init_statics);
4882 JValue result;
4883 clinit->Invoke(self, nullptr, 0, &result, "V");
4884 }
4885 }
Ian Rogers7b078e82014-09-10 14:44:24 -07004886 self->AllowThreadSuspension();
Elliott Hughes83df2ac2011-10-11 16:37:54 -07004887 uint64_t t1 = NanoTime();
4888
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004889 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004890 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004891 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004892
4893 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004894 WrapExceptionInInitializer(klass);
Vladimir Marko72ab6842017-01-20 19:32:50 +00004895 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004896 success = false;
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01004897 } else if (Runtime::Current()->IsTransactionAborted()) {
4898 // The exception thrown when the transaction aborted has been caught and cleared
4899 // so we need to throw it again now.
David Sehr709b0702016-10-13 09:12:37 -07004900 VLOG(compiler) << "Return from class initializer of "
4901 << mirror::Class::PrettyDescriptor(klass.Get())
Sebastien Hertzbd9cf9f2015-03-03 12:16:13 +01004902 << " without exception while transaction was aborted: re-throw it now.";
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02004903 Runtime::Current()->ThrowTransactionAbortError(self);
Vladimir Marko72ab6842017-01-20 19:32:50 +00004904 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01004905 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004906 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07004907 RuntimeStats* global_stats = Runtime::Current()->GetStats();
4908 RuntimeStats* thread_stats = self->GetStats();
4909 ++global_stats->class_init_count;
4910 ++thread_stats->class_init_count;
4911 global_stats->class_init_time_ns += (t1 - t0);
4912 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07004913 // Set the class as initialized except if failed to initialize static fields.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004914 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004915 if (VLOG_IS_ON(class_linker)) {
Ian Rogers1ff3c982014-08-12 02:30:58 -07004916 std::string temp;
4917 LOG(INFO) << "Initialized class " << klass->GetDescriptor(&temp) << " from " <<
Mathieu Chartierf8322842014-05-16 10:59:25 -07004918 klass->GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08004919 }
Brian Carlstrom073278c2014-02-19 15:21:21 -08004920 // Opportunistically set static method trampolines to their destination.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004921 FixupStaticTrampolines(klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004922 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004923 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004924 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004925}
4926
Alex Lighteb7c1442015-08-31 13:17:42 -07004927// We recursively run down the tree of interfaces. We need to do this in the order they are declared
4928// and perform the initialization only on those interfaces that contain default methods.
4929bool ClassLinker::InitializeDefaultInterfaceRecursive(Thread* self,
4930 Handle<mirror::Class> iface,
4931 bool can_init_statics,
4932 bool can_init_parents) {
4933 CHECK(iface->IsInterface());
4934 size_t num_direct_ifaces = iface->NumDirectInterfaces();
Alex Light56a40f52015-10-14 11:07:41 -07004935 // Only create the (expensive) handle scope if we need it.
4936 if (UNLIKELY(num_direct_ifaces > 0)) {
4937 StackHandleScope<1> hs(self);
4938 MutableHandle<mirror::Class> handle_super_iface(hs.NewHandle<mirror::Class>(nullptr));
4939 // First we initialize all of iface's super-interfaces recursively.
4940 for (size_t i = 0; i < num_direct_ifaces; i++) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00004941 ObjPtr<mirror::Class> super_iface = mirror::Class::GetDirectInterface(self, iface.Get(), i);
4942 DCHECK(super_iface != nullptr);
Alex Light56a40f52015-10-14 11:07:41 -07004943 if (!super_iface->HasBeenRecursivelyInitialized()) {
4944 // Recursive step
4945 handle_super_iface.Assign(super_iface);
4946 if (!InitializeDefaultInterfaceRecursive(self,
4947 handle_super_iface,
4948 can_init_statics,
4949 can_init_parents)) {
4950 return false;
4951 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004952 }
4953 }
4954 }
4955
4956 bool result = true;
4957 // Then we initialize 'iface' if it has default methods. We do not need to (and in fact must not)
4958 // initialize if we don't have default methods.
4959 if (iface->HasDefaultMethods()) {
4960 result = EnsureInitialized(self, iface, can_init_statics, can_init_parents);
4961 }
4962
4963 // Mark that this interface has undergone recursive default interface initialization so we know we
4964 // can skip it on any later class initializations. We do this even if we are not a default
4965 // interface since we can still avoid the traversal. This is purely a performance optimization.
4966 if (result) {
4967 // TODO This should be done in a better way
4968 ObjectLock<mirror::Class> lock(self, iface);
4969 iface->SetRecursivelyInitialized();
4970 }
4971 return result;
4972}
4973
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004974bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass,
4975 Thread* self,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004976 ObjectLock<mirror::Class>& lock)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004977 REQUIRES_SHARED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004978 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004979 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004980 CHECK(!klass->IsInitialized());
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004981 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004982
4983 // When we wake up, repeat the test for init-in-progress. If
4984 // there's an exception pending (only possible if
Brian Carlstromb23eab12014-10-08 17:55:21 -07004985 // we were not using WaitIgnoringInterrupts), bail out.
Brian Carlstromd1422f82011-09-28 11:37:09 -07004986 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004987 WrapExceptionInInitializer(klass);
Vladimir Marko72ab6842017-01-20 19:32:50 +00004988 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004989 return false;
4990 }
4991 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004992 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004993 continue;
4994 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004995 if (klass->GetStatus() == mirror::Class::kStatusVerified &&
4996 Runtime::Current()->IsAotCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07004997 // Compile time initialization failed.
4998 return false;
4999 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07005000 if (klass->IsErroneous()) {
5001 // The caller wants an exception, but it was thrown in a
5002 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07005003 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
David Sehr709b0702016-10-13 09:12:37 -07005004 klass->PrettyDescriptor().c_str());
Brian Carlstromb23eab12014-10-08 17:55:21 -07005005 VlogClassInitializationFailure(klass);
Brian Carlstromd1422f82011-09-28 11:37:09 -07005006 return false;
5007 }
5008 if (klass->IsInitialized()) {
5009 return true;
5010 }
David Sehr709b0702016-10-13 09:12:37 -07005011 LOG(FATAL) << "Unexpected class status. " << klass->PrettyClass() << " is "
Mathieu Chartierc528dba2013-11-26 12:00:11 -08005012 << klass->GetStatus();
Brian Carlstromd1422f82011-09-28 11:37:09 -07005013 }
Ian Rogers07140832014-09-30 15:43:59 -07005014 UNREACHABLE();
Brian Carlstromd1422f82011-09-28 11:37:09 -07005015}
5016
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005017static void ThrowSignatureCheckResolveReturnTypeException(Handle<mirror::Class> klass,
5018 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005019 ArtMethod* method,
5020 ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005021 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005022 DCHECK(Thread::Current()->IsExceptionPending());
5023 DCHECK(!m->IsProxyMethod());
5024 const DexFile* dex_file = m->GetDexFile();
5025 const DexFile::MethodId& method_id = dex_file->GetMethodId(m->GetDexMethodIndex());
5026 const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
Andreas Gampea5b09a62016-11-17 15:21:22 -08005027 dex::TypeIndex return_type_idx = proto_id.return_type_idx_;
David Sehr709b0702016-10-13 09:12:37 -07005028 std::string return_type = dex_file->PrettyType(return_type_idx);
5029 std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005030 ThrowWrappedLinkageError(klass.Get(),
5031 "While checking class %s method %s signature against %s %s: "
5032 "Failed to resolve return type %s with %s",
David Sehr709b0702016-10-13 09:12:37 -07005033 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
5034 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005035 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07005036 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005037 return_type.c_str(), class_loader.c_str());
5038}
5039
5040static void ThrowSignatureCheckResolveArgException(Handle<mirror::Class> klass,
5041 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005042 ArtMethod* method,
5043 ArtMethod* m,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005044 uint32_t index,
Andreas Gampea5b09a62016-11-17 15:21:22 -08005045 dex::TypeIndex arg_type_idx)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005046 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005047 DCHECK(Thread::Current()->IsExceptionPending());
5048 DCHECK(!m->IsProxyMethod());
5049 const DexFile* dex_file = m->GetDexFile();
David Sehr709b0702016-10-13 09:12:37 -07005050 std::string arg_type = dex_file->PrettyType(arg_type_idx);
5051 std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005052 ThrowWrappedLinkageError(klass.Get(),
5053 "While checking class %s method %s signature against %s %s: "
5054 "Failed to resolve arg %u type %s with %s",
David Sehr709b0702016-10-13 09:12:37 -07005055 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
5056 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005057 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07005058 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005059 index, arg_type.c_str(), class_loader.c_str());
5060}
5061
5062static void ThrowSignatureMismatch(Handle<mirror::Class> klass,
5063 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005064 ArtMethod* method,
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005065 const std::string& error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005066 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005067 ThrowLinkageError(klass.Get(),
5068 "Class %s method %s resolves differently in %s %s: %s",
David Sehr709b0702016-10-13 09:12:37 -07005069 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
5070 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005071 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07005072 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005073 error_msg.c_str());
5074}
5075
Ian Rogersb5fb2072014-12-02 17:22:02 -08005076static bool HasSameSignatureWithDifferentClassLoaders(Thread* self,
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005077 Handle<mirror::Class> klass,
5078 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005079 ArtMethod* method1,
5080 ArtMethod* method2)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005081 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersb5fb2072014-12-02 17:22:02 -08005082 {
5083 StackHandleScope<1> hs(self);
Vladimir Marko942fd312017-01-16 20:52:19 +00005084 Handle<mirror::Class> return_type(hs.NewHandle(method1->GetReturnType(true /* resolve */)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005085 if (UNLIKELY(return_type == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005086 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method1);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005087 return false;
5088 }
Vladimir Marko942fd312017-01-16 20:52:19 +00005089 ObjPtr<mirror::Class> other_return_type = method2->GetReturnType(true /* resolve */);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005090 if (UNLIKELY(other_return_type == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005091 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method2);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005092 return false;
5093 }
Vladimir Marko862f43c2015-02-10 18:22:57 +00005094 if (UNLIKELY(other_return_type != return_type.Get())) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005095 ThrowSignatureMismatch(klass, super_klass, method1,
5096 StringPrintf("Return types mismatch: %s(%p) vs %s(%p)",
David Sehr709b0702016-10-13 09:12:37 -07005097 return_type->PrettyClassAndClassLoader().c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005098 return_type.Get(),
David Sehr709b0702016-10-13 09:12:37 -07005099 other_return_type->PrettyClassAndClassLoader().c_str(),
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005100 other_return_type.Ptr()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08005101 return false;
5102 }
5103 }
5104 const DexFile::TypeList* types1 = method1->GetParameterTypeList();
5105 const DexFile::TypeList* types2 = method2->GetParameterTypeList();
5106 if (types1 == nullptr) {
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005107 if (types2 != nullptr && types2->Size() != 0) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005108 ThrowSignatureMismatch(klass, super_klass, method1,
5109 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07005110 method2->PrettyMethod(true).c_str()));
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005111 return false;
5112 }
5113 return true;
Ian Rogersb5fb2072014-12-02 17:22:02 -08005114 } else if (UNLIKELY(types2 == nullptr)) {
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005115 if (types1->Size() != 0) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005116 ThrowSignatureMismatch(klass, super_klass, method1,
5117 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07005118 method2->PrettyMethod(true).c_str()));
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005119 return false;
5120 }
5121 return true;
Ian Rogersb5fb2072014-12-02 17:22:02 -08005122 }
5123 uint32_t num_types = types1->Size();
5124 if (UNLIKELY(num_types != types2->Size())) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005125 ThrowSignatureMismatch(klass, super_klass, method1,
5126 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07005127 method2->PrettyMethod(true).c_str()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08005128 return false;
5129 }
5130 for (uint32_t i = 0; i < num_types; ++i) {
Vladimir Marko862f43c2015-02-10 18:22:57 +00005131 StackHandleScope<1> hs(self);
Andreas Gampea5b09a62016-11-17 15:21:22 -08005132 dex::TypeIndex param_type_idx = types1->GetTypeItem(i).type_idx_;
Vladimir Marko862f43c2015-02-10 18:22:57 +00005133 Handle<mirror::Class> param_type(hs.NewHandle(
Vladimir Marko942fd312017-01-16 20:52:19 +00005134 method1->GetClassFromTypeIndex(param_type_idx, true /* resolve */)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005135 if (UNLIKELY(param_type == nullptr)) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005136 ThrowSignatureCheckResolveArgException(klass, super_klass, method1,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005137 method1, i, param_type_idx);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005138 return false;
5139 }
Andreas Gampea5b09a62016-11-17 15:21:22 -08005140 dex::TypeIndex other_param_type_idx = types2->GetTypeItem(i).type_idx_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005141 ObjPtr<mirror::Class> other_param_type =
Vladimir Marko942fd312017-01-16 20:52:19 +00005142 method2->GetClassFromTypeIndex(other_param_type_idx, true /* resolve */);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005143 if (UNLIKELY(other_param_type == nullptr)) {
5144 ThrowSignatureCheckResolveArgException(klass, super_klass, method1,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005145 method2, i, other_param_type_idx);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005146 return false;
5147 }
Vladimir Marko862f43c2015-02-10 18:22:57 +00005148 if (UNLIKELY(param_type.Get() != other_param_type)) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005149 ThrowSignatureMismatch(klass, super_klass, method1,
5150 StringPrintf("Parameter %u type mismatch: %s(%p) vs %s(%p)",
5151 i,
David Sehr709b0702016-10-13 09:12:37 -07005152 param_type->PrettyClassAndClassLoader().c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005153 param_type.Get(),
David Sehr709b0702016-10-13 09:12:37 -07005154 other_param_type->PrettyClassAndClassLoader().c_str(),
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005155 other_param_type.Ptr()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08005156 return false;
5157 }
5158 }
5159 return true;
5160}
5161
5162
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005163bool ClassLinker::ValidateSuperClassDescriptors(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005164 if (klass->IsInterface()) {
5165 return true;
5166 }
Ian Rogers151f2212014-05-06 11:27:27 -07005167 // Begin with the methods local to the superclass.
Ian Rogersded66a02014-10-28 18:12:55 -07005168 Thread* self = Thread::Current();
Mathieu Chartiere401d142015-04-22 13:56:20 -07005169 StackHandleScope<1> hs(self);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005170 MutableHandle<mirror::Class> super_klass(hs.NewHandle<mirror::Class>(nullptr));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005171 if (klass->HasSuperClass() &&
5172 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005173 super_klass.Assign(klass->GetSuperClass());
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005174 for (int i = klass->GetSuperClass()->GetVTableLength() - 1; i >= 0; --i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005175 auto* m = klass->GetVTableEntry(i, image_pointer_size_);
5176 auto* super_m = klass->GetSuperClass()->GetVTableEntry(i, image_pointer_size_);
5177 if (m != super_m) {
Vladimir Marko942fd312017-01-16 20:52:19 +00005178 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self,
5179 klass,
5180 super_klass,
5181 m,
5182 super_m))) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005183 self->AssertPendingException();
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005184 return false;
5185 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005186 }
5187 }
5188 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07005189 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005190 super_klass.Assign(klass->GetIfTable()->GetInterface(i));
5191 if (klass->GetClassLoader() != super_klass->GetClassLoader()) {
5192 uint32_t num_methods = super_klass->NumVirtualMethods();
Ian Rogers151f2212014-05-06 11:27:27 -07005193 for (uint32_t j = 0; j < num_methods; ++j) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005194 auto* m = klass->GetIfTable()->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>(
5195 j, image_pointer_size_);
5196 auto* super_m = super_klass->GetVirtualMethod(j, image_pointer_size_);
5197 if (m != super_m) {
Vladimir Marko942fd312017-01-16 20:52:19 +00005198 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self,
5199 klass,
5200 super_klass,
5201 m,
5202 super_m))) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005203 self->AssertPendingException();
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005204 return false;
5205 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005206 }
5207 }
5208 }
5209 }
5210 return true;
5211}
5212
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005213bool ClassLinker::EnsureInitialized(Thread* self,
5214 Handle<mirror::Class> c,
5215 bool can_init_fields,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005216 bool can_init_parents) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08005217 DCHECK(c != nullptr);
Mathieu Chartier524507a2014-08-27 15:28:28 -07005218 if (c->IsInitialized()) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08005219 EnsureSkipAccessChecksMethods(c, image_pointer_size_);
Mathieu Chartier8502f722016-06-08 15:09:08 -07005220 self->AssertNoPendingException();
Mathieu Chartier524507a2014-08-27 15:28:28 -07005221 return true;
5222 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005223 const bool success = InitializeClass(self, c, can_init_fields, can_init_parents);
Mathieu Chartier524507a2014-08-27 15:28:28 -07005224 if (!success) {
5225 if (can_init_fields && can_init_parents) {
David Sehr709b0702016-10-13 09:12:37 -07005226 CHECK(self->IsExceptionPending()) << c->PrettyClass();
Mathieu Chartier524507a2014-08-27 15:28:28 -07005227 }
5228 } else {
5229 self->AssertNoPendingException();
Ian Rogers595799e2012-01-11 17:32:51 -08005230 }
5231 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07005232}
5233
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005234void ClassLinker::FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class,
5235 ObjPtr<mirror::Class> new_class) {
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005236 DCHECK_EQ(temp_class->NumInstanceFields(), 0u);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005237 for (ArtField& field : new_class->GetIFields()) {
5238 if (field.GetDeclaringClass() == temp_class) {
5239 field.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005240 }
5241 }
5242
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005243 DCHECK_EQ(temp_class->NumStaticFields(), 0u);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005244 for (ArtField& field : new_class->GetSFields()) {
5245 if (field.GetDeclaringClass() == temp_class) {
5246 field.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005247 }
5248 }
5249
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005250 DCHECK_EQ(temp_class->NumDirectMethods(), 0u);
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005251 DCHECK_EQ(temp_class->NumVirtualMethods(), 0u);
Alex Lighte64300b2015-12-15 15:02:47 -08005252 for (auto& method : new_class->GetMethods(image_pointer_size_)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005253 if (method.GetDeclaringClass() == temp_class) {
5254 method.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005255 }
5256 }
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005257
5258 // Make sure the remembered set and mod-union tables know that we updated some of the native
5259 // roots.
5260 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005261}
5262
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005263void ClassLinker::RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08005264 CHECK(class_loader->GetAllocator() == nullptr);
5265 CHECK(class_loader->GetClassTable() == nullptr);
5266 Thread* const self = Thread::Current();
5267 ClassLoaderData data;
5268 data.weak_root = self->GetJniEnv()->vm->AddWeakGlobalRef(self, class_loader);
5269 // Create and set the class table.
5270 data.class_table = new ClassTable;
5271 class_loader->SetClassTable(data.class_table);
5272 // Create and set the linear allocator.
5273 data.allocator = Runtime::Current()->CreateLinearAlloc();
5274 class_loader->SetAllocator(data.allocator);
5275 // Add to the list so that we know to free the data later.
5276 class_loaders_.push_back(data);
5277}
5278
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005279ClassTable* ClassLinker::InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07005280 if (class_loader == nullptr) {
5281 return &boot_class_table_;
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005282 }
Mathieu Chartier6b069532015-08-05 15:08:12 -07005283 ClassTable* class_table = class_loader->GetClassTable();
5284 if (class_table == nullptr) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08005285 RegisterClassLoader(class_loader);
5286 class_table = class_loader->GetClassTable();
5287 DCHECK(class_table != nullptr);
Mathieu Chartier6b069532015-08-05 15:08:12 -07005288 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005289 return class_table;
5290}
5291
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005292ClassTable* ClassLinker::ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07005293 return class_loader == nullptr ? &boot_class_table_ : class_loader->GetClassTable();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005294}
5295
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005296static ImTable* FindSuperImt(ObjPtr<mirror::Class> klass, PointerSize pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005297 REQUIRES_SHARED(Locks::mutator_lock_) {
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005298 while (klass->HasSuperClass()) {
5299 klass = klass->GetSuperClass();
5300 if (klass->ShouldHaveImt()) {
5301 return klass->GetImt(pointer_size);
5302 }
5303 }
5304 return nullptr;
5305}
5306
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005307bool ClassLinker::LinkClass(Thread* self,
5308 const char* descriptor,
5309 Handle<mirror::Class> klass,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005310 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005311 MutableHandle<mirror::Class>* h_new_class_out) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005312 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005313
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005314 if (!LinkSuperClass(klass)) {
5315 return false;
5316 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005317 ArtMethod* imt_data[ImTable::kSize];
5318 // If there are any new conflicts compared to super class.
5319 bool new_conflict = false;
5320 std::fill_n(imt_data, arraysize(imt_data), Runtime::Current()->GetImtUnimplementedMethod());
5321 if (!LinkMethods(self, klass, interfaces, &new_conflict, imt_data)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005322 return false;
5323 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005324 if (!LinkInstanceFields(self, klass)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005325 return false;
5326 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005327 size_t class_size;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005328 if (!LinkStaticFields(self, klass, &class_size)) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07005329 return false;
5330 }
5331 CreateReferenceInstanceOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005332 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005333
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005334 ImTable* imt = nullptr;
5335 if (klass->ShouldHaveImt()) {
5336 // If there are any new conflicts compared to the super class we can not make a copy. There
5337 // can be cases where both will have a conflict method at the same slot without having the same
5338 // set of conflicts. In this case, we can not share the IMT since the conflict table slow path
5339 // will possibly create a table that is incorrect for either of the classes.
5340 // Same IMT with new_conflict does not happen very often.
5341 if (!new_conflict) {
5342 ImTable* super_imt = FindSuperImt(klass.Get(), image_pointer_size_);
5343 if (super_imt != nullptr) {
5344 bool imt_equals = true;
5345 for (size_t i = 0; i < ImTable::kSize && imt_equals; ++i) {
5346 imt_equals = imt_equals && (super_imt->Get(i, image_pointer_size_) == imt_data[i]);
5347 }
5348 if (imt_equals) {
5349 imt = super_imt;
5350 }
5351 }
5352 }
5353 if (imt == nullptr) {
5354 LinearAlloc* allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
5355 imt = reinterpret_cast<ImTable*>(
5356 allocator->Alloc(self, ImTable::SizeInBytes(image_pointer_size_)));
5357 if (imt == nullptr) {
5358 return false;
5359 }
5360 imt->Populate(imt_data, image_pointer_size_);
5361 }
5362 }
5363
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005364 if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) {
5365 // We don't need to retire this class as it has no embedded tables or it was created the
5366 // correct size during class linker initialization.
David Sehr709b0702016-10-13 09:12:37 -07005367 CHECK_EQ(klass->GetClassSize(), class_size) << klass->PrettyDescriptor();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005368
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005369 if (klass->ShouldHaveEmbeddedVTable()) {
5370 klass->PopulateEmbeddedVTable(image_pointer_size_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005371 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005372 if (klass->ShouldHaveImt()) {
5373 klass->SetImt(imt, image_pointer_size_);
5374 }
Mingyao Yang063fc772016-08-02 11:02:54 -07005375
5376 // Update CHA info based on whether we override methods.
5377 // Have to do this before setting the class as resolved which allows
5378 // instantiation of klass.
5379 Runtime::Current()->GetClassHierarchyAnalysis()->UpdateAfterLoadingOf(klass);
5380
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005381 // This will notify waiters on klass that saw the not yet resolved
5382 // class in the class_table_ during EnsureResolved.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005383 mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005384 h_new_class_out->Assign(klass.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005385 } else {
5386 CHECK(!klass->IsResolved());
5387 // Retire the temporary class and create the correctly sized resolved class.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005388 StackHandleScope<1> hs(self);
Mathieu Chartiere401d142015-04-22 13:56:20 -07005389 auto h_new_class = hs.NewHandle(klass->CopyOf(self, class_size, imt, image_pointer_size_));
Mathieu Chartier3ee25bb2015-08-10 10:13:02 -07005390 // Set arrays to null since we don't want to have multiple classes with the same ArtField or
5391 // ArtMethod array pointers. If this occurs, it causes bugs in remembered sets since the GC
5392 // may not see any references to the target space and clean the card for a class if another
5393 // class had the same array pointer.
Alex Lighte64300b2015-12-15 15:02:47 -08005394 klass->SetMethodsPtrUnchecked(nullptr, 0, 0);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005395 klass->SetSFieldsPtrUnchecked(nullptr);
5396 klass->SetIFieldsPtrUnchecked(nullptr);
Andreas Gampefa4333d2017-02-14 11:10:34 -08005397 if (UNLIKELY(h_new_class == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005398 self->AssertPendingOOMException();
Vladimir Marko72ab6842017-01-20 19:32:50 +00005399 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005400 return false;
5401 }
5402
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005403 CHECK_EQ(h_new_class->GetClassSize(), class_size);
5404 ObjectLock<mirror::Class> lock(self, h_new_class);
5405 FixupTemporaryDeclaringClass(klass.Get(), h_new_class.Get());
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005406
5407 {
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005408 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005409 ObjPtr<mirror::ClassLoader> const class_loader = h_new_class.Get()->GetClassLoader();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005410 ClassTable* const table = InsertClassTableForClassLoader(class_loader);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005411 ObjPtr<mirror::Class> existing = table->UpdateClass(descriptor, h_new_class.Get(),
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005412 ComputeModifiedUtf8Hash(descriptor));
Mathieu Chartier05aa4d32015-09-19 12:44:38 -07005413 if (class_loader != nullptr) {
5414 // We updated the class in the class table, perform the write barrier so that the GC knows
5415 // about the change.
5416 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
5417 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005418 CHECK_EQ(existing, klass.Get());
Vladimir Marko1998cd02017-01-13 13:02:58 +00005419 if (log_new_roots_) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005420 new_class_roots_.push_back(GcRoot<mirror::Class>(h_new_class.Get()));
5421 }
5422 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005423
Mingyao Yang063fc772016-08-02 11:02:54 -07005424 // Update CHA info based on whether we override methods.
5425 // Have to do this before setting the class as resolved which allows
5426 // instantiation of klass.
5427 Runtime::Current()->GetClassHierarchyAnalysis()->UpdateAfterLoadingOf(h_new_class);
5428
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005429 // This will notify waiters on temp class that saw the not yet resolved class in the
5430 // class_table_ during EnsureResolved.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005431 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetired, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005432
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005433 CHECK_EQ(h_new_class->GetStatus(), mirror::Class::kStatusResolving);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005434 // This will notify waiters on new_class that saw the not yet resolved
5435 // class in the class_table_ during EnsureResolved.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005436 mirror::Class::SetStatus(h_new_class, mirror::Class::kStatusResolved, self);
5437 // Return the new class.
5438 h_new_class_out->Assign(h_new_class.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005439 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005440 return true;
5441}
5442
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005443static void CountMethodsAndFields(ClassDataItemIterator& dex_data,
5444 size_t* virtual_methods,
5445 size_t* direct_methods,
5446 size_t* static_fields,
5447 size_t* instance_fields) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005448 *virtual_methods = *direct_methods = *static_fields = *instance_fields = 0;
5449
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005450 while (dex_data.HasNextStaticField()) {
5451 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005452 (*static_fields)++;
5453 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005454 while (dex_data.HasNextInstanceField()) {
5455 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005456 (*instance_fields)++;
5457 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005458 while (dex_data.HasNextDirectMethod()) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005459 (*direct_methods)++;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005460 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005461 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005462 while (dex_data.HasNextVirtualMethod()) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005463 (*virtual_methods)++;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005464 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005465 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005466 DCHECK(!dex_data.HasNext());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005467}
5468
5469static void DumpClass(std::ostream& os,
5470 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
5471 const char* suffix) {
5472 ClassDataItemIterator dex_data(dex_file, dex_file.GetClassData(dex_class_def));
5473 os << dex_file.GetClassDescriptor(dex_class_def) << suffix << ":\n";
5474 os << " Static fields:\n";
5475 while (dex_data.HasNextStaticField()) {
5476 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex());
5477 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n";
5478 dex_data.Next();
5479 }
5480 os << " Instance fields:\n";
5481 while (dex_data.HasNextInstanceField()) {
5482 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex());
5483 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n";
5484 dex_data.Next();
5485 }
5486 os << " Direct methods:\n";
5487 while (dex_data.HasNextDirectMethod()) {
5488 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex());
5489 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n";
5490 dex_data.Next();
5491 }
5492 os << " Virtual methods:\n";
5493 while (dex_data.HasNextVirtualMethod()) {
5494 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex());
5495 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n";
5496 dex_data.Next();
5497 }
5498}
5499
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005500static std::string DumpClasses(const DexFile& dex_file1,
5501 const DexFile::ClassDef& dex_class_def1,
5502 const DexFile& dex_file2,
5503 const DexFile::ClassDef& dex_class_def2) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005504 std::ostringstream os;
5505 DumpClass(os, dex_file1, dex_class_def1, " (Compile time)");
5506 DumpClass(os, dex_file2, dex_class_def2, " (Runtime)");
5507 return os.str();
5508}
5509
5510
5511// Very simple structural check on whether the classes match. Only compares the number of
5512// methods and fields.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005513static bool SimpleStructuralCheck(const DexFile& dex_file1,
5514 const DexFile::ClassDef& dex_class_def1,
5515 const DexFile& dex_file2,
5516 const DexFile::ClassDef& dex_class_def2,
Andreas Gampefd9eb392014-11-06 16:52:58 -08005517 std::string* error_msg) {
5518 ClassDataItemIterator dex_data1(dex_file1, dex_file1.GetClassData(dex_class_def1));
5519 ClassDataItemIterator dex_data2(dex_file2, dex_file2.GetClassData(dex_class_def2));
5520
5521 // Counters for current dex file.
5522 size_t dex_virtual_methods1, dex_direct_methods1, dex_static_fields1, dex_instance_fields1;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005523 CountMethodsAndFields(dex_data1,
5524 &dex_virtual_methods1,
5525 &dex_direct_methods1,
5526 &dex_static_fields1,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005527 &dex_instance_fields1);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005528 // Counters for compile-time dex file.
5529 size_t dex_virtual_methods2, dex_direct_methods2, dex_static_fields2, dex_instance_fields2;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005530 CountMethodsAndFields(dex_data2,
5531 &dex_virtual_methods2,
5532 &dex_direct_methods2,
5533 &dex_static_fields2,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005534 &dex_instance_fields2);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005535
5536 if (dex_virtual_methods1 != dex_virtual_methods2) {
5537 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005538 *error_msg = StringPrintf("Virtual method count off: %zu vs %zu\n%s",
5539 dex_virtual_methods1,
5540 dex_virtual_methods2,
5541 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005542 return false;
5543 }
5544 if (dex_direct_methods1 != dex_direct_methods2) {
5545 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005546 *error_msg = StringPrintf("Direct method count off: %zu vs %zu\n%s",
5547 dex_direct_methods1,
5548 dex_direct_methods2,
5549 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005550 return false;
5551 }
5552 if (dex_static_fields1 != dex_static_fields2) {
5553 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005554 *error_msg = StringPrintf("Static field count off: %zu vs %zu\n%s",
5555 dex_static_fields1,
5556 dex_static_fields2,
5557 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005558 return false;
5559 }
5560 if (dex_instance_fields1 != dex_instance_fields2) {
5561 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005562 *error_msg = StringPrintf("Instance field count off: %zu vs %zu\n%s",
5563 dex_instance_fields1,
5564 dex_instance_fields2,
5565 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005566 return false;
5567 }
5568
5569 return true;
5570}
5571
5572// Checks whether a the super-class changed from what we had at compile-time. This would
5573// invalidate quickening.
5574static bool CheckSuperClassChange(Handle<mirror::Class> klass,
5575 const DexFile& dex_file,
5576 const DexFile::ClassDef& class_def,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005577 ObjPtr<mirror::Class> super_class)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005578 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005579 // Check for unexpected changes in the superclass.
5580 // Quick check 1) is the super_class class-loader the boot class loader? This always has
5581 // precedence.
5582 if (super_class->GetClassLoader() != nullptr &&
5583 // Quick check 2) different dex cache? Breaks can only occur for different dex files,
5584 // which is implied by different dex cache.
5585 klass->GetDexCache() != super_class->GetDexCache()) {
5586 // Now comes the expensive part: things can be broken if (a) the klass' dex file has a
5587 // definition for the super-class, and (b) the files are in separate oat files. The oat files
5588 // are referenced from the dex file, so do (b) first. Only relevant if we have oat files.
Richard Uhler07b3c232015-03-31 15:57:54 -07005589 const OatDexFile* class_oat_dex_file = dex_file.GetOatDexFile();
5590 const OatFile* class_oat_file = nullptr;
5591 if (class_oat_dex_file != nullptr) {
5592 class_oat_file = class_oat_dex_file->GetOatFile();
5593 }
5594
Andreas Gampefd9eb392014-11-06 16:52:58 -08005595 if (class_oat_file != nullptr) {
Richard Uhler07b3c232015-03-31 15:57:54 -07005596 const OatDexFile* loaded_super_oat_dex_file = super_class->GetDexFile().GetOatDexFile();
5597 const OatFile* loaded_super_oat_file = nullptr;
5598 if (loaded_super_oat_dex_file != nullptr) {
5599 loaded_super_oat_file = loaded_super_oat_dex_file->GetOatFile();
5600 }
5601
Andreas Gampefd9eb392014-11-06 16:52:58 -08005602 if (loaded_super_oat_file != nullptr && class_oat_file != loaded_super_oat_file) {
5603 // Now check (a).
5604 const DexFile::ClassDef* super_class_def = dex_file.FindClassDef(class_def.superclass_idx_);
5605 if (super_class_def != nullptr) {
5606 // Uh-oh, we found something. Do our check.
5607 std::string error_msg;
5608 if (!SimpleStructuralCheck(dex_file, *super_class_def,
5609 super_class->GetDexFile(), *super_class->GetClassDef(),
5610 &error_msg)) {
5611 // Print a warning to the log. This exception might be caught, e.g., as common in test
5612 // drivers. When the class is later tried to be used, we re-throw a new instance, as we
5613 // only save the type of the exception.
5614 LOG(WARNING) << "Incompatible structural change detected: " <<
5615 StringPrintf(
5616 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
David Sehr709b0702016-10-13 09:12:37 -07005617 dex_file.PrettyType(super_class_def->class_idx_).c_str(),
Andreas Gampefd9eb392014-11-06 16:52:58 -08005618 class_oat_file->GetLocation().c_str(),
5619 loaded_super_oat_file->GetLocation().c_str(),
5620 error_msg.c_str());
5621 ThrowIncompatibleClassChangeError(klass.Get(),
5622 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
David Sehr709b0702016-10-13 09:12:37 -07005623 dex_file.PrettyType(super_class_def->class_idx_).c_str(),
Andreas Gampefd9eb392014-11-06 16:52:58 -08005624 class_oat_file->GetLocation().c_str(),
5625 loaded_super_oat_file->GetLocation().c_str(),
5626 error_msg.c_str());
5627 return false;
5628 }
5629 }
5630 }
5631 }
5632 }
5633 return true;
5634}
5635
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005636bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005637 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers8b2c0b92013-09-19 02:56:49 -07005638 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
Andreas Gampea5b09a62016-11-17 15:21:22 -08005639 dex::TypeIndex super_class_idx = class_def.superclass_idx_;
5640 if (super_class_idx.IsValid()) {
Roland Levillain90328ac2016-05-18 12:25:38 +01005641 // Check that a class does not inherit from itself directly.
5642 //
5643 // TODO: This is a cheap check to detect the straightforward case
5644 // of a class extending itself (b/28685551), but we should do a
5645 // proper cycle detection on loaded classes, to detect all cases
5646 // of class circularity errors (b/28830038).
5647 if (super_class_idx == class_def.class_idx_) {
5648 ThrowClassCircularityError(klass.Get(),
5649 "Class %s extends itself",
David Sehr709b0702016-10-13 09:12:37 -07005650 klass->PrettyDescriptor().c_str());
Roland Levillain90328ac2016-05-18 12:25:38 +01005651 return false;
5652 }
5653
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005654 ObjPtr<mirror::Class> super_class = ResolveType(dex_file, super_class_idx, klass.Get());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005655 if (super_class == nullptr) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07005656 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005657 return false;
5658 }
Ian Rogersbe125a92012-01-11 15:19:49 -08005659 // Verify
5660 if (!klass->CanAccess(super_class)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005661 ThrowIllegalAccessError(klass.Get(), "Class %s extended by class %s is inaccessible",
David Sehr709b0702016-10-13 09:12:37 -07005662 super_class->PrettyDescriptor().c_str(),
5663 klass->PrettyDescriptor().c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08005664 return false;
5665 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005666 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005667 klass->SetSuperClass(super_class);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005668
5669 if (!CheckSuperClassChange(klass, dex_file, class_def, super_class)) {
5670 DCHECK(Thread::Current()->IsExceptionPending());
5671 return false;
5672 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005673 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07005674 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005675 if (interfaces != nullptr) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005676 for (size_t i = 0; i < interfaces->Size(); i++) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08005677 dex::TypeIndex idx = interfaces->GetTypeItem(i).type_idx_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005678 ObjPtr<mirror::Class> interface = ResolveType(dex_file, idx, klass.Get());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005679 if (interface == nullptr) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005680 DCHECK(Thread::Current()->IsExceptionPending());
5681 return false;
5682 }
5683 // Verify
5684 if (!klass->CanAccess(interface)) {
5685 // TODO: the RI seemed to ignore this in my testing.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005686 ThrowIllegalAccessError(klass.Get(),
5687 "Interface %s implemented by class %s is inaccessible",
David Sehr709b0702016-10-13 09:12:37 -07005688 interface->PrettyDescriptor().c_str(),
5689 klass->PrettyDescriptor().c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005690 return false;
5691 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005692 }
5693 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07005694 // Mark the class as loaded.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005695 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, nullptr);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005696 return true;
5697}
5698
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005699bool ClassLinker::LinkSuperClass(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005700 CHECK(!klass->IsPrimitive());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005701 ObjPtr<mirror::Class> super = klass->GetSuperClass();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005702 if (klass.Get() == GetClassRoot(kJavaLangObject)) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005703 if (super != nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005704 ThrowClassFormatError(klass.Get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005705 return false;
5706 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005707 return true;
5708 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005709 if (super == nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005710 ThrowLinkageError(klass.Get(), "No superclass defined for class %s",
David Sehr709b0702016-10-13 09:12:37 -07005711 klass->PrettyDescriptor().c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005712 return false;
5713 }
5714 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07005715 if (super->IsFinal() || super->IsInterface()) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005716 ThrowIncompatibleClassChangeError(klass.Get(),
5717 "Superclass %s of %s is %s",
David Sehr709b0702016-10-13 09:12:37 -07005718 super->PrettyDescriptor().c_str(),
5719 klass->PrettyDescriptor().c_str(),
Ian Rogers62d6c772013-02-27 08:32:07 -08005720 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005721 return false;
5722 }
5723 if (!klass->CanAccess(super)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005724 ThrowIllegalAccessError(klass.Get(), "Superclass %s is inaccessible to class %s",
David Sehr709b0702016-10-13 09:12:37 -07005725 super->PrettyDescriptor().c_str(),
5726 klass->PrettyDescriptor().c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005727 return false;
5728 }
Elliott Hughes20cde902011-10-04 17:37:27 -07005729
Brian Carlstromf3632832014-05-20 15:36:53 -07005730 // Inherit kAccClassIsFinalizable from the superclass in case this
5731 // class doesn't override finalize.
Elliott Hughes20cde902011-10-04 17:37:27 -07005732 if (super->IsFinalizable()) {
5733 klass->SetFinalizable();
5734 }
5735
Mathieu Chartiere4275c02015-08-06 15:34:15 -07005736 // Inherit class loader flag form super class.
5737 if (super->IsClassLoaderClass()) {
5738 klass->SetClassLoaderClass();
5739 }
5740
Elliott Hughes2da50362011-10-10 16:57:08 -07005741 // Inherit reference flags (if any) from the superclass.
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07005742 uint32_t reference_flags = (super->GetClassFlags() & mirror::kClassFlagReference);
Elliott Hughes2da50362011-10-10 16:57:08 -07005743 if (reference_flags != 0) {
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07005744 CHECK_EQ(klass->GetClassFlags(), 0u);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07005745 klass->SetClassFlags(klass->GetClassFlags() | reference_flags);
Elliott Hughes2da50362011-10-10 16:57:08 -07005746 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07005747 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07005748 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005749 ThrowLinkageError(klass.Get(),
Ian Rogers62d6c772013-02-27 08:32:07 -08005750 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
David Sehr709b0702016-10-13 09:12:37 -07005751 klass->PrettyDescriptor().c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07005752 return false;
5753 }
Elliott Hughes2da50362011-10-10 16:57:08 -07005754
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005755 if (kIsDebugBuild) {
5756 // Ensure super classes are fully resolved prior to resolving fields..
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005757 while (super != nullptr) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005758 CHECK(super->IsResolved());
5759 super = super->GetSuperClass();
5760 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005761 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005762 return true;
5763}
5764
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005765// Populate the class vtable and itable. Compute return type indices.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005766bool ClassLinker::LinkMethods(Thread* self,
5767 Handle<mirror::Class> klass,
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005768 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005769 bool* out_new_conflict,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005770 ArtMethod** out_imt) {
Ian Rogers7b078e82014-09-10 14:44:24 -07005771 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07005772 // A map from vtable indexes to the method they need to be updated to point to. Used because we
5773 // need to have default methods be in the virtuals array of each class but we don't set that up
5774 // until LinkInterfaceMethods.
Alex Light9139e002015-10-09 15:59:48 -07005775 std::unordered_map<size_t, ClassLinker::MethodTranslation> default_translations;
Alex Lighteb7c1442015-08-31 13:17:42 -07005776 // Link virtual methods then interface methods.
5777 // We set up the interface lookup table first because we need it to determine if we need to update
5778 // any vtable entries with new default method implementations.
5779 return SetupInterfaceLookupTable(self, klass, interfaces)
5780 && LinkVirtualMethods(self, klass, /*out*/ &default_translations)
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005781 && LinkInterfaceMethods(self, klass, default_translations, out_new_conflict, out_imt);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005782}
5783
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005784// Comparator for name and signature of a method, used in finding overriding methods. Implementation
5785// avoids the use of handles, if it didn't then rather than compare dex files we could compare dex
5786// caches in the implementation below.
5787class MethodNameAndSignatureComparator FINAL : public ValueObject {
5788 public:
Mathieu Chartiere401d142015-04-22 13:56:20 -07005789 explicit MethodNameAndSignatureComparator(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005790 REQUIRES_SHARED(Locks::mutator_lock_) :
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005791 dex_file_(method->GetDexFile()), mid_(&dex_file_->GetMethodId(method->GetDexMethodIndex())),
5792 name_(nullptr), name_len_(0) {
David Sehr709b0702016-10-13 09:12:37 -07005793 DCHECK(!method->IsProxyMethod()) << method->PrettyMethod();
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005794 }
5795
5796 const char* GetName() {
5797 if (name_ == nullptr) {
5798 name_ = dex_file_->StringDataAndUtf16LengthByIdx(mid_->name_idx_, &name_len_);
5799 }
5800 return name_;
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005801 }
5802
Mathieu Chartiere401d142015-04-22 13:56:20 -07005803 bool HasSameNameAndSignature(ArtMethod* other)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005804 REQUIRES_SHARED(Locks::mutator_lock_) {
David Sehr709b0702016-10-13 09:12:37 -07005805 DCHECK(!other->IsProxyMethod()) << other->PrettyMethod();
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005806 const DexFile* other_dex_file = other->GetDexFile();
5807 const DexFile::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex());
5808 if (dex_file_ == other_dex_file) {
5809 return mid_->name_idx_ == other_mid.name_idx_ && mid_->proto_idx_ == other_mid.proto_idx_;
5810 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005811 GetName(); // Only used to make sure its calculated.
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005812 uint32_t other_name_len;
5813 const char* other_name = other_dex_file->StringDataAndUtf16LengthByIdx(other_mid.name_idx_,
5814 &other_name_len);
5815 if (name_len_ != other_name_len || strcmp(name_, other_name) != 0) {
5816 return false;
5817 }
5818 return dex_file_->GetMethodSignature(*mid_) == other_dex_file->GetMethodSignature(other_mid);
5819 }
5820
5821 private:
5822 // Dex file for the method to compare against.
5823 const DexFile* const dex_file_;
5824 // MethodId for the method to compare against.
5825 const DexFile::MethodId* const mid_;
5826 // Lazily computed name from the dex file's strings.
5827 const char* name_;
5828 // Lazily computed name length.
5829 uint32_t name_len_;
5830};
5831
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005832class LinkVirtualHashTable {
5833 public:
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005834 LinkVirtualHashTable(Handle<mirror::Class> klass,
5835 size_t hash_size,
5836 uint32_t* hash_table,
Andreas Gampe542451c2016-07-26 09:02:02 -07005837 PointerSize image_pointer_size)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005838 : klass_(klass),
5839 hash_size_(hash_size),
5840 hash_table_(hash_table),
Mathieu Chartiere401d142015-04-22 13:56:20 -07005841 image_pointer_size_(image_pointer_size) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005842 std::fill(hash_table_, hash_table_ + hash_size_, invalid_index_);
5843 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005844
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005845 void Add(uint32_t virtual_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005846 ArtMethod* local_method = klass_->GetVirtualMethodDuringLinking(
5847 virtual_method_index, image_pointer_size_);
5848 const char* name = local_method->GetInterfaceMethodIfProxy(image_pointer_size_)->GetName();
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08005849 uint32_t hash = ComputeModifiedUtf8Hash(name);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005850 uint32_t index = hash % hash_size_;
5851 // Linear probe until we have an empty slot.
5852 while (hash_table_[index] != invalid_index_) {
5853 if (++index == hash_size_) {
5854 index = 0;
5855 }
5856 }
5857 hash_table_[index] = virtual_method_index;
5858 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005859
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005860 uint32_t FindAndRemove(MethodNameAndSignatureComparator* comparator)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005861 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005862 const char* name = comparator->GetName();
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08005863 uint32_t hash = ComputeModifiedUtf8Hash(name);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005864 size_t index = hash % hash_size_;
5865 while (true) {
5866 const uint32_t value = hash_table_[index];
5867 // Since linear probe makes continuous blocks, hitting an invalid index means we are done
5868 // the block and can safely assume not found.
5869 if (value == invalid_index_) {
5870 break;
5871 }
5872 if (value != removed_index_) { // This signifies not already overriden.
Mathieu Chartiere401d142015-04-22 13:56:20 -07005873 ArtMethod* virtual_method =
5874 klass_->GetVirtualMethodDuringLinking(value, image_pointer_size_);
5875 if (comparator->HasSameNameAndSignature(
5876 virtual_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005877 hash_table_[index] = removed_index_;
5878 return value;
5879 }
5880 }
5881 if (++index == hash_size_) {
5882 index = 0;
5883 }
5884 }
5885 return GetNotFoundIndex();
5886 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005887
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005888 static uint32_t GetNotFoundIndex() {
5889 return invalid_index_;
5890 }
5891
5892 private:
5893 static const uint32_t invalid_index_;
5894 static const uint32_t removed_index_;
5895
5896 Handle<mirror::Class> klass_;
5897 const size_t hash_size_;
5898 uint32_t* const hash_table_;
Andreas Gampe542451c2016-07-26 09:02:02 -07005899 const PointerSize image_pointer_size_;
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005900};
5901
5902const uint32_t LinkVirtualHashTable::invalid_index_ = std::numeric_limits<uint32_t>::max();
5903const uint32_t LinkVirtualHashTable::removed_index_ = std::numeric_limits<uint32_t>::max() - 1;
5904
Stephen Hines1ddd9132017-02-08 01:51:18 -08005905bool ClassLinker::LinkVirtualMethods(
Alex Lighteb7c1442015-08-31 13:17:42 -07005906 Thread* self,
5907 Handle<mirror::Class> klass,
Alex Light9139e002015-10-09 15:59:48 -07005908 /*out*/std::unordered_map<size_t, ClassLinker::MethodTranslation>* default_translations) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005909 const size_t num_virtual_methods = klass->NumVirtualMethods();
Alex Lighteb7c1442015-08-31 13:17:42 -07005910 if (klass->IsInterface()) {
5911 // No vtable.
5912 if (!IsUint<16>(num_virtual_methods)) {
5913 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zu", num_virtual_methods);
5914 return false;
5915 }
5916 bool has_defaults = false;
Alex Lighteb7c1442015-08-31 13:17:42 -07005917 // Assign each method an IMT index and set the default flag.
5918 for (size_t i = 0; i < num_virtual_methods; ++i) {
5919 ArtMethod* m = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
5920 m->SetMethodIndex(i);
5921 if (!m->IsAbstract()) {
5922 m->SetAccessFlags(m->GetAccessFlags() | kAccDefault);
5923 has_defaults = true;
5924 }
5925 }
5926 // Mark that we have default methods so that we won't need to scan the virtual_methods_ array
5927 // during initialization. This is a performance optimization. We could simply traverse the
5928 // virtual_methods_ array again during initialization.
5929 if (has_defaults) {
5930 klass->SetHasDefaultMethods();
5931 }
5932 return true;
5933 } else if (klass->HasSuperClass()) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005934 const size_t super_vtable_length = klass->GetSuperClass()->GetVTableLength();
5935 const size_t max_count = num_virtual_methods + super_vtable_length;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005936 StackHandleScope<2> hs(self);
Mingyao Yang38eecb02014-08-13 14:51:03 -07005937 Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass()));
Mathieu Chartiere401d142015-04-22 13:56:20 -07005938 MutableHandle<mirror::PointerArray> vtable;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005939 if (super_class->ShouldHaveEmbeddedVTable()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005940 vtable = hs.NewHandle(AllocPointerArray(self, max_count));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005941 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005942 self->AssertPendingOOMException();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005943 return false;
5944 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005945 for (size_t i = 0; i < super_vtable_length; i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005946 vtable->SetElementPtrSize(
5947 i, super_class->GetEmbeddedVTableEntry(i, image_pointer_size_), image_pointer_size_);
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005948 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005949 // We might need to change vtable if we have new virtual methods or new interfaces (since that
5950 // might give us new default methods). If no new interfaces then we can skip the rest since
5951 // the class cannot override any of the super-class's methods. This is required for
5952 // correctness since without it we might not update overridden default method vtable entries
5953 // correctly.
5954 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005955 klass->SetVTable(vtable.Get());
5956 return true;
5957 }
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005958 } else {
Alex Lighteb7c1442015-08-31 13:17:42 -07005959 DCHECK(super_class->IsAbstract() && !super_class->IsArrayClass());
Mathieu Chartiere401d142015-04-22 13:56:20 -07005960 auto* super_vtable = super_class->GetVTable();
David Sehr709b0702016-10-13 09:12:37 -07005961 CHECK(super_vtable != nullptr) << super_class->PrettyClass();
Alex Lighteb7c1442015-08-31 13:17:42 -07005962 // We might need to change vtable if we have new virtual methods or new interfaces (since that
5963 // might give us new default methods). See comment above.
5964 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005965 klass->SetVTable(super_vtable);
5966 return true;
5967 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005968 vtable = hs.NewHandle(down_cast<mirror::PointerArray*>(
5969 super_vtable->CopyOf(self, max_count)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005970 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005971 self->AssertPendingOOMException();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005972 return false;
5973 }
Ian Rogersa436fde2013-08-27 23:34:06 -07005974 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005975 // How the algorithm works:
5976 // 1. Populate hash table by adding num_virtual_methods from klass. The values in the hash
5977 // table are: invalid_index for unused slots, index super_vtable_length + i for a virtual
5978 // method which has not been matched to a vtable method, and j if the virtual method at the
5979 // index overrode the super virtual method at index j.
5980 // 2. Loop through super virtual methods, if they overwrite, update hash table to j
5981 // (j < super_vtable_length) to avoid redundant checks. (TODO maybe use this info for reducing
5982 // the need for the initial vtable which we later shrink back down).
5983 // 3. Add non overridden methods to the end of the vtable.
5984 static constexpr size_t kMaxStackHash = 250;
Alex Lighteb7c1442015-08-31 13:17:42 -07005985 // + 1 so that even if we only have new default methods we will still be able to use this hash
5986 // table (i.e. it will never have 0 size).
5987 const size_t hash_table_size = num_virtual_methods * 3 + 1;
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005988 uint32_t* hash_table_ptr;
5989 std::unique_ptr<uint32_t[]> hash_heap_storage;
5990 if (hash_table_size <= kMaxStackHash) {
5991 hash_table_ptr = reinterpret_cast<uint32_t*>(
5992 alloca(hash_table_size * sizeof(*hash_table_ptr)));
5993 } else {
5994 hash_heap_storage.reset(new uint32_t[hash_table_size]);
5995 hash_table_ptr = hash_heap_storage.get();
5996 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005997 LinkVirtualHashTable hash_table(klass, hash_table_size, hash_table_ptr, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005998 // Add virtual methods to the hash table.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005999 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006000 DCHECK(klass->GetVirtualMethodDuringLinking(
6001 i, image_pointer_size_)->GetDeclaringClass() != nullptr);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006002 hash_table.Add(i);
6003 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006004 // Loop through each super vtable method and see if they are overridden by a method we added to
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006005 // the hash table.
6006 for (size_t j = 0; j < super_vtable_length; ++j) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006007 // Search the hash table to see if we are overridden by any method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07006008 ArtMethod* super_method = vtable->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
Alex Lightc7a420c2016-10-18 14:33:18 -07006009 if (!klass->CanAccessMember(super_method->GetDeclaringClass(),
6010 super_method->GetAccessFlags())) {
6011 // Continue on to the next method since this one is package private and canot be overridden.
6012 // Before Android 4.1, the package-private method super_method might have been incorrectly
6013 // overridden.
6014 continue;
6015 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006016 MethodNameAndSignatureComparator super_method_name_comparator(
Mathieu Chartiere401d142015-04-22 13:56:20 -07006017 super_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Lightc7a420c2016-10-18 14:33:18 -07006018 // We remove the method so that subsequent lookups will be faster by making the hash-map
6019 // smaller as we go on.
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006020 uint32_t hash_index = hash_table.FindAndRemove(&super_method_name_comparator);
6021 if (hash_index != hash_table.GetNotFoundIndex()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006022 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(
6023 hash_index, image_pointer_size_);
Alex Lightc7a420c2016-10-18 14:33:18 -07006024 if (super_method->IsFinal()) {
6025 ThrowLinkageError(klass.Get(), "Method %s overrides final method in class %s",
6026 virtual_method->PrettyMethod().c_str(),
6027 super_method->GetDeclaringClassDescriptor());
6028 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006029 }
Alex Lightc7a420c2016-10-18 14:33:18 -07006030 vtable->SetElementPtrSize(j, virtual_method, image_pointer_size_);
6031 virtual_method->SetMethodIndex(j);
Alex Light9139e002015-10-09 15:59:48 -07006032 } else if (super_method->IsOverridableByDefaultMethod()) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006033 // We didn't directly override this method but we might through default methods...
6034 // Check for default method update.
6035 ArtMethod* default_method = nullptr;
Alex Light9139e002015-10-09 15:59:48 -07006036 switch (FindDefaultMethodImplementation(self,
6037 super_method,
6038 klass,
6039 /*out*/&default_method)) {
6040 case DefaultMethodSearchResult::kDefaultConflict: {
6041 // A conflict was found looking for default methods. Note this (assuming it wasn't
6042 // pre-existing) in the translations map.
6043 if (UNLIKELY(!super_method->IsDefaultConflicting())) {
6044 // Don't generate another conflict method to reduce memory use as an optimization.
6045 default_translations->insert(
6046 {j, ClassLinker::MethodTranslation::CreateConflictingMethod()});
6047 }
6048 break;
6049 }
6050 case DefaultMethodSearchResult::kAbstractFound: {
6051 // No conflict but method is abstract.
6052 // We note that this vtable entry must be made abstract.
6053 if (UNLIKELY(!super_method->IsAbstract())) {
6054 default_translations->insert(
6055 {j, ClassLinker::MethodTranslation::CreateAbstractMethod()});
6056 }
6057 break;
6058 }
6059 case DefaultMethodSearchResult::kDefaultFound: {
6060 if (UNLIKELY(super_method->IsDefaultConflicting() ||
6061 default_method->GetDeclaringClass() != super_method->GetDeclaringClass())) {
6062 // Found a default method implementation that is new.
6063 // TODO Refactor this add default methods to virtuals here and not in
6064 // LinkInterfaceMethods maybe.
6065 // The problem is default methods might override previously present
6066 // default-method or miranda-method vtable entries from the superclass.
6067 // Unfortunately we need these to be entries in this class's virtuals. We do not
6068 // give these entries there until LinkInterfaceMethods so we pass this map around
6069 // to let it know which vtable entries need to be updated.
6070 // Make a note that vtable entry j must be updated, store what it needs to be updated
6071 // to. We will allocate a virtual method slot in LinkInterfaceMethods and fix it up
6072 // then.
6073 default_translations->insert(
6074 {j, ClassLinker::MethodTranslation::CreateTranslatedMethod(default_method)});
David Sehr709b0702016-10-13 09:12:37 -07006075 VLOG(class_linker) << "Method " << super_method->PrettyMethod()
6076 << " overridden by default "
6077 << default_method->PrettyMethod()
6078 << " in " << mirror::Class::PrettyClass(klass.Get());
Alex Light9139e002015-10-09 15:59:48 -07006079 }
6080 break;
6081 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006082 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006083 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006084 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006085 size_t actual_count = super_vtable_length;
Alex Lighteb7c1442015-08-31 13:17:42 -07006086 // Add the non-overridden methods at the end.
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006087 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006088 ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006089 size_t method_idx = local_method->GetMethodIndexDuringLinking();
6090 if (method_idx < super_vtable_length &&
Mathieu Chartiere401d142015-04-22 13:56:20 -07006091 local_method == vtable->GetElementPtrSize<ArtMethod*>(method_idx, image_pointer_size_)) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006092 continue;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006093 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07006094 vtable->SetElementPtrSize(actual_count, local_method, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006095 local_method->SetMethodIndex(actual_count);
6096 ++actual_count;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006097 }
Andreas Gampeab1eb0d2015-02-13 19:23:55 -08006098 if (!IsUint<16>(actual_count)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07006099 ThrowClassFormatError(klass.Get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006100 return false;
6101 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07006102 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006103 CHECK_LE(actual_count, max_count);
6104 if (actual_count < max_count) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006105 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, actual_count)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006106 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006107 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006108 return false;
6109 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006110 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07006111 klass->SetVTable(vtable.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006112 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07006113 CHECK_EQ(klass.Get(), GetClassRoot(kJavaLangObject));
Andreas Gampeab1eb0d2015-02-13 19:23:55 -08006114 if (!IsUint<16>(num_virtual_methods)) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006115 ThrowClassFormatError(klass.Get(), "Too many methods: %d",
6116 static_cast<int>(num_virtual_methods));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006117 return false;
6118 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07006119 auto* vtable = AllocPointerArray(self, num_virtual_methods);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006120 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006121 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006122 return false;
6123 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07006124 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006125 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
6126 vtable->SetElementPtrSize(i, virtual_method, image_pointer_size_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07006127 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006128 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006129 klass->SetVTable(vtable);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006130 }
6131 return true;
6132}
6133
Alex Light9139e002015-10-09 15:59:48 -07006134// Determine if the given iface has any subinterface in the given list that declares the method
6135// specified by 'target'.
6136//
6137// Arguments
6138// - self: The thread we are running on
6139// - target: A comparator that will match any method that overrides the method we are checking for
6140// - iftable: The iftable we are searching for an overriding method on.
6141// - ifstart: The index of the interface we are checking to see if anything overrides
6142// - iface: The interface we are checking to see if anything overrides.
6143// - image_pointer_size:
6144// The image pointer size.
6145//
6146// Returns
6147// - True: There is some method that matches the target comparator defined in an interface that
6148// is a subtype of iface.
6149// - False: There is no method that matches the target comparator in any interface that is a subtype
6150// of iface.
6151static bool ContainsOverridingMethodOf(Thread* self,
6152 MethodNameAndSignatureComparator& target,
6153 Handle<mirror::IfTable> iftable,
6154 size_t ifstart,
6155 Handle<mirror::Class> iface,
Andreas Gampe542451c2016-07-26 09:02:02 -07006156 PointerSize image_pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006157 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light9139e002015-10-09 15:59:48 -07006158 DCHECK(self != nullptr);
Andreas Gampefa4333d2017-02-14 11:10:34 -08006159 DCHECK(iface != nullptr);
6160 DCHECK(iftable != nullptr);
Alex Light9139e002015-10-09 15:59:48 -07006161 DCHECK_GE(ifstart, 0u);
6162 DCHECK_LT(ifstart, iftable->Count());
6163 DCHECK_EQ(iface.Get(), iftable->GetInterface(ifstart));
6164 DCHECK(iface->IsInterface());
6165
6166 size_t iftable_count = iftable->Count();
6167 StackHandleScope<1> hs(self);
6168 MutableHandle<mirror::Class> current_iface(hs.NewHandle<mirror::Class>(nullptr));
6169 for (size_t k = ifstart + 1; k < iftable_count; k++) {
6170 // Skip ifstart since our current interface obviously cannot override itself.
6171 current_iface.Assign(iftable->GetInterface(k));
Alex Lighte64300b2015-12-15 15:02:47 -08006172 // Iterate through every method on this interface. The order does not matter.
6173 for (ArtMethod& current_method : current_iface->GetDeclaredVirtualMethods(image_pointer_size)) {
Alex Light9139e002015-10-09 15:59:48 -07006174 if (UNLIKELY(target.HasSameNameAndSignature(
Alex Lighte64300b2015-12-15 15:02:47 -08006175 current_method.GetInterfaceMethodIfProxy(image_pointer_size)))) {
Alex Light9139e002015-10-09 15:59:48 -07006176 // Check if the i'th interface is a subtype of this one.
6177 if (iface->IsAssignableFrom(current_iface.Get())) {
6178 return true;
6179 }
6180 break;
6181 }
6182 }
6183 }
6184 return false;
6185}
6186
Alex Lighteb7c1442015-08-31 13:17:42 -07006187// Find the default method implementation for 'interface_method' in 'klass'. Stores it into
Alex Light9139e002015-10-09 15:59:48 -07006188// out_default_method and returns kDefaultFound on success. If no default method was found return
6189// kAbstractFound and store nullptr into out_default_method. If an error occurs (such as a
6190// default_method conflict) it will return kDefaultConflict.
6191ClassLinker::DefaultMethodSearchResult ClassLinker::FindDefaultMethodImplementation(
6192 Thread* self,
6193 ArtMethod* target_method,
6194 Handle<mirror::Class> klass,
6195 /*out*/ArtMethod** out_default_method) const {
Alex Lighteb7c1442015-08-31 13:17:42 -07006196 DCHECK(self != nullptr);
6197 DCHECK(target_method != nullptr);
6198 DCHECK(out_default_method != nullptr);
Alex Lighteb7c1442015-08-31 13:17:42 -07006199
6200 *out_default_method = nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006201
6202 // We organize the interface table so that, for interface I any subinterfaces J follow it in the
6203 // table. This lets us walk the table backwards when searching for default methods. The first one
6204 // we encounter is the best candidate since it is the most specific. Once we have found it we keep
6205 // track of it and then continue checking all other interfaces, since we need to throw an error if
6206 // we encounter conflicting default method implementations (one is not a subtype of the other).
6207 //
6208 // The order of unrelated interfaces does not matter and is not defined.
6209 size_t iftable_count = klass->GetIfTableCount();
6210 if (iftable_count == 0) {
Alex Light9139e002015-10-09 15:59:48 -07006211 // No interfaces. We have already reset out to null so just return kAbstractFound.
6212 return DefaultMethodSearchResult::kAbstractFound;
Alex Lighteb7c1442015-08-31 13:17:42 -07006213 }
6214
Alex Light9139e002015-10-09 15:59:48 -07006215 StackHandleScope<3> hs(self);
6216 MutableHandle<mirror::Class> chosen_iface(hs.NewHandle<mirror::Class>(nullptr));
Alex Lighteb7c1442015-08-31 13:17:42 -07006217 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable()));
Alex Light9139e002015-10-09 15:59:48 -07006218 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
Alex Lighteb7c1442015-08-31 13:17:42 -07006219 MethodNameAndSignatureComparator target_name_comparator(
6220 target_method->GetInterfaceMethodIfProxy(image_pointer_size_));
6221 // Iterates over the klass's iftable in reverse
Alex Light9139e002015-10-09 15:59:48 -07006222 for (size_t k = iftable_count; k != 0; ) {
6223 --k;
6224
Alex Lighteb7c1442015-08-31 13:17:42 -07006225 DCHECK_LT(k, iftable->Count());
Alex Light9139e002015-10-09 15:59:48 -07006226
6227 iface.Assign(iftable->GetInterface(k));
Alex Lighte64300b2015-12-15 15:02:47 -08006228 // Iterate through every declared method on this interface. The order does not matter.
6229 for (auto& method_iter : iface->GetDeclaredVirtualMethods(image_pointer_size_)) {
6230 ArtMethod* current_method = &method_iter;
Alex Lighteb7c1442015-08-31 13:17:42 -07006231 // Skip abstract methods and methods with different names.
6232 if (current_method->IsAbstract() ||
6233 !target_name_comparator.HasSameNameAndSignature(
6234 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
6235 continue;
Alex Lightd7c10c22016-03-31 10:03:07 -07006236 } else if (!current_method->IsPublic()) {
6237 // The verifier should have caught the non-public method for dex version 37. Just warn and
6238 // skip it since this is from before default-methods so we don't really need to care that it
6239 // has code.
David Sehr709b0702016-10-13 09:12:37 -07006240 LOG(WARNING) << "Interface method " << current_method->PrettyMethod()
6241 << " is not public! "
Alex Lightd7c10c22016-03-31 10:03:07 -07006242 << "This will be a fatal error in subsequent versions of android. "
6243 << "Continuing anyway.";
Alex Lighteb7c1442015-08-31 13:17:42 -07006244 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08006245 if (UNLIKELY(chosen_iface != nullptr)) {
Alex Light9139e002015-10-09 15:59:48 -07006246 // We have multiple default impls of the same method. This is a potential default conflict.
6247 // We need to check if this possibly conflicting method is either a superclass of the chosen
6248 // default implementation or is overridden by a non-default interface method. In either case
6249 // there is no conflict.
6250 if (!iface->IsAssignableFrom(chosen_iface.Get()) &&
6251 !ContainsOverridingMethodOf(self,
6252 target_name_comparator,
6253 iftable,
6254 k,
6255 iface,
6256 image_pointer_size_)) {
Nicolas Geoffray7f3e0db2016-01-28 09:29:31 +00006257 VLOG(class_linker) << "Conflicting default method implementations found: "
David Sehr709b0702016-10-13 09:12:37 -07006258 << current_method->PrettyMethod() << " and "
6259 << ArtMethod::PrettyMethod(*out_default_method) << " in class "
6260 << klass->PrettyClass() << " conflict.";
Alex Light9139e002015-10-09 15:59:48 -07006261 *out_default_method = nullptr;
6262 return DefaultMethodSearchResult::kDefaultConflict;
Alex Lighteb7c1442015-08-31 13:17:42 -07006263 } else {
6264 break; // Continue checking at the next interface.
6265 }
6266 } else {
Alex Light9139e002015-10-09 15:59:48 -07006267 // chosen_iface == null
6268 if (!ContainsOverridingMethodOf(self,
6269 target_name_comparator,
6270 iftable,
6271 k,
6272 iface,
6273 image_pointer_size_)) {
6274 // Don't set this as the chosen interface if something else is overriding it (because that
6275 // other interface would be potentially chosen instead if it was default). If the other
6276 // interface was abstract then we wouldn't select this interface as chosen anyway since
6277 // the abstract method masks it.
6278 *out_default_method = current_method;
6279 chosen_iface.Assign(iface.Get());
6280 // We should now finish traversing the graph to find if we have default methods that
6281 // conflict.
6282 } else {
David Sehr709b0702016-10-13 09:12:37 -07006283 VLOG(class_linker) << "A default method '" << current_method->PrettyMethod()
6284 << "' was "
6285 << "skipped because it was overridden by an abstract method in a "
6286 << "subinterface on class '" << klass->PrettyClass() << "'";
Alex Light9139e002015-10-09 15:59:48 -07006287 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006288 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006289 break;
6290 }
6291 }
Alex Light9139e002015-10-09 15:59:48 -07006292 if (*out_default_method != nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07006293 VLOG(class_linker) << "Default method '" << (*out_default_method)->PrettyMethod()
6294 << "' selected "
6295 << "as the implementation for '" << target_method->PrettyMethod()
6296 << "' in '" << klass->PrettyClass() << "'";
Alex Light9139e002015-10-09 15:59:48 -07006297 return DefaultMethodSearchResult::kDefaultFound;
6298 } else {
6299 return DefaultMethodSearchResult::kAbstractFound;
6300 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006301}
6302
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006303ArtMethod* ClassLinker::AddMethodToConflictTable(ObjPtr<mirror::Class> klass,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006304 ArtMethod* conflict_method,
6305 ArtMethod* interface_method,
6306 ArtMethod* method,
6307 bool force_new_conflict_method) {
Andreas Gampe542451c2016-07-26 09:02:02 -07006308 ImtConflictTable* current_table = conflict_method->GetImtConflictTable(kRuntimePointerSize);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006309 Runtime* const runtime = Runtime::Current();
6310 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
6311 bool new_entry = conflict_method == runtime->GetImtConflictMethod() || force_new_conflict_method;
6312
6313 // Create a new entry if the existing one is the shared conflict method.
6314 ArtMethod* new_conflict_method = new_entry
6315 ? runtime->CreateImtConflictMethod(linear_alloc)
6316 : conflict_method;
6317
6318 // Allocate a new table. Note that we will leak this table at the next conflict,
6319 // but that's a tradeoff compared to making the table fixed size.
6320 void* data = linear_alloc->Alloc(
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006321 Thread::Current(), ImtConflictTable::ComputeSizeWithOneMoreEntry(current_table,
6322 image_pointer_size_));
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006323 if (data == nullptr) {
6324 LOG(ERROR) << "Failed to allocate conflict table";
6325 return conflict_method;
6326 }
6327 ImtConflictTable* new_table = new (data) ImtConflictTable(current_table,
6328 interface_method,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006329 method,
6330 image_pointer_size_);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006331
6332 // Do a fence to ensure threads see the data in the table before it is assigned
6333 // to the conflict method.
6334 // Note that there is a race in the presence of multiple threads and we may leak
6335 // memory from the LinearAlloc, but that's a tradeoff compared to using
6336 // atomic operations.
6337 QuasiAtomic::ThreadFenceRelease();
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006338 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006339 return new_conflict_method;
6340}
6341
Vladimir Marko921094a2017-01-12 18:37:06 +00006342bool ClassLinker::AllocateIfTableMethodArrays(Thread* self,
6343 Handle<mirror::Class> klass,
6344 Handle<mirror::IfTable> iftable) {
6345 DCHECK(!klass->IsInterface());
6346 const bool has_superclass = klass->HasSuperClass();
6347 const bool extend_super_iftable = has_superclass;
6348 const size_t ifcount = klass->GetIfTableCount();
6349 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
6350 for (size_t i = 0; i < ifcount; ++i) {
6351 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods();
6352 if (num_methods > 0) {
6353 const bool is_super = i < super_ifcount;
6354 // This is an interface implemented by a super-class. Therefore we can just copy the method
6355 // array from the superclass.
6356 const bool super_interface = is_super && extend_super_iftable;
6357 ObjPtr<mirror::PointerArray> method_array;
6358 if (super_interface) {
6359 ObjPtr<mirror::IfTable> if_table = klass->GetSuperClass()->GetIfTable();
6360 DCHECK(if_table != nullptr);
6361 DCHECK(if_table->GetMethodArray(i) != nullptr);
6362 // If we are working on a super interface, try extending the existing method array.
6363 method_array = down_cast<mirror::PointerArray*>(if_table->GetMethodArray(i)->Clone(self));
6364 } else {
6365 method_array = AllocPointerArray(self, num_methods);
6366 }
6367 if (UNLIKELY(method_array == nullptr)) {
6368 self->AssertPendingOOMException();
6369 return false;
6370 }
6371 iftable->SetMethodArray(i, method_array);
6372 }
6373 }
6374 return true;
6375}
6376
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006377void ClassLinker::SetIMTRef(ArtMethod* unimplemented_method,
6378 ArtMethod* imt_conflict_method,
6379 ArtMethod* current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006380 /*out*/bool* new_conflict,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006381 /*out*/ArtMethod** imt_ref) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006382 // Place method in imt if entry is empty, place conflict otherwise.
6383 if (*imt_ref == unimplemented_method) {
6384 *imt_ref = current_method;
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006385 } else if (!(*imt_ref)->IsRuntimeMethod()) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006386 // If we are not a conflict and we have the same signature and name as the imt
6387 // entry, it must be that we overwrote a superclass vtable entry.
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006388 // Note that we have checked IsRuntimeMethod, as there may be multiple different
6389 // conflict methods.
Alex Lighteb7c1442015-08-31 13:17:42 -07006390 MethodNameAndSignatureComparator imt_comparator(
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006391 (*imt_ref)->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Lighteb7c1442015-08-31 13:17:42 -07006392 if (imt_comparator.HasSameNameAndSignature(
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006393 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006394 *imt_ref = current_method;
6395 } else {
Alex Light9139e002015-10-09 15:59:48 -07006396 *imt_ref = imt_conflict_method;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006397 *new_conflict = true;
Alex Lighteb7c1442015-08-31 13:17:42 -07006398 }
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006399 } else {
6400 // Place the default conflict method. Note that there may be an existing conflict
6401 // method in the IMT, but it could be one tailored to the super class, with a
6402 // specific ImtConflictTable.
6403 *imt_ref = imt_conflict_method;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006404 *new_conflict = true;
Alex Lighteb7c1442015-08-31 13:17:42 -07006405 }
6406}
6407
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006408void ClassLinker::FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) {
David Sehr709b0702016-10-13 09:12:37 -07006409 DCHECK(klass->ShouldHaveImt()) << klass->PrettyClass();
6410 DCHECK(!klass->IsTemp()) << klass->PrettyClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006411 ArtMethod* imt_data[ImTable::kSize];
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006412 Runtime* const runtime = Runtime::Current();
6413 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
6414 ArtMethod* const conflict_method = runtime->GetImtConflictMethod();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006415 std::fill_n(imt_data, arraysize(imt_data), unimplemented_method);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006416 if (klass->GetIfTable() != nullptr) {
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006417 bool new_conflict = false;
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006418 FillIMTFromIfTable(klass->GetIfTable(),
6419 unimplemented_method,
6420 conflict_method,
6421 klass,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006422 /*create_conflict_tables*/true,
6423 /*ignore_copied_methods*/false,
6424 &new_conflict,
6425 &imt_data[0]);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006426 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006427 if (!klass->ShouldHaveImt()) {
6428 return;
6429 }
6430 // Compare the IMT with the super class including the conflict methods. If they are equivalent,
6431 // we can just use the same pointer.
6432 ImTable* imt = nullptr;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006433 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006434 if (super_class != nullptr && super_class->ShouldHaveImt()) {
6435 ImTable* super_imt = super_class->GetImt(image_pointer_size_);
6436 bool same = true;
6437 for (size_t i = 0; same && i < ImTable::kSize; ++i) {
6438 ArtMethod* method = imt_data[i];
6439 ArtMethod* super_method = super_imt->Get(i, image_pointer_size_);
6440 if (method != super_method) {
6441 bool is_conflict_table = method->IsRuntimeMethod() &&
6442 method != unimplemented_method &&
6443 method != conflict_method;
6444 // Verify conflict contents.
6445 bool super_conflict_table = super_method->IsRuntimeMethod() &&
6446 super_method != unimplemented_method &&
6447 super_method != conflict_method;
6448 if (!is_conflict_table || !super_conflict_table) {
6449 same = false;
6450 } else {
6451 ImtConflictTable* table1 = method->GetImtConflictTable(image_pointer_size_);
6452 ImtConflictTable* table2 = super_method->GetImtConflictTable(image_pointer_size_);
6453 same = same && table1->Equals(table2, image_pointer_size_);
6454 }
6455 }
6456 }
6457 if (same) {
6458 imt = super_imt;
6459 }
6460 }
6461 if (imt == nullptr) {
6462 imt = klass->GetImt(image_pointer_size_);
6463 DCHECK(imt != nullptr);
6464 imt->Populate(imt_data, image_pointer_size_);
6465 } else {
6466 klass->SetImt(imt, image_pointer_size_);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006467 }
6468}
6469
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006470ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count,
6471 LinearAlloc* linear_alloc,
Andreas Gampe542451c2016-07-26 09:02:02 -07006472 PointerSize image_pointer_size) {
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006473 void* data = linear_alloc->Alloc(Thread::Current(),
6474 ImtConflictTable::ComputeSize(count,
6475 image_pointer_size));
6476 return (data != nullptr) ? new (data) ImtConflictTable(count, image_pointer_size) : nullptr;
6477}
6478
6479ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc) {
6480 return CreateImtConflictTable(count, linear_alloc, image_pointer_size_);
6481}
6482
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006483void ClassLinker::FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006484 ArtMethod* unimplemented_method,
6485 ArtMethod* imt_conflict_method,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006486 ObjPtr<mirror::Class> klass,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006487 bool create_conflict_tables,
6488 bool ignore_copied_methods,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006489 /*out*/bool* new_conflict,
6490 /*out*/ArtMethod** imt) {
6491 uint32_t conflict_counts[ImTable::kSize] = {};
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006492 for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006493 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006494 const size_t num_virtuals = interface->NumVirtualMethods();
6495 const size_t method_array_count = if_table->GetMethodArrayCount(i);
6496 // Virtual methods can be larger than the if table methods if there are default methods.
6497 DCHECK_GE(num_virtuals, method_array_count);
6498 if (kIsDebugBuild) {
6499 if (klass->IsInterface()) {
6500 DCHECK_EQ(method_array_count, 0u);
6501 } else {
6502 DCHECK_EQ(interface->NumDeclaredVirtualMethods(), method_array_count);
6503 }
6504 }
6505 if (method_array_count == 0) {
6506 continue;
6507 }
6508 auto* method_array = if_table->GetMethodArray(i);
6509 for (size_t j = 0; j < method_array_count; ++j) {
6510 ArtMethod* implementation_method =
6511 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6512 if (ignore_copied_methods && implementation_method->IsCopied()) {
6513 continue;
6514 }
6515 DCHECK(implementation_method != nullptr);
6516 // Miranda methods cannot be used to implement an interface method, but they are safe to put
6517 // in the IMT since their entrypoint is the interface trampoline. If we put any copied methods
6518 // or interface methods in the IMT here they will not create extra conflicts since we compare
6519 // names and signatures in SetIMTRef.
6520 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
Andreas Gampe75a7db62016-09-26 12:04:26 -07006521 const uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006522
6523 // There is only any conflicts if all of the interface methods for an IMT slot don't have
6524 // the same implementation method, keep track of this to avoid creating a conflict table in
6525 // this case.
6526
6527 // Conflict table size for each IMT slot.
6528 ++conflict_counts[imt_index];
6529
6530 SetIMTRef(unimplemented_method,
6531 imt_conflict_method,
6532 implementation_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006533 /*out*/new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006534 /*out*/&imt[imt_index]);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006535 }
6536 }
6537
6538 if (create_conflict_tables) {
6539 // Create the conflict tables.
6540 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006541 for (size_t i = 0; i < ImTable::kSize; ++i) {
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006542 size_t conflicts = conflict_counts[i];
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006543 if (imt[i] == imt_conflict_method) {
6544 ImtConflictTable* new_table = CreateImtConflictTable(conflicts, linear_alloc);
6545 if (new_table != nullptr) {
6546 ArtMethod* new_conflict_method =
6547 Runtime::Current()->CreateImtConflictMethod(linear_alloc);
6548 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_);
6549 imt[i] = new_conflict_method;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006550 } else {
6551 LOG(ERROR) << "Failed to allocate conflict table";
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006552 imt[i] = imt_conflict_method;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006553 }
6554 } else {
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006555 DCHECK_NE(imt[i], imt_conflict_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006556 }
6557 }
6558
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006559 for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006560 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006561 const size_t method_array_count = if_table->GetMethodArrayCount(i);
6562 // Virtual methods can be larger than the if table methods if there are default methods.
6563 if (method_array_count == 0) {
6564 continue;
6565 }
6566 auto* method_array = if_table->GetMethodArray(i);
6567 for (size_t j = 0; j < method_array_count; ++j) {
6568 ArtMethod* implementation_method =
6569 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6570 if (ignore_copied_methods && implementation_method->IsCopied()) {
6571 continue;
6572 }
6573 DCHECK(implementation_method != nullptr);
6574 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
Andreas Gampe75a7db62016-09-26 12:04:26 -07006575 const uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006576 if (!imt[imt_index]->IsRuntimeMethod() ||
6577 imt[imt_index] == unimplemented_method ||
6578 imt[imt_index] == imt_conflict_method) {
6579 continue;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006580 }
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006581 ImtConflictTable* table = imt[imt_index]->GetImtConflictTable(image_pointer_size_);
6582 const size_t num_entries = table->NumEntries(image_pointer_size_);
6583 table->SetInterfaceMethod(num_entries, image_pointer_size_, interface_method);
6584 table->SetImplementationMethod(num_entries, image_pointer_size_, implementation_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006585 }
6586 }
6587 }
6588}
6589
Alex Lighteb7c1442015-08-31 13:17:42 -07006590// Simple helper function that checks that no subtypes of 'val' are contained within the 'classes'
6591// set.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006592static bool NotSubinterfaceOfAny(
6593 const std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr>& classes,
6594 ObjPtr<mirror::Class> val)
Alex Lighteb7c1442015-08-31 13:17:42 -07006595 REQUIRES(Roles::uninterruptible_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006596 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006597 DCHECK(val != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006598 for (ObjPtr<mirror::Class> c : classes) {
6599 if (val->IsAssignableFrom(c)) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006600 return false;
6601 }
6602 }
6603 return true;
6604}
6605
6606// Fills in and flattens the interface inheritance hierarchy.
6607//
6608// By the end of this function all interfaces in the transitive closure of to_process are added to
6609// the iftable and every interface precedes all of its sub-interfaces in this list.
6610//
6611// all I, J: Interface | I <: J implies J precedes I
6612//
6613// (note A <: B means that A is a subtype of B)
6614//
6615// This returns the total number of items in the iftable. The iftable might be resized down after
6616// this call.
6617//
6618// We order this backwards so that we do not need to reorder superclass interfaces when new
6619// interfaces are added in subclass's interface tables.
6620//
6621// Upon entry into this function iftable is a copy of the superclass's iftable with the first
6622// super_ifcount entries filled in with the transitive closure of the interfaces of the superclass.
6623// The other entries are uninitialized. We will fill in the remaining entries in this function. The
6624// iftable must be large enough to hold all interfaces without changing its size.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006625static size_t FillIfTable(ObjPtr<mirror::IfTable> iftable,
Alex Lighteb7c1442015-08-31 13:17:42 -07006626 size_t super_ifcount,
6627 std::vector<mirror::Class*> to_process)
6628 REQUIRES(Roles::uninterruptible_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006629 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006630 // This is the set of all class's already in the iftable. Used to make checking if a class has
6631 // already been added quicker.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006632 std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr> classes_in_iftable;
Alex Lighteb7c1442015-08-31 13:17:42 -07006633 // The first super_ifcount elements are from the superclass. We note that they are already added.
6634 for (size_t i = 0; i < super_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006635 ObjPtr<mirror::Class> iface = iftable->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07006636 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, iface)) << "Bad ordering.";
6637 classes_in_iftable.insert(iface);
6638 }
6639 size_t filled_ifcount = super_ifcount;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006640 for (ObjPtr<mirror::Class> interface : to_process) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006641 // Let us call the first filled_ifcount elements of iftable the current-iface-list.
6642 // At this point in the loop current-iface-list has the invariant that:
6643 // for every pair of interfaces I,J within it:
6644 // if index_of(I) < index_of(J) then I is not a subtype of J
6645
6646 // If we have already seen this element then all of its super-interfaces must already be in the
6647 // current-iface-list so we can skip adding it.
6648 if (!ContainsElement(classes_in_iftable, interface)) {
6649 // We haven't seen this interface so add all of its super-interfaces onto the
6650 // current-iface-list, skipping those already on it.
6651 int32_t ifcount = interface->GetIfTableCount();
6652 for (int32_t j = 0; j < ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006653 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006654 if (!ContainsElement(classes_in_iftable, super_interface)) {
6655 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, super_interface)) << "Bad ordering.";
6656 classes_in_iftable.insert(super_interface);
6657 iftable->SetInterface(filled_ifcount, super_interface);
6658 filled_ifcount++;
6659 }
6660 }
6661 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, interface)) << "Bad ordering";
6662 // Place this interface onto the current-iface-list after all of its super-interfaces.
6663 classes_in_iftable.insert(interface);
6664 iftable->SetInterface(filled_ifcount, interface);
6665 filled_ifcount++;
6666 } else if (kIsDebugBuild) {
6667 // Check all super-interfaces are already in the list.
6668 int32_t ifcount = interface->GetIfTableCount();
6669 for (int32_t j = 0; j < ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006670 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006671 DCHECK(ContainsElement(classes_in_iftable, super_interface))
David Sehr709b0702016-10-13 09:12:37 -07006672 << "Iftable does not contain " << mirror::Class::PrettyClass(super_interface)
6673 << ", a superinterface of " << interface->PrettyClass();
Alex Lighteb7c1442015-08-31 13:17:42 -07006674 }
6675 }
6676 }
6677 if (kIsDebugBuild) {
6678 // Check that the iftable is ordered correctly.
6679 for (size_t i = 0; i < filled_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006680 ObjPtr<mirror::Class> if_a = iftable->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07006681 for (size_t j = i + 1; j < filled_ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006682 ObjPtr<mirror::Class> if_b = iftable->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006683 // !(if_a <: if_b)
6684 CHECK(!if_b->IsAssignableFrom(if_a))
David Sehr709b0702016-10-13 09:12:37 -07006685 << "Bad interface order: " << mirror::Class::PrettyClass(if_a) << " (index " << i
6686 << ") extends "
6687 << if_b->PrettyClass() << " (index " << j << ") and so should be after it in the "
Alex Lighteb7c1442015-08-31 13:17:42 -07006688 << "interface list.";
6689 }
6690 }
6691 }
6692 return filled_ifcount;
6693}
6694
6695bool ClassLinker::SetupInterfaceLookupTable(Thread* self, Handle<mirror::Class> klass,
6696 Handle<mirror::ObjectArray<mirror::Class>> interfaces) {
6697 StackHandleScope<1> hs(self);
Mathieu Chartier6beced42016-11-15 15:51:31 -08006698 const bool has_superclass = klass->HasSuperClass();
6699 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
Andreas Gampefa4333d2017-02-14 11:10:34 -08006700 const bool have_interfaces = interfaces != nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006701 const size_t num_interfaces =
6702 have_interfaces ? interfaces->GetLength() : klass->NumDirectInterfaces();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006703 if (num_interfaces == 0) {
6704 if (super_ifcount == 0) {
Mathieu Chartier6beced42016-11-15 15:51:31 -08006705 if (LIKELY(has_superclass)) {
6706 klass->SetIfTable(klass->GetSuperClass()->GetIfTable());
6707 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006708 // Class implements no interfaces.
6709 DCHECK_EQ(klass->GetIfTableCount(), 0);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006710 return true;
6711 }
Ian Rogers9bc81912012-10-11 21:43:36 -07006712 // Class implements same interfaces as parent, are any of these not marker interfaces?
6713 bool has_non_marker_interface = false;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006714 ObjPtr<mirror::IfTable> super_iftable = klass->GetSuperClass()->GetIfTable();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006715 for (size_t i = 0; i < super_ifcount; ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07006716 if (super_iftable->GetMethodArrayCount(i) > 0) {
6717 has_non_marker_interface = true;
6718 break;
6719 }
6720 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006721 // Class just inherits marker interfaces from parent so recycle parent's iftable.
Ian Rogers9bc81912012-10-11 21:43:36 -07006722 if (!has_non_marker_interface) {
Ian Rogers9bc81912012-10-11 21:43:36 -07006723 klass->SetIfTable(super_iftable);
6724 return true;
6725 }
6726 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006727 size_t ifcount = super_ifcount + num_interfaces;
Alex Lighteb7c1442015-08-31 13:17:42 -07006728 // Check that every class being implemented is an interface.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006729 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006730 ObjPtr<mirror::Class> interface = have_interfaces
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006731 ? interfaces->GetWithoutChecks(i)
Vladimir Marko19a4d372016-12-08 14:41:46 +00006732 : mirror::Class::GetDirectInterface(self, klass.Get(), i);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006733 DCHECK(interface != nullptr);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006734 if (UNLIKELY(!interface->IsInterface())) {
6735 std::string temp;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006736 ThrowIncompatibleClassChangeError(klass.Get(),
6737 "Class %s implements non-interface class %s",
David Sehr709b0702016-10-13 09:12:37 -07006738 klass->PrettyDescriptor().c_str(),
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006739 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str());
6740 return false;
6741 }
6742 ifcount += interface->GetIfTableCount();
6743 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006744 // Create the interface function table.
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07006745 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006746 if (UNLIKELY(iftable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006747 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006748 return false;
6749 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006750 // Fill in table with superclass's iftable.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006751 if (super_ifcount != 0) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006752 ObjPtr<mirror::IfTable> super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07006753 for (size_t i = 0; i < super_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006754 ObjPtr<mirror::Class> super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07006755 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07006756 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006757 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006758
6759 // Note that AllowThreadSuspension is to thread suspension as pthread_testcancel is to pthread
6760 // cancellation. That is it will suspend if one has a pending suspend request but otherwise
6761 // doesn't really do anything.
Ian Rogers7b078e82014-09-10 14:44:24 -07006762 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07006763
6764 size_t new_ifcount;
6765 {
Mathieu Chartier268764d2016-09-13 12:09:38 -07006766 ScopedAssertNoThreadSuspension nts("Copying mirror::Class*'s for FillIfTable");
Alex Lighteb7c1442015-08-31 13:17:42 -07006767 std::vector<mirror::Class*> to_add;
6768 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006769 ObjPtr<mirror::Class> interface = have_interfaces ? interfaces->Get(i) :
Vladimir Marko19a4d372016-12-08 14:41:46 +00006770 mirror::Class::GetDirectInterface(self, klass.Get(), i);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006771 to_add.push_back(interface.Ptr());
Ian Rogersb52b01a2012-01-12 17:01:38 -08006772 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006773
6774 new_ifcount = FillIfTable(iftable.Get(), super_ifcount, std::move(to_add));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006775 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006776
Ian Rogers7b078e82014-09-10 14:44:24 -07006777 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07006778
Ian Rogersb52b01a2012-01-12 17:01:38 -08006779 // Shrink iftable in case duplicates were found
Alex Lighteb7c1442015-08-31 13:17:42 -07006780 if (new_ifcount < ifcount) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006781 DCHECK_NE(num_interfaces, 0U);
Mathieu Chartiere401d142015-04-22 13:56:20 -07006782 iftable.Assign(down_cast<mirror::IfTable*>(
Alex Lighteb7c1442015-08-31 13:17:42 -07006783 iftable->CopyOf(self, new_ifcount * mirror::IfTable::kMax)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006784 if (UNLIKELY(iftable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006785 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006786 return false;
6787 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006788 ifcount = new_ifcount;
Ian Rogersb52b01a2012-01-12 17:01:38 -08006789 } else {
Alex Lighteb7c1442015-08-31 13:17:42 -07006790 DCHECK_EQ(new_ifcount, ifcount);
Ian Rogersb52b01a2012-01-12 17:01:38 -08006791 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07006792 klass->SetIfTable(iftable.Get());
Alex Lighteb7c1442015-08-31 13:17:42 -07006793 return true;
6794}
6795
Alex Light1f3925d2016-09-07 12:04:20 -07006796// Finds the method with a name/signature that matches cmp in the given lists of methods. The list
6797// of methods must be unique.
6798static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp ATTRIBUTE_UNUSED) {
6799 return nullptr;
6800}
6801
6802template <typename ... Types>
Alex Light9139e002015-10-09 15:59:48 -07006803static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp,
Alex Light1f3925d2016-09-07 12:04:20 -07006804 const ScopedArenaVector<ArtMethod*>& list,
6805 const Types& ... rest)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006806 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light9139e002015-10-09 15:59:48 -07006807 for (ArtMethod* method : list) {
6808 if (cmp.HasSameNameAndSignature(method)) {
6809 return method;
6810 }
6811 }
Alex Light1f3925d2016-09-07 12:04:20 -07006812 return FindSameNameAndSignature(cmp, rest...);
Alex Light9139e002015-10-09 15:59:48 -07006813}
6814
Alex Light1f3925d2016-09-07 12:04:20 -07006815// Check that all vtable entries are present in this class's virtuals or are the same as a
6816// superclasses vtable entry.
6817static void CheckClassOwnsVTableEntries(Thread* self,
6818 Handle<mirror::Class> klass,
6819 PointerSize pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006820 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light1f3925d2016-09-07 12:04:20 -07006821 StackHandleScope<2> hs(self);
6822 Handle<mirror::PointerArray> check_vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006823 ObjPtr<mirror::Class> super_temp = (klass->HasSuperClass()) ? klass->GetSuperClass() : nullptr;
Alex Light1f3925d2016-09-07 12:04:20 -07006824 Handle<mirror::Class> superclass(hs.NewHandle(super_temp));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006825 int32_t super_vtable_length = (superclass != nullptr) ? superclass->GetVTableLength() : 0;
Alex Lighte64300b2015-12-15 15:02:47 -08006826 for (int32_t i = 0; i < check_vtable->GetLength(); ++i) {
6827 ArtMethod* m = check_vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
6828 CHECK(m != nullptr);
6829
Alex Light1f3925d2016-09-07 12:04:20 -07006830 CHECK_EQ(m->GetMethodIndexDuringLinking(), i)
David Sehr709b0702016-10-13 09:12:37 -07006831 << m->PrettyMethod()
6832 << " has an unexpected method index for its spot in the vtable for class"
6833 << klass->PrettyClass();
Alex Lighte64300b2015-12-15 15:02:47 -08006834 ArraySlice<ArtMethod> virtuals = klass->GetVirtualMethodsSliceUnchecked(pointer_size);
6835 auto is_same_method = [m] (const ArtMethod& meth) {
6836 return &meth == m;
6837 };
6838 CHECK((super_vtable_length > i && superclass->GetVTableEntry(i, pointer_size) == m) ||
6839 std::find_if(virtuals.begin(), virtuals.end(), is_same_method) != virtuals.end())
David Sehr709b0702016-10-13 09:12:37 -07006840 << m->PrettyMethod() << " does not seem to be owned by current class "
6841 << klass->PrettyClass() << " or any of its superclasses!";
Alex Lighte64300b2015-12-15 15:02:47 -08006842 }
6843}
6844
Alex Light1f3925d2016-09-07 12:04:20 -07006845// Check to make sure the vtable does not have duplicates. Duplicates could cause problems when a
6846// method is overridden in a subclass.
6847static void CheckVTableHasNoDuplicates(Thread* self,
6848 Handle<mirror::Class> klass,
6849 PointerSize pointer_size)
6850 REQUIRES_SHARED(Locks::mutator_lock_) {
6851 StackHandleScope<1> hs(self);
6852 Handle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
6853 int32_t num_entries = vtable->GetLength();
6854 for (int32_t i = 0; i < num_entries; i++) {
6855 ArtMethod* vtable_entry = vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
6856 // Don't bother if we cannot 'see' the vtable entry (i.e. it is a package-private member maybe).
6857 if (!klass->CanAccessMember(vtable_entry->GetDeclaringClass(),
6858 vtable_entry->GetAccessFlags())) {
6859 continue;
6860 }
6861 MethodNameAndSignatureComparator name_comparator(
6862 vtable_entry->GetInterfaceMethodIfProxy(pointer_size));
Alex Lightc7a420c2016-10-18 14:33:18 -07006863 for (int32_t j = i + 1; j < num_entries; j++) {
Alex Light1f3925d2016-09-07 12:04:20 -07006864 ArtMethod* other_entry = vtable->GetElementPtrSize<ArtMethod*>(j, pointer_size);
Alex Lightc7a420c2016-10-18 14:33:18 -07006865 if (!klass->CanAccessMember(other_entry->GetDeclaringClass(),
6866 other_entry->GetAccessFlags())) {
6867 continue;
6868 }
Alex Light1f3925d2016-09-07 12:04:20 -07006869 CHECK(vtable_entry != other_entry &&
6870 !name_comparator.HasSameNameAndSignature(
6871 other_entry->GetInterfaceMethodIfProxy(pointer_size)))
6872 << "vtable entries " << i << " and " << j << " are identical for "
Alex Lightc7a420c2016-10-18 14:33:18 -07006873 << klass->PrettyClass() << " in method " << vtable_entry->PrettyMethod() << " (0x"
6874 << std::hex << reinterpret_cast<uintptr_t>(vtable_entry) << ") and "
6875 << other_entry->PrettyMethod() << " (0x" << std::hex
6876 << reinterpret_cast<uintptr_t>(other_entry) << ")";
Alex Light1f3925d2016-09-07 12:04:20 -07006877 }
6878 }
6879}
6880
6881static void SanityCheckVTable(Thread* self, Handle<mirror::Class> klass, PointerSize pointer_size)
6882 REQUIRES_SHARED(Locks::mutator_lock_) {
6883 CheckClassOwnsVTableEntries(self, klass, pointer_size);
6884 CheckVTableHasNoDuplicates(self, klass, pointer_size);
6885}
6886
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006887void ClassLinker::FillImtFromSuperClass(Handle<mirror::Class> klass,
6888 ArtMethod* unimplemented_method,
6889 ArtMethod* imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006890 bool* new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006891 ArtMethod** imt) {
Alex Light705ad492015-09-21 11:36:30 -07006892 DCHECK(klass->HasSuperClass());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006893 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006894 if (super_class->ShouldHaveImt()) {
6895 ImTable* super_imt = super_class->GetImt(image_pointer_size_);
6896 for (size_t i = 0; i < ImTable::kSize; ++i) {
6897 imt[i] = super_imt->Get(i, image_pointer_size_);
Alex Light705ad492015-09-21 11:36:30 -07006898 }
6899 } else {
6900 // No imt in the super class, need to reconstruct from the iftable.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006901 ObjPtr<mirror::IfTable> if_table = super_class->GetIfTable();
Mathieu Chartier6beced42016-11-15 15:51:31 -08006902 if (if_table->Count() != 0) {
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006903 // Ignore copied methods since we will handle these in LinkInterfaceMethods.
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006904 FillIMTFromIfTable(if_table,
6905 unimplemented_method,
6906 imt_conflict_method,
6907 klass.Get(),
6908 /*create_conflict_table*/false,
6909 /*ignore_copied_methods*/true,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006910 /*out*/new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006911 /*out*/imt);
Alex Light705ad492015-09-21 11:36:30 -07006912 }
6913 }
6914}
6915
Vladimir Marko921094a2017-01-12 18:37:06 +00006916class ClassLinker::LinkInterfaceMethodsHelper {
6917 public:
6918 LinkInterfaceMethodsHelper(ClassLinker* class_linker,
6919 Handle<mirror::Class> klass,
6920 Thread* self,
6921 Runtime* runtime)
6922 : class_linker_(class_linker),
6923 klass_(klass),
6924 method_alignment_(ArtMethod::Alignment(class_linker->GetImagePointerSize())),
6925 method_size_(ArtMethod::Size(class_linker->GetImagePointerSize())),
6926 self_(self),
6927 stack_(runtime->GetLinearAlloc()->GetArenaPool()),
6928 allocator_(&stack_),
6929 default_conflict_methods_(allocator_.Adapter()),
6930 overriding_default_conflict_methods_(allocator_.Adapter()),
6931 miranda_methods_(allocator_.Adapter()),
6932 default_methods_(allocator_.Adapter()),
6933 overriding_default_methods_(allocator_.Adapter()),
6934 move_table_(allocator_.Adapter()) {
6935 }
6936
6937 ArtMethod* FindMethod(ArtMethod* interface_method,
6938 MethodNameAndSignatureComparator& interface_name_comparator,
6939 ArtMethod* vtable_impl)
6940 REQUIRES_SHARED(Locks::mutator_lock_);
6941
6942 ArtMethod* GetOrCreateMirandaMethod(ArtMethod* interface_method,
6943 MethodNameAndSignatureComparator& interface_name_comparator)
6944 REQUIRES_SHARED(Locks::mutator_lock_);
6945
6946 bool HasNewVirtuals() const {
6947 return !(miranda_methods_.empty() &&
6948 default_methods_.empty() &&
6949 overriding_default_methods_.empty() &&
6950 overriding_default_conflict_methods_.empty() &&
6951 default_conflict_methods_.empty());
6952 }
6953
6954 void ReallocMethods() REQUIRES_SHARED(Locks::mutator_lock_);
6955
6956 ObjPtr<mirror::PointerArray> UpdateVtable(
6957 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
6958 ObjPtr<mirror::PointerArray> old_vtable) REQUIRES_SHARED(Locks::mutator_lock_);
6959
6960 void UpdateIfTable(Handle<mirror::IfTable> iftable) REQUIRES_SHARED(Locks::mutator_lock_);
6961
6962 void UpdateIMT(ArtMethod** out_imt);
6963
6964 void CheckNoStaleMethodsInDexCache() REQUIRES_SHARED(Locks::mutator_lock_) {
6965 if (kIsDebugBuild) {
6966 PointerSize pointer_size = class_linker_->GetImagePointerSize();
6967 // Check that there are no stale methods are in the dex cache array.
6968 auto* resolved_methods = klass_->GetDexCache()->GetResolvedMethods();
6969 for (size_t i = 0, count = klass_->GetDexCache()->NumResolvedMethods(); i < count; ++i) {
6970 auto* m = mirror::DexCache::GetElementPtrSize(resolved_methods, i, pointer_size);
6971 CHECK(move_table_.find(m) == move_table_.end() ||
6972 // The original versions of copied methods will still be present so allow those too.
6973 // Note that if the first check passes this might fail to GetDeclaringClass().
6974 std::find_if(m->GetDeclaringClass()->GetMethods(pointer_size).begin(),
6975 m->GetDeclaringClass()->GetMethods(pointer_size).end(),
6976 [m] (ArtMethod& meth) {
6977 return &meth == m;
6978 }) != m->GetDeclaringClass()->GetMethods(pointer_size).end())
6979 << "Obsolete method " << m->PrettyMethod() << " is in dex cache!";
6980 }
6981 }
6982 }
6983
6984 void ClobberOldMethods(LengthPrefixedArray<ArtMethod>* old_methods,
6985 LengthPrefixedArray<ArtMethod>* methods) {
6986 if (kIsDebugBuild) {
6987 CHECK(methods != nullptr);
6988 // Put some random garbage in old methods to help find stale pointers.
6989 if (methods != old_methods && old_methods != nullptr) {
6990 // Need to make sure the GC is not running since it could be scanning the methods we are
6991 // about to overwrite.
6992 ScopedThreadStateChange tsc(self_, kSuspended);
6993 gc::ScopedGCCriticalSection gcs(self_,
6994 gc::kGcCauseClassLinker,
6995 gc::kCollectorTypeClassLinker);
6996 const size_t old_size = LengthPrefixedArray<ArtMethod>::ComputeSize(old_methods->size(),
6997 method_size_,
6998 method_alignment_);
6999 memset(old_methods, 0xFEu, old_size);
7000 }
7001 }
7002 }
7003
7004 private:
7005 size_t NumberOfNewVirtuals() const {
7006 return miranda_methods_.size() +
7007 default_methods_.size() +
7008 overriding_default_conflict_methods_.size() +
7009 overriding_default_methods_.size() +
7010 default_conflict_methods_.size();
7011 }
7012
7013 bool FillTables() REQUIRES_SHARED(Locks::mutator_lock_) {
7014 return !klass_->IsInterface();
7015 }
7016
7017 void LogNewVirtuals() const REQUIRES_SHARED(Locks::mutator_lock_) {
7018 DCHECK(!klass_->IsInterface() || (default_methods_.empty() && miranda_methods_.empty()))
7019 << "Interfaces should only have default-conflict methods appended to them.";
7020 VLOG(class_linker) << mirror::Class::PrettyClass(klass_.Get()) << ": miranda_methods="
7021 << miranda_methods_.size()
7022 << " default_methods=" << default_methods_.size()
7023 << " overriding_default_methods=" << overriding_default_methods_.size()
7024 << " default_conflict_methods=" << default_conflict_methods_.size()
7025 << " overriding_default_conflict_methods="
7026 << overriding_default_conflict_methods_.size();
7027 }
7028
7029 ClassLinker* class_linker_;
7030 Handle<mirror::Class> klass_;
7031 size_t method_alignment_;
7032 size_t method_size_;
7033 Thread* const self_;
7034
7035 // These are allocated on the heap to begin, we then transfer to linear alloc when we re-create
7036 // the virtual methods array.
7037 // Need to use low 4GB arenas for compiler or else the pointers wont fit in 32 bit method array
7038 // during cross compilation.
7039 // Use the linear alloc pool since this one is in the low 4gb for the compiler.
7040 ArenaStack stack_;
7041 ScopedArenaAllocator allocator_;
7042
7043 ScopedArenaVector<ArtMethod*> default_conflict_methods_;
7044 ScopedArenaVector<ArtMethod*> overriding_default_conflict_methods_;
7045 ScopedArenaVector<ArtMethod*> miranda_methods_;
7046 ScopedArenaVector<ArtMethod*> default_methods_;
7047 ScopedArenaVector<ArtMethod*> overriding_default_methods_;
7048
7049 ScopedArenaUnorderedMap<ArtMethod*, ArtMethod*> move_table_;
7050};
7051
7052ArtMethod* ClassLinker::LinkInterfaceMethodsHelper::FindMethod(
7053 ArtMethod* interface_method,
7054 MethodNameAndSignatureComparator& interface_name_comparator,
7055 ArtMethod* vtable_impl) {
7056 ArtMethod* current_method = nullptr;
7057 switch (class_linker_->FindDefaultMethodImplementation(self_,
7058 interface_method,
7059 klass_,
7060 /*out*/&current_method)) {
7061 case DefaultMethodSearchResult::kDefaultConflict: {
7062 // Default method conflict.
7063 DCHECK(current_method == nullptr);
7064 ArtMethod* default_conflict_method = nullptr;
7065 if (vtable_impl != nullptr && vtable_impl->IsDefaultConflicting()) {
7066 // We can reuse the method from the superclass, don't bother adding it to virtuals.
7067 default_conflict_method = vtable_impl;
7068 } else {
7069 // See if we already have a conflict method for this method.
7070 ArtMethod* preexisting_conflict = FindSameNameAndSignature(
7071 interface_name_comparator,
7072 default_conflict_methods_,
7073 overriding_default_conflict_methods_);
7074 if (LIKELY(preexisting_conflict != nullptr)) {
7075 // We already have another conflict we can reuse.
7076 default_conflict_method = preexisting_conflict;
7077 } else {
7078 // Note that we do this even if we are an interface since we need to create this and
7079 // cannot reuse another classes.
7080 // Create a new conflict method for this to use.
7081 default_conflict_method = reinterpret_cast<ArtMethod*>(allocator_.Alloc(method_size_));
7082 new(default_conflict_method) ArtMethod(interface_method,
7083 class_linker_->GetImagePointerSize());
7084 if (vtable_impl == nullptr) {
7085 // Save the conflict method. We need to add it to the vtable.
7086 default_conflict_methods_.push_back(default_conflict_method);
7087 } else {
7088 // Save the conflict method but it is already in the vtable.
7089 overriding_default_conflict_methods_.push_back(default_conflict_method);
7090 }
7091 }
7092 }
7093 current_method = default_conflict_method;
7094 break;
7095 } // case kDefaultConflict
7096 case DefaultMethodSearchResult::kDefaultFound: {
7097 DCHECK(current_method != nullptr);
7098 // Found a default method.
7099 if (vtable_impl != nullptr &&
7100 current_method->GetDeclaringClass() == vtable_impl->GetDeclaringClass()) {
7101 // We found a default method but it was the same one we already have from our
7102 // superclass. Don't bother adding it to our vtable again.
7103 current_method = vtable_impl;
7104 } else if (LIKELY(FillTables())) {
7105 // Interfaces don't need to copy default methods since they don't have vtables.
7106 // Only record this default method if it is new to save space.
7107 // TODO It might be worthwhile to copy default methods on interfaces anyway since it
7108 // would make lookup for interface super much faster. (We would only need to scan
7109 // the iftable to find if there is a NSME or AME.)
7110 ArtMethod* old = FindSameNameAndSignature(interface_name_comparator,
7111 default_methods_,
7112 overriding_default_methods_);
7113 if (old == nullptr) {
7114 // We found a default method implementation and there were no conflicts.
7115 if (vtable_impl == nullptr) {
7116 // Save the default method. We need to add it to the vtable.
7117 default_methods_.push_back(current_method);
7118 } else {
7119 // Save the default method but it is already in the vtable.
7120 overriding_default_methods_.push_back(current_method);
7121 }
7122 } else {
7123 CHECK(old == current_method) << "Multiple default implementations selected!";
7124 }
7125 }
7126 break;
7127 } // case kDefaultFound
7128 case DefaultMethodSearchResult::kAbstractFound: {
7129 DCHECK(current_method == nullptr);
7130 // Abstract method masks all defaults.
7131 if (vtable_impl != nullptr &&
7132 vtable_impl->IsAbstract() &&
7133 !vtable_impl->IsDefaultConflicting()) {
7134 // We need to make this an abstract method but the version in the vtable already is so
7135 // don't do anything.
7136 current_method = vtable_impl;
7137 }
7138 break;
7139 } // case kAbstractFound
7140 }
7141 return current_method;
7142}
7143
7144ArtMethod* ClassLinker::LinkInterfaceMethodsHelper::GetOrCreateMirandaMethod(
7145 ArtMethod* interface_method,
7146 MethodNameAndSignatureComparator& interface_name_comparator) {
7147 // Find out if there is already a miranda method we can use.
7148 ArtMethod* miranda_method = FindSameNameAndSignature(interface_name_comparator,
7149 miranda_methods_);
7150 if (miranda_method == nullptr) {
7151 DCHECK(interface_method->IsAbstract()) << interface_method->PrettyMethod();
7152 miranda_method = reinterpret_cast<ArtMethod*>(allocator_.Alloc(method_size_));
7153 CHECK(miranda_method != nullptr);
7154 // Point the interface table at a phantom slot.
7155 new(miranda_method) ArtMethod(interface_method, class_linker_->GetImagePointerSize());
7156 miranda_methods_.push_back(miranda_method);
7157 }
7158 return miranda_method;
7159}
7160
7161void ClassLinker::LinkInterfaceMethodsHelper::ReallocMethods() {
7162 LogNewVirtuals();
7163
7164 const size_t old_method_count = klass_->NumMethods();
7165 const size_t new_method_count = old_method_count + NumberOfNewVirtuals();
7166 DCHECK_NE(old_method_count, new_method_count);
7167
7168 // Attempt to realloc to save RAM if possible.
7169 LengthPrefixedArray<ArtMethod>* old_methods = klass_->GetMethodsPtr();
7170 // The Realloced virtual methods aren't visible from the class roots, so there is no issue
7171 // where GCs could attempt to mark stale pointers due to memcpy. And since we overwrite the
7172 // realloced memory with out->CopyFrom, we are guaranteed to have objects in the to space since
7173 // CopyFrom has internal read barriers.
7174 //
7175 // TODO We should maybe move some of this into mirror::Class or at least into another method.
7176 const size_t old_size = LengthPrefixedArray<ArtMethod>::ComputeSize(old_method_count,
7177 method_size_,
7178 method_alignment_);
7179 const size_t new_size = LengthPrefixedArray<ArtMethod>::ComputeSize(new_method_count,
7180 method_size_,
7181 method_alignment_);
7182 const size_t old_methods_ptr_size = (old_methods != nullptr) ? old_size : 0;
7183 auto* methods = reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
7184 Runtime::Current()->GetLinearAlloc()->Realloc(
7185 self_, old_methods, old_methods_ptr_size, new_size));
7186 CHECK(methods != nullptr); // Native allocation failure aborts.
7187
7188 PointerSize pointer_size = class_linker_->GetImagePointerSize();
7189 if (methods != old_methods) {
7190 // Maps from heap allocated miranda method to linear alloc miranda method.
7191 StrideIterator<ArtMethod> out = methods->begin(method_size_, method_alignment_);
7192 // Copy over the old methods.
7193 for (auto& m : klass_->GetMethods(pointer_size)) {
7194 move_table_.emplace(&m, &*out);
7195 // The CopyFrom is only necessary to not miss read barriers since Realloc won't do read
7196 // barriers when it copies.
7197 out->CopyFrom(&m, pointer_size);
7198 ++out;
7199 }
7200 }
7201 StrideIterator<ArtMethod> out(methods->begin(method_size_, method_alignment_) + old_method_count);
7202 // Copy over miranda methods before copying vtable since CopyOf may cause thread suspension and
7203 // we want the roots of the miranda methods to get visited.
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007204 for (size_t i = 0; i < miranda_methods_.size(); ++i) {
7205 ArtMethod* mir_method = miranda_methods_[i];
Vladimir Marko921094a2017-01-12 18:37:06 +00007206 ArtMethod& new_method = *out;
7207 new_method.CopyFrom(mir_method, pointer_size);
7208 new_method.SetAccessFlags(new_method.GetAccessFlags() | kAccMiranda | kAccCopied);
7209 DCHECK_NE(new_method.GetAccessFlags() & kAccAbstract, 0u)
7210 << "Miranda method should be abstract!";
7211 move_table_.emplace(mir_method, &new_method);
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007212 // Update the entry in the method array, as the array will be used for future lookups,
7213 // where thread suspension is allowed.
7214 // As such, the array should not contain locally allocated ArtMethod, otherwise the GC
7215 // would not see them.
7216 miranda_methods_[i] = &new_method;
Vladimir Marko921094a2017-01-12 18:37:06 +00007217 ++out;
7218 }
7219 // We need to copy the default methods into our own method table since the runtime requires that
7220 // every method on a class's vtable be in that respective class's virtual method table.
7221 // NOTE This means that two classes might have the same implementation of a method from the same
7222 // interface but will have different ArtMethod*s for them. This also means we cannot compare a
7223 // default method found on a class with one found on the declaring interface directly and must
7224 // look at the declaring class to determine if they are the same.
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007225 for (ScopedArenaVector<ArtMethod*>* methods_vec : {&default_methods_,
7226 &overriding_default_methods_}) {
7227 for (size_t i = 0; i < methods_vec->size(); ++i) {
7228 ArtMethod* def_method = (*methods_vec)[i];
Vladimir Marko921094a2017-01-12 18:37:06 +00007229 ArtMethod& new_method = *out;
7230 new_method.CopyFrom(def_method, pointer_size);
7231 // Clear the kAccSkipAccessChecks flag if it is present. Since this class hasn't been
7232 // verified yet it shouldn't have methods that are skipping access checks.
7233 // TODO This is rather arbitrary. We should maybe support classes where only some of its
7234 // methods are skip_access_checks.
7235 constexpr uint32_t kSetFlags = kAccDefault | kAccCopied;
7236 constexpr uint32_t kMaskFlags = ~kAccSkipAccessChecks;
7237 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags);
7238 move_table_.emplace(def_method, &new_method);
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007239 // Update the entry in the method array, as the array will be used for future lookups,
7240 // where thread suspension is allowed.
7241 // As such, the array should not contain locally allocated ArtMethod, otherwise the GC
7242 // would not see them.
7243 (*methods_vec)[i] = &new_method;
Vladimir Marko921094a2017-01-12 18:37:06 +00007244 ++out;
7245 }
7246 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007247 for (ScopedArenaVector<ArtMethod*>* methods_vec : {&default_conflict_methods_,
7248 &overriding_default_conflict_methods_}) {
7249 for (size_t i = 0; i < methods_vec->size(); ++i) {
7250 ArtMethod* conf_method = (*methods_vec)[i];
Vladimir Marko921094a2017-01-12 18:37:06 +00007251 ArtMethod& new_method = *out;
7252 new_method.CopyFrom(conf_method, pointer_size);
7253 // This is a type of default method (there are default method impls, just a conflict) so
7254 // mark this as a default, non-abstract method, since thats what it is. Also clear the
7255 // kAccSkipAccessChecks bit since this class hasn't been verified yet it shouldn't have
7256 // methods that are skipping access checks.
7257 constexpr uint32_t kSetFlags = kAccDefault | kAccDefaultConflict | kAccCopied;
7258 constexpr uint32_t kMaskFlags = ~(kAccAbstract | kAccSkipAccessChecks);
7259 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags);
7260 DCHECK(new_method.IsDefaultConflicting());
7261 // The actual method might or might not be marked abstract since we just copied it from a
7262 // (possibly default) interface method. We need to set it entry point to be the bridge so
7263 // that the compiler will not invoke the implementation of whatever method we copied from.
7264 EnsureThrowsInvocationError(class_linker_, &new_method);
7265 move_table_.emplace(conf_method, &new_method);
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007266 // Update the entry in the method array, as the array will be used for future lookups,
7267 // where thread suspension is allowed.
7268 // As such, the array should not contain locally allocated ArtMethod, otherwise the GC
7269 // would not see them.
7270 (*methods_vec)[i] = &new_method;
Vladimir Marko921094a2017-01-12 18:37:06 +00007271 ++out;
7272 }
7273 }
7274 methods->SetSize(new_method_count);
7275 class_linker_->UpdateClassMethods(klass_.Get(), methods);
7276}
7277
7278ObjPtr<mirror::PointerArray> ClassLinker::LinkInterfaceMethodsHelper::UpdateVtable(
7279 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
7280 ObjPtr<mirror::PointerArray> old_vtable) {
7281 // Update the vtable to the new method structures. We can skip this for interfaces since they
7282 // do not have vtables.
7283 const size_t old_vtable_count = old_vtable->GetLength();
7284 const size_t new_vtable_count = old_vtable_count +
7285 miranda_methods_.size() +
7286 default_methods_.size() +
7287 default_conflict_methods_.size();
7288
7289 ObjPtr<mirror::PointerArray> vtable =
7290 down_cast<mirror::PointerArray*>(old_vtable->CopyOf(self_, new_vtable_count));
7291 if (UNLIKELY(vtable == nullptr)) {
7292 self_->AssertPendingOOMException();
7293 return nullptr;
7294 }
7295
7296 size_t vtable_pos = old_vtable_count;
7297 PointerSize pointer_size = class_linker_->GetImagePointerSize();
7298 // Update all the newly copied method's indexes so they denote their placement in the vtable.
7299 for (const ScopedArenaVector<ArtMethod*>& methods_vec : {default_methods_,
7300 default_conflict_methods_,
7301 miranda_methods_}) {
7302 // These are the functions that are not already in the vtable!
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007303 for (ArtMethod* new_vtable_method : methods_vec) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007304 // Leave the declaring class alone the method's dex_code_item_offset_ and dex_method_index_
7305 // fields are references into the dex file the method was defined in. Since the ArtMethod
7306 // does not store that information it uses declaring_class_->dex_cache_.
7307 new_vtable_method->SetMethodIndex(0xFFFF & vtable_pos);
7308 vtable->SetElementPtrSize(vtable_pos, new_vtable_method, pointer_size);
7309 ++vtable_pos;
7310 }
7311 }
7312 DCHECK_EQ(vtable_pos, new_vtable_count);
7313
7314 // Update old vtable methods. We use the default_translations map to figure out what each
7315 // vtable entry should be updated to, if they need to be at all.
7316 for (size_t i = 0; i < old_vtable_count; ++i) {
7317 ArtMethod* translated_method = vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
7318 // Try and find what we need to change this method to.
7319 auto translation_it = default_translations.find(i);
Vladimir Marko921094a2017-01-12 18:37:06 +00007320 if (translation_it != default_translations.end()) {
7321 if (translation_it->second.IsInConflict()) {
7322 // Find which conflict method we are to use for this method.
7323 MethodNameAndSignatureComparator old_method_comparator(
7324 translated_method->GetInterfaceMethodIfProxy(pointer_size));
7325 // We only need to look through overriding_default_conflict_methods since this is an
7326 // overridden method we are fixing up here.
7327 ArtMethod* new_conflict_method = FindSameNameAndSignature(
7328 old_method_comparator, overriding_default_conflict_methods_);
7329 CHECK(new_conflict_method != nullptr) << "Expected a conflict method!";
7330 translated_method = new_conflict_method;
7331 } else if (translation_it->second.IsAbstract()) {
7332 // Find which miranda method we are to use for this method.
7333 MethodNameAndSignatureComparator old_method_comparator(
7334 translated_method->GetInterfaceMethodIfProxy(pointer_size));
7335 ArtMethod* miranda_method = FindSameNameAndSignature(old_method_comparator,
7336 miranda_methods_);
7337 DCHECK(miranda_method != nullptr);
7338 translated_method = miranda_method;
7339 } else {
7340 // Normal default method (changed from an older default or abstract interface method).
7341 DCHECK(translation_it->second.IsTranslation());
7342 translated_method = translation_it->second.GetTranslation();
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007343 auto it = move_table_.find(translated_method);
7344 DCHECK(it != move_table_.end());
7345 translated_method = it->second;
Vladimir Marko921094a2017-01-12 18:37:06 +00007346 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007347 } else {
7348 auto it = move_table_.find(translated_method);
7349 translated_method = (it != move_table_.end()) ? it->second : nullptr;
Vladimir Marko921094a2017-01-12 18:37:06 +00007350 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007351
7352 if (translated_method != nullptr) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007353 // Make sure the new_methods index is set.
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007354 if (translated_method->GetMethodIndexDuringLinking() != i) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007355 if (kIsDebugBuild) {
7356 auto* methods = klass_->GetMethodsPtr();
7357 CHECK_LE(reinterpret_cast<uintptr_t>(&*methods->begin(method_size_, method_alignment_)),
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007358 reinterpret_cast<uintptr_t>(translated_method));
7359 CHECK_LT(reinterpret_cast<uintptr_t>(translated_method),
Vladimir Marko921094a2017-01-12 18:37:06 +00007360 reinterpret_cast<uintptr_t>(&*methods->end(method_size_, method_alignment_)));
7361 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007362 translated_method->SetMethodIndex(0xFFFF & i);
Vladimir Marko921094a2017-01-12 18:37:06 +00007363 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007364 vtable->SetElementPtrSize(i, translated_method, pointer_size);
Vladimir Marko921094a2017-01-12 18:37:06 +00007365 }
7366 }
7367 klass_->SetVTable(vtable.Ptr());
7368 return vtable;
7369}
7370
7371void ClassLinker::LinkInterfaceMethodsHelper::UpdateIfTable(Handle<mirror::IfTable> iftable) {
7372 PointerSize pointer_size = class_linker_->GetImagePointerSize();
7373 const size_t ifcount = klass_->GetIfTableCount();
7374 // Go fix up all the stale iftable pointers.
7375 for (size_t i = 0; i < ifcount; ++i) {
7376 for (size_t j = 0, count = iftable->GetMethodArrayCount(i); j < count; ++j) {
7377 auto* method_array = iftable->GetMethodArray(i);
7378 auto* m = method_array->GetElementPtrSize<ArtMethod*>(j, pointer_size);
7379 DCHECK(m != nullptr) << klass_->PrettyClass();
7380 auto it = move_table_.find(m);
7381 if (it != move_table_.end()) {
7382 auto* new_m = it->second;
7383 DCHECK(new_m != nullptr) << klass_->PrettyClass();
7384 method_array->SetElementPtrSize(j, new_m, pointer_size);
7385 }
7386 }
7387 }
7388}
7389
7390void ClassLinker::LinkInterfaceMethodsHelper::UpdateIMT(ArtMethod** out_imt) {
7391 // Fix up IMT next.
7392 for (size_t i = 0; i < ImTable::kSize; ++i) {
7393 auto it = move_table_.find(out_imt[i]);
7394 if (it != move_table_.end()) {
7395 out_imt[i] = it->second;
7396 }
7397 }
7398}
7399
Alex Light705ad492015-09-21 11:36:30 -07007400// TODO This method needs to be split up into several smaller methods.
Alex Lighteb7c1442015-08-31 13:17:42 -07007401bool ClassLinker::LinkInterfaceMethods(
7402 Thread* self,
7403 Handle<mirror::Class> klass,
Alex Light9139e002015-10-09 15:59:48 -07007404 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007405 bool* out_new_conflict,
Alex Lighteb7c1442015-08-31 13:17:42 -07007406 ArtMethod** out_imt) {
7407 StackHandleScope<3> hs(self);
7408 Runtime* const runtime = Runtime::Current();
Alex Light705ad492015-09-21 11:36:30 -07007409
7410 const bool is_interface = klass->IsInterface();
Alex Lighteb7c1442015-08-31 13:17:42 -07007411 const bool has_superclass = klass->HasSuperClass();
Alex Light705ad492015-09-21 11:36:30 -07007412 const bool fill_tables = !is_interface;
Alex Lighteb7c1442015-08-31 13:17:42 -07007413 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
Alex Lighteb7c1442015-08-31 13:17:42 -07007414 const size_t ifcount = klass->GetIfTableCount();
7415
Vladimir Marko921094a2017-01-12 18:37:06 +00007416 Handle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable()));
Mathieu Chartiere401d142015-04-22 13:56:20 -07007417
7418 MutableHandle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
7419 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
Alex Light9139e002015-10-09 15:59:48 -07007420 ArtMethod* const imt_conflict_method = runtime->GetImtConflictMethod();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07007421 // Copy the IMT from the super class if possible.
Alex Light705ad492015-09-21 11:36:30 -07007422 const bool extend_super_iftable = has_superclass;
7423 if (has_superclass && fill_tables) {
7424 FillImtFromSuperClass(klass,
Alex Light705ad492015-09-21 11:36:30 -07007425 unimplemented_method,
7426 imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007427 out_new_conflict,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07007428 out_imt);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07007429 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07007430 // Allocate method arrays before since we don't want miss visiting miranda method roots due to
7431 // thread suspension.
Alex Light705ad492015-09-21 11:36:30 -07007432 if (fill_tables) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007433 if (!AllocateIfTableMethodArrays(self, klass, iftable)) {
7434 return false;
Mathieu Chartiere401d142015-04-22 13:56:20 -07007435 }
7436 }
7437
Vladimir Marko921094a2017-01-12 18:37:06 +00007438 LinkInterfaceMethodsHelper helper(this, klass, self, runtime);
7439
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007440 auto* old_cause = self->StartAssertNoThreadSuspension(
Mathieu Chartiere401d142015-04-22 13:56:20 -07007441 "Copying ArtMethods for LinkInterfaceMethods");
Alex Light9139e002015-10-09 15:59:48 -07007442 // Going in reverse to ensure that we will hit abstract methods that override defaults before the
7443 // defaults. This means we don't need to do any trickery when creating the Miranda methods, since
7444 // they will already be null. This has the additional benefit that the declarer of a miranda
7445 // method will actually declare an abstract method.
7446 for (size_t i = ifcount; i != 0; ) {
7447 --i;
7448
7449 DCHECK_GE(i, 0u);
7450 DCHECK_LT(i, ifcount);
7451
Alex Light705ad492015-09-21 11:36:30 -07007452 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods();
Mathieu Chartiere401d142015-04-22 13:56:20 -07007453 if (num_methods > 0) {
7454 StackHandleScope<2> hs2(self);
7455 const bool is_super = i < super_ifcount;
7456 const bool super_interface = is_super && extend_super_iftable;
Alex Light705ad492015-09-21 11:36:30 -07007457 // We don't actually create or fill these tables for interfaces, we just copy some methods for
7458 // conflict methods. Just set this as nullptr in those cases.
7459 Handle<mirror::PointerArray> method_array(fill_tables
7460 ? hs2.NewHandle(iftable->GetMethodArray(i))
7461 : hs2.NewHandle<mirror::PointerArray>(nullptr));
Mathieu Chartiere401d142015-04-22 13:56:20 -07007462
Alex Lighte64300b2015-12-15 15:02:47 -08007463 ArraySlice<ArtMethod> input_virtual_methods;
Mathieu Chartier9865bde2015-12-21 09:58:16 -08007464 ScopedNullHandle<mirror::PointerArray> null_handle;
7465 Handle<mirror::PointerArray> input_vtable_array(null_handle);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007466 int32_t input_array_length = 0;
Alex Lighte64300b2015-12-15 15:02:47 -08007467
Alex Light9139e002015-10-09 15:59:48 -07007468 // TODO Cleanup Needed: In the presence of default methods this optimization is rather dirty
7469 // and confusing. Default methods should always look through all the superclasses
7470 // because they are the last choice of an implementation. We get around this by looking
7471 // at the super-classes iftable methods (copied into method_array previously) when we are
7472 // looking for the implementation of a super-interface method but that is rather dirty.
Alex Lighte64300b2015-12-15 15:02:47 -08007473 bool using_virtuals;
Alex Light705ad492015-09-21 11:36:30 -07007474 if (super_interface || is_interface) {
Alex Lighte64300b2015-12-15 15:02:47 -08007475 // If we are overwriting a super class interface, try to only virtual methods instead of the
Mathieu Chartiere401d142015-04-22 13:56:20 -07007476 // whole vtable.
Alex Lighte64300b2015-12-15 15:02:47 -08007477 using_virtuals = true;
7478 input_virtual_methods = klass->GetDeclaredMethodsSlice(image_pointer_size_);
7479 input_array_length = input_virtual_methods.size();
Mathieu Chartiere401d142015-04-22 13:56:20 -07007480 } else {
Alex Lighte64300b2015-12-15 15:02:47 -08007481 // For a new interface, however, we need the whole vtable in case a new
7482 // interface method is implemented in the whole superclass.
7483 using_virtuals = false;
Andreas Gampefa4333d2017-02-14 11:10:34 -08007484 DCHECK(vtable != nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007485 input_vtable_array = vtable;
7486 input_array_length = input_vtable_array->GetLength();
7487 }
Alex Lighte64300b2015-12-15 15:02:47 -08007488
Alex Lighteb7c1442015-08-31 13:17:42 -07007489 // For each method in interface
Ian Rogers62d6c772013-02-27 08:32:07 -08007490 for (size_t j = 0; j < num_methods; ++j) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007491 auto* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07007492 MethodNameAndSignatureComparator interface_name_comparator(
Mathieu Chartiere401d142015-04-22 13:56:20 -07007493 interface_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Andreas Gampe75a7db62016-09-26 12:04:26 -07007494 uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Alex Lighteb7c1442015-08-31 13:17:42 -07007495 ArtMethod** imt_ptr = &out_imt[imt_index];
Ian Rogers9bc81912012-10-11 21:43:36 -07007496 // For each method listed in the interface's method list, find the
7497 // matching method in our class's method list. We want to favor the
7498 // subclass over the superclass, which just requires walking
7499 // back from the end of the vtable. (This only matters if the
7500 // superclass defines a private method and this class redefines
7501 // it -- otherwise it would use the same vtable slot. In .dex files
7502 // those don't end up in the virtual method table, so it shouldn't
7503 // matter which direction we go. We walk it backward anyway.)
Alex Lighteb7c1442015-08-31 13:17:42 -07007504 //
7505 // To find defaults we need to do the same but also go over interfaces.
7506 bool found_impl = false;
Alex Light9139e002015-10-09 15:59:48 -07007507 ArtMethod* vtable_impl = nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07007508 for (int32_t k = input_array_length - 1; k >= 0; --k) {
Alex Lighte64300b2015-12-15 15:02:47 -08007509 ArtMethod* vtable_method = using_virtuals ?
7510 &input_virtual_methods[k] :
Mathieu Chartiere401d142015-04-22 13:56:20 -07007511 input_vtable_array->GetElementPtrSize<ArtMethod*>(k, image_pointer_size_);
7512 ArtMethod* vtable_method_for_name_comparison =
7513 vtable_method->GetInterfaceMethodIfProxy(image_pointer_size_);
Ian Rogers03b6eaf2014-10-28 09:34:57 -07007514 if (interface_name_comparator.HasSameNameAndSignature(
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07007515 vtable_method_for_name_comparison)) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07007516 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Mathieu Chartier4d122c12015-06-17 14:14:36 -07007517 // Must do EndAssertNoThreadSuspension before throw since the throw can cause
7518 // allocations.
7519 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007520 ThrowIllegalAccessError(klass.Get(),
Brian Carlstromf3632832014-05-20 15:36:53 -07007521 "Method '%s' implementing interface method '%s' is not public",
David Sehr709b0702016-10-13 09:12:37 -07007522 vtable_method->PrettyMethod().c_str(),
7523 interface_method->PrettyMethod().c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07007524 return false;
Alex Light9139e002015-10-09 15:59:48 -07007525 } else if (UNLIKELY(vtable_method->IsOverridableByDefaultMethod())) {
Alex Lighteb7c1442015-08-31 13:17:42 -07007526 // We might have a newer, better, default method for this, so we just skip it. If we
7527 // are still using this we will select it again when scanning for default methods. To
7528 // obviate the need to copy the method again we will make a note that we already found
7529 // a default here.
7530 // TODO This should be much cleaner.
Alex Light9139e002015-10-09 15:59:48 -07007531 vtable_impl = vtable_method;
Alex Lighteb7c1442015-08-31 13:17:42 -07007532 break;
7533 } else {
7534 found_impl = true;
Alex Light705ad492015-09-21 11:36:30 -07007535 if (LIKELY(fill_tables)) {
7536 method_array->SetElementPtrSize(j, vtable_method, image_pointer_size_);
7537 // Place method in imt if entry is empty, place conflict otherwise.
7538 SetIMTRef(unimplemented_method,
7539 imt_conflict_method,
Alex Light705ad492015-09-21 11:36:30 -07007540 vtable_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007541 /*out*/out_new_conflict,
Alex Light705ad492015-09-21 11:36:30 -07007542 /*out*/imt_ptr);
7543 }
Ian Rogers9bc81912012-10-11 21:43:36 -07007544 break;
7545 }
7546 }
Alex Light9139e002015-10-09 15:59:48 -07007547 }
7548 // Continue on to the next method if we are done.
7549 if (LIKELY(found_impl)) {
7550 continue;
7551 } else if (LIKELY(super_interface)) {
7552 // Don't look for a default implementation when the super-method is implemented directly
7553 // by the class.
7554 //
7555 // See if we can use the superclasses method and skip searching everything else.
7556 // Note: !found_impl && super_interface
7557 CHECK(extend_super_iftable);
7558 // If this is a super_interface method it is possible we shouldn't override it because a
7559 // superclass could have implemented it directly. We get the method the superclass used
7560 // to implement this to know if we can override it with a default method. Doing this is
7561 // safe since we know that the super_iftable is filled in so we can simply pull it from
7562 // there. We don't bother if this is not a super-classes interface since in that case we
7563 // have scanned the entire vtable anyway and would have found it.
7564 // TODO This is rather dirty but it is faster than searching through the entire vtable
7565 // every time.
7566 ArtMethod* supers_method =
7567 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
7568 DCHECK(supers_method != nullptr);
7569 DCHECK(interface_name_comparator.HasSameNameAndSignature(supers_method));
Alex Light705ad492015-09-21 11:36:30 -07007570 if (LIKELY(!supers_method->IsOverridableByDefaultMethod())) {
Alex Light9139e002015-10-09 15:59:48 -07007571 // The method is not overridable by a default method (i.e. it is directly implemented
7572 // in some class). Therefore move onto the next interface method.
7573 continue;
Alex Lightd6c2bfa2016-05-02 18:51:34 -07007574 } else {
7575 // If the super-classes method is override-able by a default method we need to keep
7576 // track of it since though it is override-able it is not guaranteed to be 'overridden'.
7577 // If it turns out not to be overridden and we did not keep track of it we might add it
Alex Light66630be2016-05-04 09:23:09 -07007578 // to the vtable twice, causing corruption (vtable entries having inconsistent and
7579 // illegal states, incorrect vtable size, and incorrect or inconsistent iftable entries)
7580 // in this class and any subclasses.
Alex Lightd6c2bfa2016-05-02 18:51:34 -07007581 DCHECK(vtable_impl == nullptr || vtable_impl == supers_method)
David Sehr709b0702016-10-13 09:12:37 -07007582 << "vtable_impl was " << ArtMethod::PrettyMethod(vtable_impl)
7583 << " and not 'nullptr' or "
7584 << supers_method->PrettyMethod()
7585 << " as expected. IFTable appears to be corrupt!";
Alex Lightd6c2bfa2016-05-02 18:51:34 -07007586 vtable_impl = supers_method;
Alex Light9139e002015-10-09 15:59:48 -07007587 }
7588 }
7589 // If we haven't found it yet we should search through the interfaces for default methods.
Vladimir Marko921094a2017-01-12 18:37:06 +00007590 ArtMethod* current_method = helper.FindMethod(interface_method,
7591 interface_name_comparator,
7592 vtable_impl);
Alex Light705ad492015-09-21 11:36:30 -07007593 if (LIKELY(fill_tables)) {
Alex Light12771082016-01-26 16:07:41 -08007594 if (current_method == nullptr && !super_interface) {
Alex Light705ad492015-09-21 11:36:30 -07007595 // We could not find an implementation for this method and since it is a brand new
7596 // interface we searched the entire vtable (and all default methods) for an
7597 // implementation but couldn't find one. We therefore need to make a miranda method.
Vladimir Marko921094a2017-01-12 18:37:06 +00007598 current_method = helper.GetOrCreateMirandaMethod(interface_method,
7599 interface_name_comparator);
Alex Light12771082016-01-26 16:07:41 -08007600 }
7601
7602 if (current_method != nullptr) {
7603 // We found a default method implementation. Record it in the iftable and IMT.
7604 method_array->SetElementPtrSize(j, current_method, image_pointer_size_);
7605 SetIMTRef(unimplemented_method,
7606 imt_conflict_method,
Alex Light12771082016-01-26 16:07:41 -08007607 current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007608 /*out*/out_new_conflict,
Alex Light12771082016-01-26 16:07:41 -08007609 /*out*/imt_ptr);
Alex Light9139e002015-10-09 15:59:48 -07007610 }
7611 }
Alex Light705ad492015-09-21 11:36:30 -07007612 } // For each method in interface end.
7613 } // if (num_methods > 0)
7614 } // For each interface.
Alex Light705ad492015-09-21 11:36:30 -07007615 // TODO don't extend virtuals of interface unless necessary (when is it?).
Vladimir Marko921094a2017-01-12 18:37:06 +00007616 if (helper.HasNewVirtuals()) {
7617 LengthPrefixedArray<ArtMethod>* old_methods = kIsDebugBuild ? klass->GetMethodsPtr() : nullptr;
7618 helper.ReallocMethods(); // No return value to check. Native allocation failure aborts.
7619 LengthPrefixedArray<ArtMethod>* methods = kIsDebugBuild ? klass->GetMethodsPtr() : nullptr;
7620
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007621 // Done copying methods, they are all roots in the class now, so we can end the no thread
Mathieu Chartiere401d142015-04-22 13:56:20 -07007622 // suspension assert.
7623 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007624
Alex Light705ad492015-09-21 11:36:30 -07007625 if (fill_tables) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007626 vtable.Assign(helper.UpdateVtable(default_translations, vtable.Get()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08007627 if (UNLIKELY(vtable == nullptr)) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007628 // The helper has already called self->AssertPendingOOMException();
Alex Light705ad492015-09-21 11:36:30 -07007629 return false;
7630 }
Vladimir Marko921094a2017-01-12 18:37:06 +00007631 helper.UpdateIfTable(iftable);
7632 helper.UpdateIMT(out_imt);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007633 }
Alex Light705ad492015-09-21 11:36:30 -07007634
Vladimir Marko921094a2017-01-12 18:37:06 +00007635 helper.CheckNoStaleMethodsInDexCache();
7636 helper.ClobberOldMethods(old_methods, methods);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007637 } else {
7638 self->EndAssertNoThreadSuspension(old_cause);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007639 }
Alex Light705ad492015-09-21 11:36:30 -07007640 if (kIsDebugBuild && !is_interface) {
Alex Light1f3925d2016-09-07 12:04:20 -07007641 SanityCheckVTable(self, klass, image_pointer_size_);
Elliott Hughes4681c802011-09-25 18:04:37 -07007642 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007643 return true;
7644}
7645
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007646bool ClassLinker::LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007647 CHECK(klass != nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007648 return LinkFields(self, klass, false, nullptr);
Brian Carlstrom4873d462011-08-21 15:23:39 -07007649}
7650
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007651bool ClassLinker::LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007652 CHECK(klass != nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007653 return LinkFields(self, klass, true, class_size);
Brian Carlstrom4873d462011-08-21 15:23:39 -07007654}
7655
Brian Carlstromdbc05252011-09-09 01:59:59 -07007656struct LinkFieldsComparator {
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07007657 explicit LinkFieldsComparator() REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07007658 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07007659 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Mathieu Chartierc7853442015-03-27 14:35:38 -07007660 bool operator()(ArtField* field1, ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08007661 NO_THREAD_SAFETY_ANALYSIS {
Fred Shih37f05ef2014-07-16 18:38:08 -07007662 // First come reference fields, then 64-bit, then 32-bit, and then 16-bit, then finally 8-bit.
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07007663 Primitive::Type type1 = field1->GetTypeAsPrimitiveType();
7664 Primitive::Type type2 = field2->GetTypeAsPrimitiveType();
Ian Rogersef7d42f2014-01-06 12:55:46 -08007665 if (type1 != type2) {
Vladimir Markod5777482014-11-12 17:02:02 +00007666 if (type1 == Primitive::kPrimNot) {
7667 // Reference always goes first.
7668 return true;
Ian Rogersef7d42f2014-01-06 12:55:46 -08007669 }
Vladimir Markod5777482014-11-12 17:02:02 +00007670 if (type2 == Primitive::kPrimNot) {
7671 // Reference always goes first.
7672 return false;
7673 }
7674 size_t size1 = Primitive::ComponentSize(type1);
7675 size_t size2 = Primitive::ComponentSize(type2);
7676 if (size1 != size2) {
7677 // Larger primitive types go first.
7678 return size1 > size2;
7679 }
7680 // Primitive types differ but sizes match. Arbitrarily order by primitive type.
7681 return type1 < type2;
Brian Carlstromdbc05252011-09-09 01:59:59 -07007682 }
Vladimir Marko7a7c1db2014-11-17 15:13:34 +00007683 // Same basic group? Then sort by dex field index. This is guaranteed to be sorted
7684 // by name and for equal names by type id index.
7685 // NOTE: This works also for proxies. Their static fields are assigned appropriate indexes.
7686 return field1->GetDexFieldIndex() < field2->GetDexFieldIndex();
Brian Carlstromdbc05252011-09-09 01:59:59 -07007687 }
7688};
7689
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007690bool ClassLinker::LinkFields(Thread* self,
7691 Handle<mirror::Class> klass,
7692 bool is_static,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007693 size_t* class_size) {
Ian Rogers7b078e82014-09-10 14:44:24 -07007694 self->AllowThreadSuspension();
Mathieu Chartierc7853442015-03-27 14:35:38 -07007695 const size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007696 LengthPrefixedArray<ArtField>* const fields = is_static ? klass->GetSFieldsPtr() :
7697 klass->GetIFieldsPtr();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007698
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007699 // Initialize field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07007700 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007701 if (is_static) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007702 field_offset = klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007703 } else {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007704 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007705 if (super_class != nullptr) {
Brian Carlstromf3632832014-05-20 15:36:53 -07007706 CHECK(super_class->IsResolved())
David Sehr709b0702016-10-13 09:12:37 -07007707 << klass->PrettyClass() << " " << super_class->PrettyClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007708 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007709 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007710 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007711
David Sehr709b0702016-10-13 09:12:37 -07007712 CHECK_EQ(num_fields == 0, fields == nullptr) << klass->PrettyClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007713
Brian Carlstromdbc05252011-09-09 01:59:59 -07007714 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07007715 // minimizes disruption of C++ version such as Class and Method.
Alex Lighte64300b2015-12-15 15:02:47 -08007716 //
7717 // The overall sort order order is:
7718 // 1) All object reference fields, sorted alphabetically.
7719 // 2) All java long (64-bit) integer fields, sorted alphabetically.
7720 // 3) All java double (64-bit) floating point fields, sorted alphabetically.
7721 // 4) All java int (32-bit) integer fields, sorted alphabetically.
7722 // 5) All java float (32-bit) floating point fields, sorted alphabetically.
7723 // 6) All java char (16-bit) integer fields, sorted alphabetically.
7724 // 7) All java short (16-bit) integer fields, sorted alphabetically.
7725 // 8) All java boolean (8-bit) integer fields, sorted alphabetically.
7726 // 9) All java byte (8-bit) integer fields, sorted alphabetically.
7727 //
7728 // Once the fields are sorted in this order we will attempt to fill any gaps that might be present
7729 // in the memory layout of the structure. See ShuffleForward for how this is done.
Mathieu Chartierc7853442015-03-27 14:35:38 -07007730 std::deque<ArtField*> grouped_and_sorted_fields;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07007731 const char* old_no_suspend_cause = self->StartAssertNoThreadSuspension(
Fred Shih37f05ef2014-07-16 18:38:08 -07007732 "Naked ArtField references in deque");
Brian Carlstromdbc05252011-09-09 01:59:59 -07007733 for (size_t i = 0; i < num_fields; i++) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007734 grouped_and_sorted_fields.push_back(&fields->At(i));
Brian Carlstromdbc05252011-09-09 01:59:59 -07007735 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07007736 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
7737 LinkFieldsComparator());
Brian Carlstromdbc05252011-09-09 01:59:59 -07007738
Fred Shih381e4ca2014-08-25 17:24:27 -07007739 // References should be at the front.
Brian Carlstromdbc05252011-09-09 01:59:59 -07007740 size_t current_field = 0;
7741 size_t num_reference_fields = 0;
Fred Shih381e4ca2014-08-25 17:24:27 -07007742 FieldGaps gaps;
7743
Brian Carlstromdbc05252011-09-09 01:59:59 -07007744 for (; current_field < num_fields; current_field++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07007745 ArtField* field = grouped_and_sorted_fields.front();
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07007746 Primitive::Type type = field->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07007747 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07007748 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07007749 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007750 }
Vladimir Marko76649e82014-11-10 18:32:59 +00007751 if (UNLIKELY(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(
7752 field_offset.Uint32Value()))) {
Fred Shih381e4ca2014-08-25 17:24:27 -07007753 MemberOffset old_offset = field_offset;
7754 field_offset = MemberOffset(RoundUp(field_offset.Uint32Value(), 4));
7755 AddFieldGap(old_offset.Uint32Value(), field_offset.Uint32Value(), &gaps);
7756 }
Roland Levillain14d90572015-07-16 10:52:26 +01007757 DCHECK_ALIGNED(field_offset.Uint32Value(), sizeof(mirror::HeapReference<mirror::Object>));
Brian Carlstromdbc05252011-09-09 01:59:59 -07007758 grouped_and_sorted_fields.pop_front();
7759 num_reference_fields++;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007760 field->SetOffset(field_offset);
Vladimir Marko76649e82014-11-10 18:32:59 +00007761 field_offset = MemberOffset(field_offset.Uint32Value() +
7762 sizeof(mirror::HeapReference<mirror::Object>));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007763 }
Fred Shih381e4ca2014-08-25 17:24:27 -07007764 // Gaps are stored as a max heap which means that we must shuffle from largest to smallest
7765 // otherwise we could end up with suboptimal gap fills.
Vladimir Marko76649e82014-11-10 18:32:59 +00007766 ShuffleForward<8>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7767 ShuffleForward<4>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7768 ShuffleForward<2>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7769 ShuffleForward<1>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
Fred Shih37f05ef2014-07-16 18:38:08 -07007770 CHECK(grouped_and_sorted_fields.empty()) << "Missed " << grouped_and_sorted_fields.size() <<
7771 " fields.";
Ian Rogers7b078e82014-09-10 14:44:24 -07007772 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007773
Elliott Hughesadb460d2011-10-05 17:02:34 -07007774 // 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 -07007775 if (!is_static && klass->DescriptorEquals("Ljava/lang/ref/Reference;")) {
Elliott Hughesadb460d2011-10-05 17:02:34 -07007776 // We know there are no non-reference fields in the Reference classes, and we know
7777 // that 'referent' is alphabetically last, so this is easy...
David Sehr709b0702016-10-13 09:12:37 -07007778 CHECK_EQ(num_reference_fields, num_fields) << klass->PrettyClass();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007779 CHECK_STREQ(fields->At(num_fields - 1).GetName(), "referent")
David Sehr709b0702016-10-13 09:12:37 -07007780 << klass->PrettyClass();
Elliott Hughesadb460d2011-10-05 17:02:34 -07007781 --num_reference_fields;
7782 }
7783
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007784 size_t size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007785 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007786 if (is_static) {
7787 klass->SetNumReferenceStaticFields(num_reference_fields);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007788 *class_size = size;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007789 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007790 klass->SetNumReferenceInstanceFields(num_reference_fields);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007791 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007792 if (num_reference_fields == 0 || super_class == nullptr) {
7793 // object has one reference field, klass, but we ignore it since we always visit the class.
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007794 // super_class is null iff the class is java.lang.Object.
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007795 if (super_class == nullptr ||
7796 (super_class->GetClassFlags() & mirror::kClassFlagNoReferenceFields) != 0) {
7797 klass->SetClassFlags(klass->GetClassFlags() | mirror::kClassFlagNoReferenceFields);
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007798 }
7799 }
7800 if (kIsDebugBuild) {
7801 DCHECK_EQ(super_class == nullptr, klass->DescriptorEquals("Ljava/lang/Object;"));
7802 size_t total_reference_instance_fields = 0;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007803 ObjPtr<mirror::Class> cur_super = klass.Get();
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007804 while (cur_super != nullptr) {
7805 total_reference_instance_fields += cur_super->NumReferenceInstanceFieldsDuringLinking();
7806 cur_super = cur_super->GetSuperClass();
7807 }
7808 if (super_class == nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07007809 CHECK_EQ(total_reference_instance_fields, 1u) << klass->PrettyDescriptor();
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007810 } else {
7811 // Check that there is at least num_reference_fields other than Object.class.
7812 CHECK_GE(total_reference_instance_fields, 1u + num_reference_fields)
David Sehr709b0702016-10-13 09:12:37 -07007813 << klass->PrettyClass();
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007814 }
7815 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07007816 if (!klass->IsVariableSize()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007817 std::string temp;
7818 DCHECK_GE(size, sizeof(mirror::Object)) << klass->GetDescriptor(&temp);
7819 size_t previous_size = klass->GetObjectSize();
7820 if (previous_size != 0) {
7821 // Make sure that we didn't originally have an incorrect size.
7822 CHECK_EQ(previous_size, size) << klass->GetDescriptor(&temp);
Mathieu Chartier79b4f382013-10-23 15:21:37 -07007823 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07007824 klass->SetObjectSize(size);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007825 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007826 }
Vladimir Marko76649e82014-11-10 18:32:59 +00007827
7828 if (kIsDebugBuild) {
7829 // Make sure that the fields array is ordered by name but all reference
7830 // offsets are at the beginning as far as alignment allows.
7831 MemberOffset start_ref_offset = is_static
Mathieu Chartiere401d142015-04-22 13:56:20 -07007832 ? klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_)
Vladimir Marko76649e82014-11-10 18:32:59 +00007833 : klass->GetFirstReferenceInstanceFieldOffset();
7834 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() +
7835 num_reference_fields *
7836 sizeof(mirror::HeapReference<mirror::Object>));
7837 MemberOffset current_ref_offset = start_ref_offset;
7838 for (size_t i = 0; i < num_fields; i++) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007839 ArtField* field = &fields->At(i);
Mathieu Chartierc7853442015-03-27 14:35:38 -07007840 VLOG(class_linker) << "LinkFields: " << (is_static ? "static" : "instance")
David Sehr709b0702016-10-13 09:12:37 -07007841 << " class=" << klass->PrettyClass() << " field=" << field->PrettyField()
7842 << " offset=" << field->GetOffsetDuringLinking();
Vladimir Marko76649e82014-11-10 18:32:59 +00007843 if (i != 0) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007844 ArtField* const prev_field = &fields->At(i - 1);
Vladimir Marko7a7c1db2014-11-17 15:13:34 +00007845 // NOTE: The field names can be the same. This is not possible in the Java language
7846 // but it's valid Java/dex bytecode and for example proguard can generate such bytecode.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007847 DCHECK_LE(strcmp(prev_field->GetName(), field->GetName()), 0);
Vladimir Marko76649e82014-11-10 18:32:59 +00007848 }
7849 Primitive::Type type = field->GetTypeAsPrimitiveType();
7850 bool is_primitive = type != Primitive::kPrimNot;
7851 if (klass->DescriptorEquals("Ljava/lang/ref/Reference;") &&
7852 strcmp("referent", field->GetName()) == 0) {
7853 is_primitive = true; // We lied above, so we have to expect a lie here.
7854 }
7855 MemberOffset offset = field->GetOffsetDuringLinking();
7856 if (is_primitive) {
7857 if (offset.Uint32Value() < end_ref_offset.Uint32Value()) {
7858 // Shuffled before references.
7859 size_t type_size = Primitive::ComponentSize(type);
7860 CHECK_LT(type_size, sizeof(mirror::HeapReference<mirror::Object>));
7861 CHECK_LT(offset.Uint32Value(), start_ref_offset.Uint32Value());
7862 CHECK_LE(offset.Uint32Value() + type_size, start_ref_offset.Uint32Value());
7863 CHECK(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(offset.Uint32Value()));
7864 }
7865 } else {
7866 CHECK_EQ(current_ref_offset.Uint32Value(), offset.Uint32Value());
7867 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() +
7868 sizeof(mirror::HeapReference<mirror::Object>));
7869 }
7870 }
7871 CHECK_EQ(current_ref_offset.Uint32Value(), end_ref_offset.Uint32Value());
7872 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007873 return true;
7874}
7875
Vladimir Marko76649e82014-11-10 18:32:59 +00007876// Set the bitmap of reference instance field offsets.
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007877void ClassLinker::CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007878 uint32_t reference_offsets = 0;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007879 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007880 // Leave the reference offsets as 0 for mirror::Object (the class field is handled specially).
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007881 if (super_class != nullptr) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007882 reference_offsets = super_class->GetReferenceInstanceOffsets();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007883 // Compute reference offsets unless our superclass overflowed.
7884 if (reference_offsets != mirror::Class::kClassWalkSuper) {
7885 size_t num_reference_fields = klass->NumReferenceInstanceFieldsDuringLinking();
Vladimir Marko76649e82014-11-10 18:32:59 +00007886 if (num_reference_fields != 0u) {
7887 // All of the fields that contain object references are guaranteed be grouped in memory
7888 // starting at an appropriately aligned address after super class object data.
7889 uint32_t start_offset = RoundUp(super_class->GetObjectSize(),
7890 sizeof(mirror::HeapReference<mirror::Object>));
7891 uint32_t start_bit = (start_offset - mirror::kObjectHeaderSize) /
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007892 sizeof(mirror::HeapReference<mirror::Object>);
Vladimir Marko76649e82014-11-10 18:32:59 +00007893 if (start_bit + num_reference_fields > 32) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007894 reference_offsets = mirror::Class::kClassWalkSuper;
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007895 } else {
Vladimir Marko76649e82014-11-10 18:32:59 +00007896 reference_offsets |= (0xffffffffu << start_bit) &
7897 (0xffffffffu >> (32 - (start_bit + num_reference_fields)));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007898 }
7899 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07007900 }
7901 }
Mingyao Yangfaff0f02014-09-10 12:03:22 -07007902 klass->SetReferenceInstanceOffsets(reference_offsets);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007903}
7904
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007905mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
Andreas Gampe8a0128a2016-11-28 07:38:35 -08007906 dex::StringIndex string_idx,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007907 Handle<mirror::DexCache> dex_cache) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007908 DCHECK(dex_cache != nullptr);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007909 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007910 ObjPtr<mirror::String> resolved = dex_cache->GetResolvedString(string_idx);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007911 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007912 return resolved.Ptr();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007913 }
Ian Rogersdfb325e2013-10-30 01:00:44 -07007914 uint32_t utf16_length;
7915 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007916 ObjPtr<mirror::String> string = intern_table_->InternStrong(utf16_length, utf8_data);
Vladimir Markobfb80d22017-02-14 14:08:12 +00007917 if (string != nullptr) {
7918 dex_cache->SetResolvedString(string_idx, string);
7919 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007920 return string.Ptr();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007921}
7922
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007923mirror::String* ClassLinker::LookupString(const DexFile& dex_file,
Andreas Gampe8a0128a2016-11-28 07:38:35 -08007924 dex::StringIndex string_idx,
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007925 Handle<mirror::DexCache> dex_cache) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007926 DCHECK(dex_cache != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007927 ObjPtr<mirror::String> resolved = dex_cache->GetResolvedString(string_idx);
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007928 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007929 return resolved.Ptr();
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007930 }
7931 uint32_t utf16_length;
7932 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Andreas Gampe8a0128a2016-11-28 07:38:35 -08007933 ObjPtr<mirror::String> string =
7934 intern_table_->LookupStrong(Thread::Current(), utf16_length, utf8_data);
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007935 if (string != nullptr) {
7936 dex_cache->SetResolvedString(string_idx, string);
7937 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007938 return string.Ptr();
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007939}
7940
Mathieu Chartierb8901302016-09-30 10:27:43 -07007941ObjPtr<mirror::Class> ClassLinker::LookupResolvedType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007942 dex::TypeIndex type_idx,
Mathieu Chartierb8901302016-09-30 10:27:43 -07007943 ObjPtr<mirror::DexCache> dex_cache,
7944 ObjPtr<mirror::ClassLoader> class_loader) {
7945 ObjPtr<mirror::Class> type = dex_cache->GetResolvedType(type_idx);
7946 if (type == nullptr) {
7947 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
7948 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
7949 if (descriptor[1] == '\0') {
7950 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
7951 // for primitive classes that aren't backed by dex files.
7952 type = FindPrimitiveClass(descriptor[0]);
7953 } else {
7954 Thread* const self = Thread::Current();
7955 DCHECK(self != nullptr);
7956 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
7957 // Find the class in the loaded classes table.
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07007958 type = LookupClass(self, descriptor, hash, class_loader.Ptr());
Mathieu Chartierb8901302016-09-30 10:27:43 -07007959 }
Vladimir Markobfb80d22017-02-14 14:08:12 +00007960 if (type != nullptr) {
7961 if (type->IsResolved()) {
7962 dex_cache->SetResolvedType(type_idx, type);
7963 } else {
7964 type = nullptr;
7965 }
7966 }
Mathieu Chartierb8901302016-09-30 10:27:43 -07007967 }
Vladimir Markobfb80d22017-02-14 14:08:12 +00007968 DCHECK(type == nullptr || type->IsResolved());
7969 return type;
Mathieu Chartierb8901302016-09-30 10:27:43 -07007970}
7971
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007972mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007973 dex::TypeIndex type_idx,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007974 ObjPtr<mirror::Class> referrer) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007975 StackHandleScope<2> hs(Thread::Current());
7976 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
7977 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
Mathieu Chartier590fee92013-09-13 13:46:47 -07007978 return ResolveType(dex_file, type_idx, dex_cache, class_loader);
7979}
7980
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007981mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007982 dex::TypeIndex type_idx,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007983 Handle<mirror::DexCache> dex_cache,
7984 Handle<mirror::ClassLoader> class_loader) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007985 DCHECK(dex_cache != nullptr);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007986 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007987 ObjPtr<mirror::Class> resolved = dex_cache->GetResolvedType(type_idx);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007988 if (resolved == nullptr) {
Vladimir Markobfb80d22017-02-14 14:08:12 +00007989 // TODO: Avoid this lookup as it duplicates work done in FindClass(). It is here
7990 // as a workaround for FastNative JNI to avoid AssertNoPendingException() when
7991 // trying to resolve annotations while an exception may be pending. Bug: 34659969
7992 resolved = LookupResolvedType(dex_file, type_idx, dex_cache.Get(), class_loader.Get());
7993 }
7994 if (resolved == nullptr) {
Ian Rogers98379392014-02-24 16:53:16 -08007995 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07007996 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Ian Rogers98379392014-02-24 16:53:16 -08007997 resolved = FindClass(self, descriptor, class_loader);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007998 if (resolved != nullptr) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05007999 // TODO: we used to throw here if resolved's class loader was not the
8000 // boot class loader. This was to permit different classes with the
8001 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07008002 dex_cache->SetResolvedType(type_idx, resolved);
8003 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08008004 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08008005 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08008006 // Convert a ClassNotFoundException to a NoClassDefFoundError.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07008007 StackHandleScope<1> hs(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00008008 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
Ian Rogers62d6c772013-02-27 08:32:07 -08008009 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008010 DCHECK(resolved == nullptr); // No Handle needed to preserve resolved.
Ian Rogers98379392014-02-24 16:53:16 -08008011 self->ClearException();
jeffhao8cd6dda2012-02-22 10:15:34 -08008012 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00008013 self->GetException()->SetCause(cause.Get());
jeffhao8cd6dda2012-02-22 10:15:34 -08008014 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07008015 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07008016 }
Vladimir Marko72ab6842017-01-20 19:32:50 +00008017 DCHECK((resolved == nullptr) || resolved->IsResolved())
David Sehr709b0702016-10-13 09:12:37 -07008018 << resolved->PrettyDescriptor() << " " << resolved->GetStatus();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008019 return resolved.Ptr();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07008020}
8021
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08008022template <ClassLinker::ResolveMode kResolveMode>
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008023ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
8024 uint32_t method_idx,
Mathieu Chartiere401d142015-04-22 13:56:20 -07008025 Handle<mirror::DexCache> dex_cache,
8026 Handle<mirror::ClassLoader> class_loader,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008027 ArtMethod* referrer,
8028 InvokeType type) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08008029 DCHECK(dex_cache != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07008030 // Check for hit in the dex cache.
Mathieu Chartiere401d142015-04-22 13:56:20 -07008031 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008032 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07008033 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008034 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex();
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08008035 if (kResolveMode == ClassLinker::kForceICCECheck) {
8036 if (resolved->CheckIncompatibleClassChange(type)) {
8037 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer);
8038 return nullptr;
8039 }
8040 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008041 return resolved;
8042 }
Ian Rogers08f753d2012-08-24 14:35:25 -07008043 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008044 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008045 ObjPtr<mirror::Class> klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008046 if (klass == nullptr) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07008047 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008048 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008049 }
Ian Rogers08f753d2012-08-24 14:35:25 -07008050 // Scan using method_idx, this saves string compares but will only hit for matching dex
8051 // caches/files.
8052 switch (type) {
8053 case kDirect: // Fall-through.
8054 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008055 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8056 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07008057 break;
8058 case kInterface:
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08008059 // We have to check whether the method id really belongs to an interface (dex static bytecode
8060 // constraint A15). Otherwise you must not invoke-interface on it.
8061 //
8062 // This is not symmetric to A12-A14 (direct, static, virtual), as using FindInterfaceMethod
8063 // assumes that the given type is an interface, and will check the interface table if the
8064 // method isn't declared in the class. So it may find an interface method (usually by name
8065 // in the handling below, but we do the constraint check early). In that case,
8066 // CheckIncompatibleClassChange will succeed (as it is called on an interface method)
8067 // unexpectedly.
8068 // Example:
8069 // interface I {
8070 // foo()
8071 // }
8072 // class A implements I {
8073 // ...
8074 // }
8075 // class B extends A {
8076 // ...
8077 // }
8078 // invoke-interface B.foo
8079 // -> FindInterfaceMethod finds I.foo (interface method), not A.foo (miranda method)
8080 if (UNLIKELY(!klass->IsInterface())) {
8081 ThrowIncompatibleClassChangeError(klass,
8082 "Found class %s, but interface was expected",
David Sehr709b0702016-10-13 09:12:37 -07008083 klass->PrettyDescriptor().c_str());
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08008084 return nullptr;
8085 } else {
8086 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8087 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
8088 }
Ian Rogers08f753d2012-08-24 14:35:25 -07008089 break;
Alex Light705ad492015-09-21 11:36:30 -07008090 case kSuper:
8091 if (klass->IsInterface()) {
8092 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8093 } else {
8094 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8095 }
8096 break;
Ian Rogers08f753d2012-08-24 14:35:25 -07008097 case kVirtual:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008098 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07008099 break;
8100 default:
8101 LOG(FATAL) << "Unreachable - invocation type: " << type;
Ian Rogers2c4257b2014-10-24 14:20:06 -07008102 UNREACHABLE();
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008103 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008104 if (resolved == nullptr) {
Ian Rogers08f753d2012-08-24 14:35:25 -07008105 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008106 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07008107 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07008108 switch (type) {
8109 case kDirect: // Fall-through.
8110 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008111 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_);
8112 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07008113 break;
8114 case kInterface:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008115 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008116 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07008117 break;
Alex Light705ad492015-09-21 11:36:30 -07008118 case kSuper:
8119 if (klass->IsInterface()) {
8120 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
8121 } else {
8122 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
8123 }
8124 break;
Ian Rogers08f753d2012-08-24 14:35:25 -07008125 case kVirtual:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008126 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07008127 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008128 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008129 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008130 // If we found a method, check for incompatible class changes.
8131 if (LIKELY(resolved != nullptr && !resolved->CheckIncompatibleClassChange(type))) {
Ian Rogers08f753d2012-08-24 14:35:25 -07008132 // Be a good citizen and update the dex cache to speed subsequent calls.
Mathieu Chartiere401d142015-04-22 13:56:20 -07008133 dex_cache->SetResolvedMethod(method_idx, resolved, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07008134 return resolved;
8135 } else {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008136 // If we had a method, it's an incompatible-class-change error.
8137 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008138 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008139 } else {
8140 // We failed to find the method which means either an access error, an incompatible class
8141 // change, or no such method. First try to find the method among direct and virtual methods.
8142 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
8143 const Signature signature = dex_file.GetMethodSignature(method_id);
8144 switch (type) {
8145 case kDirect:
8146 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008147 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008148 // Note: kDirect and kStatic are also mutually exclusive, but in that case we would
8149 // have had a resolved method before, which triggers the "true" branch above.
8150 break;
8151 case kInterface:
8152 case kVirtual:
8153 case kSuper:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008154 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008155 break;
8156 }
8157
8158 // If we found something, check that it can be accessed by the referrer.
Ian Rogerse0a02da2014-12-02 14:10:53 -08008159 bool exception_generated = false;
Mathieu Chartiere401d142015-04-22 13:56:20 -07008160 if (resolved != nullptr && referrer != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008161 ObjPtr<mirror::Class> methods_class = resolved->GetDeclaringClass();
8162 ObjPtr<mirror::Class> referring_class = referrer->GetDeclaringClass();
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008163 if (!referring_class->CanAccess(methods_class)) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008164 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class,
8165 methods_class,
8166 resolved,
Mathieu Chartiere401d142015-04-22 13:56:20 -07008167 type);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008168 exception_generated = true;
Mathieu Chartiere401d142015-04-22 13:56:20 -07008169 } else if (!referring_class->CanAccessMember(methods_class, resolved->GetAccessFlags())) {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008170 ThrowIllegalAccessErrorMethod(referring_class, resolved);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008171 exception_generated = true;
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008172 }
8173 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008174 if (!exception_generated) {
8175 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check
8176 // interface methods and throw if we find the method there. If we find nothing, throw a
8177 // NoSuchMethodError.
8178 switch (type) {
8179 case kDirect:
8180 case kStatic:
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008181 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008182 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008183 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008184 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008185 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008186 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008187 } else {
8188 ThrowNoSuchMethodError(type, klass, name, signature);
8189 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008190 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008191 break;
8192 case kInterface:
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008193 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008194 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008195 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008196 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008197 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008198 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008199 } else {
8200 ThrowNoSuchMethodError(type, klass, name, signature);
8201 }
8202 }
8203 break;
8204 case kSuper:
8205 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008206 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008207 } else {
8208 ThrowNoSuchMethodError(type, klass, name, signature);
8209 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008210 break;
8211 case kVirtual:
8212 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008213 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008214 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008215 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008216 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008217 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008218 } else {
8219 ThrowNoSuchMethodError(type, klass, name, signature);
8220 }
8221 }
8222 break;
8223 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008224 }
Ian Rogers08f753d2012-08-24 14:35:25 -07008225 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008226 Thread::Current()->AssertPendingException();
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008227 return nullptr;
Ian Rogers08f753d2012-08-24 14:35:25 -07008228 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07008229}
8230
Jeff Hao13e748b2015-08-25 20:44:19 +00008231ArtMethod* ClassLinker::ResolveMethodWithoutInvokeType(const DexFile& dex_file,
8232 uint32_t method_idx,
8233 Handle<mirror::DexCache> dex_cache,
8234 Handle<mirror::ClassLoader> class_loader) {
8235 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008236 Thread::PoisonObjectPointersIfDebug();
Jeff Hao13e748b2015-08-25 20:44:19 +00008237 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
8238 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex();
8239 return resolved;
8240 }
8241 // Fail, get the declaring class.
8242 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008243 ObjPtr<mirror::Class> klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Jeff Hao13e748b2015-08-25 20:44:19 +00008244 if (klass == nullptr) {
8245 Thread::Current()->AssertPendingException();
8246 return nullptr;
8247 }
8248 if (klass->IsInterface()) {
David Sehr709b0702016-10-13 09:12:37 -07008249 LOG(FATAL) << "ResolveAmbiguousMethod: unexpected method in interface: "
8250 << klass->PrettyClass();
Jeff Hao13e748b2015-08-25 20:44:19 +00008251 return nullptr;
8252 }
8253
8254 // Search both direct and virtual methods
8255 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8256 if (resolved == nullptr) {
8257 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8258 }
8259
8260 return resolved;
8261}
8262
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008263ArtField* ClassLinker::ResolveField(const DexFile& dex_file,
8264 uint32_t field_idx,
Mathieu Chartierc7853442015-03-27 14:35:38 -07008265 Handle<mirror::DexCache> dex_cache,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008266 Handle<mirror::ClassLoader> class_loader,
8267 bool is_static) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08008268 DCHECK(dex_cache != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008269 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008270 Thread::PoisonObjectPointersIfDebug();
Andreas Gampe58a5af82014-07-31 16:23:49 -07008271 if (resolved != nullptr) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008272 return resolved;
8273 }
8274 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07008275 Thread* const self = Thread::Current();
Vladimir Marko19a4d372016-12-08 14:41:46 +00008276 ObjPtr<mirror::Class> klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
8277 if (klass == nullptr) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08008278 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe58a5af82014-07-31 16:23:49 -07008279 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008280 }
8281
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008282 if (is_static) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00008283 resolved = mirror::Class::FindStaticField(self, klass, dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008284 } else {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07008285 resolved = klass->FindInstanceField(dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008286 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008287
Andreas Gampe58a5af82014-07-31 16:23:49 -07008288 if (resolved == nullptr) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008289 const char* name = dex_file.GetFieldName(field_id);
8290 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
8291 if (is_static) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07008292 resolved = mirror::Class::FindStaticField(self, klass, name, type);
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008293 } else {
8294 resolved = klass->FindInstanceField(name, type);
8295 }
Andreas Gampe58a5af82014-07-31 16:23:49 -07008296 if (resolved == nullptr) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00008297 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008298 return nullptr;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008299 }
Ian Rogersb067ac22011-12-13 18:05:09 -08008300 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07008301 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_);
Ian Rogersb067ac22011-12-13 18:05:09 -08008302 return resolved;
8303}
8304
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008305ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
8306 uint32_t field_idx,
Mathieu Chartierc7853442015-03-27 14:35:38 -07008307 Handle<mirror::DexCache> dex_cache,
8308 Handle<mirror::ClassLoader> class_loader) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08008309 DCHECK(dex_cache != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008310 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008311 Thread::PoisonObjectPointersIfDebug();
Andreas Gampe58a5af82014-07-31 16:23:49 -07008312 if (resolved != nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08008313 return resolved;
8314 }
8315 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07008316 Thread* self = Thread::Current();
Vladimir Marko19a4d372016-12-08 14:41:46 +00008317 ObjPtr<mirror::Class> klass(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader));
8318 if (klass == nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08008319 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008320 return nullptr;
Ian Rogersb067ac22011-12-13 18:05:09 -08008321 }
8322
Ian Rogersdfb325e2013-10-30 01:00:44 -07008323 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
8324 StringPiece type(dex_file.StringDataByIdx(
Ian Rogersfc0e94b2013-09-23 23:51:32 -07008325 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
Mathieu Chartierf8322842014-05-16 10:59:25 -07008326 resolved = mirror::Class::FindField(self, klass, name, type);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008327 if (resolved != nullptr) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07008328 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_);
Ian Rogersb067ac22011-12-13 18:05:09 -08008329 } else {
Vladimir Marko19a4d372016-12-08 14:41:46 +00008330 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008331 }
8332 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07008333}
8334
Narayan Kamath25352fc2016-08-03 12:46:58 +01008335mirror::MethodType* ClassLinker::ResolveMethodType(const DexFile& dex_file,
8336 uint32_t proto_idx,
8337 Handle<mirror::DexCache> dex_cache,
8338 Handle<mirror::ClassLoader> class_loader) {
8339 DCHECK(Runtime::Current()->IsMethodHandlesEnabled());
Andreas Gampefa4333d2017-02-14 11:10:34 -08008340 DCHECK(dex_cache != nullptr);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008341
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008342 ObjPtr<mirror::MethodType> resolved = dex_cache->GetResolvedMethodType(proto_idx);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008343 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008344 return resolved.Ptr();
Narayan Kamath25352fc2016-08-03 12:46:58 +01008345 }
8346
8347 Thread* const self = Thread::Current();
8348 StackHandleScope<4> hs(self);
8349
8350 // First resolve the return type.
8351 const DexFile::ProtoId& proto_id = dex_file.GetProtoId(proto_idx);
8352 Handle<mirror::Class> return_type(hs.NewHandle(
8353 ResolveType(dex_file, proto_id.return_type_idx_, dex_cache, class_loader)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008354 if (return_type == nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01008355 DCHECK(self->IsExceptionPending());
8356 return nullptr;
8357 }
8358
8359 // Then resolve the argument types.
8360 //
8361 // TODO: Is there a better way to figure out the number of method arguments
8362 // other than by looking at the shorty ?
8363 const size_t num_method_args = strlen(dex_file.StringDataByIdx(proto_id.shorty_idx_)) - 1;
8364
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008365 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008366 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008367 Handle<mirror::ObjectArray<mirror::Class>> method_params(hs.NewHandle(
8368 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, num_method_args)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008369 if (method_params == nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01008370 DCHECK(self->IsExceptionPending());
8371 return nullptr;
8372 }
8373
8374 DexFileParameterIterator it(dex_file, proto_id);
8375 int32_t i = 0;
8376 MutableHandle<mirror::Class> param_class = hs.NewHandle<mirror::Class>(nullptr);
8377 for (; it.HasNext(); it.Next()) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08008378 const dex::TypeIndex type_idx = it.GetTypeIdx();
Narayan Kamath25352fc2016-08-03 12:46:58 +01008379 param_class.Assign(ResolveType(dex_file, type_idx, dex_cache, class_loader));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008380 if (param_class == nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01008381 DCHECK(self->IsExceptionPending());
8382 return nullptr;
8383 }
8384
8385 method_params->Set(i++, param_class.Get());
8386 }
8387
8388 DCHECK(!it.HasNext());
8389
8390 Handle<mirror::MethodType> type = hs.NewHandle(
8391 mirror::MethodType::Create(self, return_type, method_params));
8392 dex_cache->SetResolvedMethodType(proto_idx, type.Get());
8393
8394 return type.Get();
8395}
8396
Orion Hodsonc069a302017-01-18 09:23:12 +00008397mirror::MethodHandle* ClassLinker::ResolveMethodHandle(uint32_t method_handle_idx,
8398 ArtMethod* referrer)
8399 REQUIRES_SHARED(Locks::mutator_lock_) {
8400 Thread* const self = Thread::Current();
8401 const DexFile* const dex_file = referrer->GetDexFile();
8402 const DexFile::MethodHandleItem& mh = dex_file->GetMethodHandle(method_handle_idx);
8403
8404 union {
8405 ArtField* field;
8406 ArtMethod* method;
8407 uintptr_t field_or_method;
8408 } target;
8409 uint32_t num_params;
8410 mirror::MethodHandle::Kind kind;
8411 DexFile::MethodHandleType handle_type =
8412 static_cast<DexFile::MethodHandleType>(mh.method_handle_type_);
8413 switch (handle_type) {
8414 case DexFile::MethodHandleType::kStaticPut: {
8415 kind = mirror::MethodHandle::Kind::kStaticPut;
8416 target.field = ResolveField(mh.field_or_method_idx_, referrer, true /* is_static */);
8417 num_params = 1;
8418 break;
8419 }
8420 case DexFile::MethodHandleType::kStaticGet: {
8421 kind = mirror::MethodHandle::Kind::kStaticGet;
8422 target.field = ResolveField(mh.field_or_method_idx_, referrer, true /* is_static */);
8423 num_params = 0;
8424 break;
8425 }
8426 case DexFile::MethodHandleType::kInstancePut: {
8427 kind = mirror::MethodHandle::Kind::kInstancePut;
8428 target.field = ResolveField(mh.field_or_method_idx_, referrer, false /* is_static */);
8429 num_params = 2;
8430 break;
8431 }
8432 case DexFile::MethodHandleType::kInstanceGet: {
8433 kind = mirror::MethodHandle::Kind::kInstanceGet;
8434 target.field = ResolveField(mh.field_or_method_idx_, referrer, false /* is_static */);
8435 num_params = 1;
8436 break;
8437 }
8438 case DexFile::MethodHandleType::kInvokeStatic: {
8439 kind = mirror::MethodHandle::Kind::kInvokeStatic;
8440 target.method = ResolveMethod<kNoICCECheckForCache>(self,
8441 mh.field_or_method_idx_,
8442 referrer,
8443 InvokeType::kStatic);
8444 uint32_t shorty_length;
8445 target.method->GetShorty(&shorty_length);
8446 num_params = shorty_length - 1; // Remove 1 for return value.
8447 break;
8448 }
8449 case DexFile::MethodHandleType::kInvokeInstance: {
8450 kind = mirror::MethodHandle::Kind::kInvokeVirtual;
8451 target.method = ResolveMethod<kNoICCECheckForCache>(self,
8452 mh.field_or_method_idx_,
8453 referrer,
8454 InvokeType::kVirtual);
8455 uint32_t shorty_length;
8456 target.method->GetShorty(&shorty_length);
8457 num_params = shorty_length - 1; // Remove 1 for return value.
8458 break;
8459 }
8460 case DexFile::MethodHandleType::kInvokeConstructor: {
8461 UNIMPLEMENTED(FATAL) << "Invoke constructor is implemented as a transform.";
8462 num_params = 0;
8463 }
8464 }
8465
8466 StackHandleScope<5> hs(self);
8467 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
8468 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
8469 Handle<mirror::ObjectArray<mirror::Class>> method_params(hs.NewHandle(
8470 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, num_params)));
8471 if (method_params.Get() == nullptr) {
8472 DCHECK(self->IsExceptionPending());
8473 return nullptr;
8474 }
8475
8476 Handle<mirror::Class> return_type;
8477 switch (handle_type) {
8478 case DexFile::MethodHandleType::kStaticPut: {
8479 method_params->Set(0, target.field->GetType<true>());
8480 return_type = hs.NewHandle(FindPrimitiveClass('V'));
8481 break;
8482 }
8483 case DexFile::MethodHandleType::kStaticGet: {
8484 return_type = hs.NewHandle(target.field->GetType<true>());
8485 break;
8486 }
8487 case DexFile::MethodHandleType::kInstancePut: {
8488 method_params->Set(0, target.field->GetDeclaringClass());
8489 method_params->Set(1, target.field->GetType<true>());
8490 return_type = hs.NewHandle(FindPrimitiveClass('V'));
8491 break;
8492 }
8493 case DexFile::MethodHandleType::kInstanceGet: {
8494 method_params->Set(0, target.field->GetDeclaringClass());
8495 return_type = hs.NewHandle(target.field->GetType<true>());
8496 break;
8497 }
8498 case DexFile::MethodHandleType::kInvokeStatic:
8499 case DexFile::MethodHandleType::kInvokeInstance: {
8500 // TODO(oth): This will not work for varargs methods as this
8501 // requires instantiating a Transformer. This resolution step
8502 // would be best done in managed code rather than in the run
8503 // time (b/35235705)
8504 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
8505 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
8506 DexFileParameterIterator it(*dex_file, target.method->GetPrototype());
8507 for (int32_t i = 0; it.HasNext(); i++, it.Next()) {
8508 const dex::TypeIndex type_idx = it.GetTypeIdx();
8509 mirror::Class* klass = ResolveType(*dex_file, type_idx, dex_cache, class_loader);
8510 if (nullptr == klass) {
8511 DCHECK(self->IsExceptionPending());
8512 return nullptr;
8513 }
8514 method_params->Set(i, klass);
8515 }
8516 return_type = hs.NewHandle(target.method->GetReturnType(true));
8517 break;
8518 }
8519 case DexFile::MethodHandleType::kInvokeConstructor: {
8520 // TODO(oth): b/35235705
8521 UNIMPLEMENTED(FATAL) << "Invoke constructor is implemented as a transform.";
8522 }
8523 }
8524
8525 if (return_type.IsNull()) {
8526 DCHECK(self->IsExceptionPending());
8527 return nullptr;
8528 }
8529
8530 Handle<mirror::MethodType>
8531 mt(hs.NewHandle(mirror::MethodType::Create(self, return_type, method_params)));
8532 if (mt.IsNull()) {
8533 DCHECK(self->IsExceptionPending());
8534 return nullptr;
8535 }
8536 return mirror::MethodHandleImpl::Create(self, target.field_or_method, kind, mt);
8537}
8538
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008539bool ClassLinker::IsQuickResolutionStub(const void* entry_point) const {
8540 return (entry_point == GetQuickResolutionStub()) ||
8541 (quick_resolution_trampoline_ == entry_point);
8542}
8543
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008544bool ClassLinker::IsQuickToInterpreterBridge(const void* entry_point) const {
8545 return (entry_point == GetQuickToInterpreterBridge()) ||
8546 (quick_to_interpreter_bridge_trampoline_ == entry_point);
8547}
8548
8549bool ClassLinker::IsQuickGenericJniStub(const void* entry_point) const {
8550 return (entry_point == GetQuickGenericJniStub()) ||
8551 (quick_generic_jni_trampoline_ == entry_point);
8552}
8553
8554const void* ClassLinker::GetRuntimeQuickGenericJniStub() const {
8555 return GetQuickGenericJniStub();
8556}
8557
Andreas Gampecc1b5352016-12-01 16:58:38 -08008558void ClassLinker::SetEntryPointsToCompiledCode(ArtMethod* method, const void* code) const {
8559 CHECK(code != nullptr);
8560 const uint8_t* base = reinterpret_cast<const uint8_t*>(code); // Base of data points at code.
8561 base -= sizeof(void*); // Move backward so that code_offset != 0.
8562 const uint32_t code_offset = sizeof(void*);
8563 OatFile::OatMethod oat_method(base, code_offset);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008564 oat_method.LinkMethod(method);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008565}
8566
Mathieu Chartiere401d142015-04-22 13:56:20 -07008567void ClassLinker::SetEntryPointsToInterpreter(ArtMethod* method) const {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008568 if (!method->IsNative()) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008569 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
8570 } else {
Andreas Gampecc1b5352016-12-01 16:58:38 -08008571 SetEntryPointsToCompiledCode(method, GetQuickGenericJniStub());
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008572 }
8573}
8574
Ian Rogers7dfb28c2013-08-22 08:18:36 -07008575void ClassLinker::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07008576 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier6b069532015-08-05 15:08:12 -07008577 ReaderMutexLock mu(soa.Self(), *Locks::classlinker_classes_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008578 os << "Zygote loaded classes=" << NumZygoteClasses() << " post zygote classes="
8579 << NumNonZygoteClasses() << "\n";
8580}
8581
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008582class CountClassesVisitor : public ClassLoaderVisitor {
8583 public:
8584 CountClassesVisitor() : num_zygote_classes(0), num_non_zygote_classes(0) {}
8585
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008586 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07008587 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008588 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier6b069532015-08-05 15:08:12 -07008589 if (class_table != nullptr) {
Vladimir Markoc5798bf2016-12-09 10:20:54 +00008590 num_zygote_classes += class_table->NumZygoteClasses(class_loader);
8591 num_non_zygote_classes += class_table->NumNonZygoteClasses(class_loader);
Mathieu Chartier6b069532015-08-05 15:08:12 -07008592 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008593 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008594
8595 size_t num_zygote_classes;
8596 size_t num_non_zygote_classes;
8597};
8598
8599size_t ClassLinker::NumZygoteClasses() const {
8600 CountClassesVisitor visitor;
8601 VisitClassLoaders(&visitor);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00008602 return visitor.num_zygote_classes + boot_class_table_.NumZygoteClasses(nullptr);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008603}
8604
8605size_t ClassLinker::NumNonZygoteClasses() const {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008606 CountClassesVisitor visitor;
8607 VisitClassLoaders(&visitor);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00008608 return visitor.num_non_zygote_classes + boot_class_table_.NumNonZygoteClasses(nullptr);
Elliott Hughescac6cc72011-11-03 20:31:21 -07008609}
8610
Ian Rogers7dfb28c2013-08-22 08:18:36 -07008611size_t ClassLinker::NumLoadedClasses() {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07008612 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Mathieu Chartierc2e20622014-11-03 11:41:47 -08008613 // Only return non zygote classes since these are the ones which apps which care about.
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008614 return NumNonZygoteClasses();
Elliott Hughese27955c2011-08-26 15:21:24 -07008615}
8616
Brian Carlstrom47d237a2011-10-18 15:08:33 -07008617pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07008618 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07008619}
8620
8621pid_t ClassLinker::GetDexLockOwner() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08008622 return Locks::dex_lock_->GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07008623}
8624
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008625void ClassLinker::SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008626 DCHECK(!init_done_);
8627
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008628 DCHECK(klass != nullptr);
8629 DCHECK(klass->GetClassLoader() == nullptr);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008630
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07008631 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008632 DCHECK(class_roots != nullptr);
8633 DCHECK(class_roots->Get(class_root) == nullptr);
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07008634 class_roots->Set<false>(class_root, klass);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008635}
8636
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008637const char* ClassLinker::GetClassRootDescriptor(ClassRoot class_root) {
8638 static const char* class_roots_descriptors[] = {
8639 "Ljava/lang/Class;",
8640 "Ljava/lang/Object;",
8641 "[Ljava/lang/Class;",
8642 "[Ljava/lang/Object;",
8643 "Ljava/lang/String;",
8644 "Ljava/lang/DexCache;",
8645 "Ljava/lang/ref/Reference;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008646 "Ljava/lang/reflect/Constructor;",
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008647 "Ljava/lang/reflect/Field;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008648 "Ljava/lang/reflect/Method;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008649 "Ljava/lang/reflect/Proxy;",
8650 "[Ljava/lang/String;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008651 "[Ljava/lang/reflect/Constructor;",
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008652 "[Ljava/lang/reflect/Field;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008653 "[Ljava/lang/reflect/Method;",
Orion Hodsonc069a302017-01-18 09:23:12 +00008654 "Ljava/lang/invoke/CallSite;",
Narayan Kamathafa48272016-08-03 12:46:58 +01008655 "Ljava/lang/invoke/MethodHandleImpl;",
Orion Hodsonc069a302017-01-18 09:23:12 +00008656 "Ljava/lang/invoke/MethodHandles$Lookup;",
Narayan Kamathafa48272016-08-03 12:46:58 +01008657 "Ljava/lang/invoke/MethodType;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008658 "Ljava/lang/ClassLoader;",
8659 "Ljava/lang/Throwable;",
8660 "Ljava/lang/ClassNotFoundException;",
8661 "Ljava/lang/StackTraceElement;",
Narayan Kamath000e1882016-10-24 17:14:25 +01008662 "Ldalvik/system/EmulatedStackFrame;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008663 "Z",
8664 "B",
8665 "C",
8666 "D",
8667 "F",
8668 "I",
8669 "J",
8670 "S",
8671 "V",
8672 "[Z",
8673 "[B",
8674 "[C",
8675 "[D",
8676 "[F",
8677 "[I",
8678 "[J",
8679 "[S",
8680 "[Ljava/lang/StackTraceElement;",
Alex Lightd6251582016-10-31 11:12:30 -07008681 "Ldalvik/system/ClassExt;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008682 };
Andreas Gampe575e78c2014-11-03 23:41:03 -08008683 static_assert(arraysize(class_roots_descriptors) == size_t(kClassRootsMax),
8684 "Mismatch between class descriptors and class-root enum");
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008685
8686 const char* descriptor = class_roots_descriptors[class_root];
8687 CHECK(descriptor != nullptr);
8688 return descriptor;
8689}
8690
Jeff Hao5872d7c2016-04-27 11:07:41 -07008691jobject ClassLinker::CreatePathClassLoader(Thread* self,
8692 const std::vector<const DexFile*>& dex_files) {
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008693 // SOAAlreadyRunnable is protected, and we need something to add a global reference.
8694 // We could move the jobject to the callers, but all call-sites do this...
8695 ScopedObjectAccessUnchecked soa(self);
8696
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008697 // For now, create a libcore-level DexFile for each ART DexFile. This "explodes" multidex.
Vladimir Marko19a4d372016-12-08 14:41:46 +00008698 StackHandleScope<6> hs(self);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008699
Mathieu Chartierc7853442015-03-27 14:35:38 -07008700 ArtField* dex_elements_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008701 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008702
Mathieu Chartier3398c782016-09-30 10:27:43 -07008703 Handle<mirror::Class> dex_elements_class(hs.NewHandle(dex_elements_field->GetType<true>()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008704 DCHECK(dex_elements_class != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008705 DCHECK(dex_elements_class->IsArrayClass());
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008706 Handle<mirror::ObjectArray<mirror::Object>> h_dex_elements(hs.NewHandle(
Mathieu Chartier3398c782016-09-30 10:27:43 -07008707 mirror::ObjectArray<mirror::Object>::Alloc(self,
8708 dex_elements_class.Get(),
8709 dex_files.size())));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008710 Handle<mirror::Class> h_dex_element_class =
8711 hs.NewHandle(dex_elements_class->GetComponentType());
8712
Mathieu Chartierc7853442015-03-27 14:35:38 -07008713 ArtField* element_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008714 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008715 DCHECK_EQ(h_dex_element_class.Get(), element_file_field->GetDeclaringClass());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008716
Andreas Gampe08883de2016-11-08 13:20:52 -08008717 ArtField* cookie_field = jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008718 DCHECK_EQ(cookie_field->GetDeclaringClass(), element_file_field->GetType<false>());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008719
Andreas Gampe08883de2016-11-08 13:20:52 -08008720 ArtField* file_name_field = jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_fileName);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008721 DCHECK_EQ(file_name_field->GetDeclaringClass(), element_file_field->GetType<false>());
8722
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008723 // Fill the elements array.
8724 int32_t index = 0;
8725 for (const DexFile* dex_file : dex_files) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008726 StackHandleScope<4> hs2(self);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008727
Mathieu Chartier966878d2016-01-14 14:33:29 -08008728 // CreatePathClassLoader is only used by gtests. Index 0 of h_long_array is supposed to be the
8729 // oat file but we can leave it null.
Mathieu Chartiere58991b2015-10-13 07:59:34 -07008730 Handle<mirror::LongArray> h_long_array = hs2.NewHandle(mirror::LongArray::Alloc(
8731 self,
8732 kDexFileIndexStart + 1));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008733 DCHECK(h_long_array != nullptr);
Mathieu Chartiere58991b2015-10-13 07:59:34 -07008734 h_long_array->Set(kDexFileIndexStart, reinterpret_cast<intptr_t>(dex_file));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008735
8736 Handle<mirror::Object> h_dex_file = hs2.NewHandle(
Mathieu Chartierc7853442015-03-27 14:35:38 -07008737 cookie_field->GetDeclaringClass()->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008738 DCHECK(h_dex_file != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008739 cookie_field->SetObject<false>(h_dex_file.Get(), h_long_array.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008740
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008741 Handle<mirror::String> h_file_name = hs2.NewHandle(
8742 mirror::String::AllocFromModifiedUtf8(self, dex_file->GetLocation().c_str()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008743 DCHECK(h_file_name != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008744 file_name_field->SetObject<false>(h_dex_file.Get(), h_file_name.Get());
8745
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008746 Handle<mirror::Object> h_element = hs2.NewHandle(h_dex_element_class->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008747 DCHECK(h_element != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008748 element_file_field->SetObject<false>(h_element.Get(), h_dex_file.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008749
8750 h_dex_elements->Set(index, h_element.Get());
8751 index++;
8752 }
8753 DCHECK_EQ(index, h_dex_elements->GetLength());
8754
8755 // Create DexPathList.
8756 Handle<mirror::Object> h_dex_path_list = hs.NewHandle(
Mathieu Chartierc7853442015-03-27 14:35:38 -07008757 dex_elements_field->GetDeclaringClass()->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008758 DCHECK(h_dex_path_list != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008759 // Set elements.
Mathieu Chartierc7853442015-03-27 14:35:38 -07008760 dex_elements_field->SetObject<false>(h_dex_path_list.Get(), h_dex_elements.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008761
8762 // Create PathClassLoader.
8763 Handle<mirror::Class> h_path_class_class = hs.NewHandle(
Mathieu Chartier0795f232016-09-27 18:43:30 -07008764 soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008765 Handle<mirror::Object> h_path_class_loader = hs.NewHandle(
8766 h_path_class_class->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008767 DCHECK(h_path_class_loader != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008768 // Set DexPathList.
Mathieu Chartierc7853442015-03-27 14:35:38 -07008769 ArtField* path_list_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008770 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008771 DCHECK(path_list_field != nullptr);
8772 path_list_field->SetObject<false>(h_path_class_loader.Get(), h_dex_path_list.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008773
8774 // Make a pretend boot-classpath.
8775 // TODO: Should we scan the image?
Mathieu Chartierc7853442015-03-27 14:35:38 -07008776 ArtField* const parent_field =
Vladimir Marko19a4d372016-12-08 14:41:46 +00008777 mirror::Class::FindField(self,
8778 h_path_class_loader->GetClass(),
8779 "parent",
Mathieu Chartierc7853442015-03-27 14:35:38 -07008780 "Ljava/lang/ClassLoader;");
Roland Levillainf39c9eb2015-05-26 15:02:07 +01008781 DCHECK(parent_field != nullptr);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07008782 ObjPtr<mirror::Object> boot_cl =
Mathieu Chartier0795f232016-09-27 18:43:30 -07008783 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader)->AllocObject(self);
Mathieu Chartier966878d2016-01-14 14:33:29 -08008784 parent_field->SetObject<false>(h_path_class_loader.Get(), boot_cl);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008785
8786 // Make it a global ref and return.
8787 ScopedLocalRef<jobject> local_ref(
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07008788 soa.Env(), soa.Env()->AddLocalReference<jobject>(h_path_class_loader.Get()));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008789 return soa.Env()->NewGlobalRef(local_ref.get());
8790}
8791
Andreas Gampe8ac75952015-06-02 21:01:45 -07008792void ClassLinker::DropFindArrayClassCache() {
8793 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
8794 find_array_class_cache_next_victim_ = 0;
8795}
8796
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07008797void ClassLinker::ClearClassTableStrongRoots() const {
8798 Thread* const self = Thread::Current();
8799 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
8800 for (const ClassLoaderData& data : class_loaders_) {
8801 if (data.class_table != nullptr) {
8802 data.class_table->ClearStrongRoots();
8803 }
8804 }
8805}
8806
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008807void ClassLinker::VisitClassLoaders(ClassLoaderVisitor* visitor) const {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008808 Thread* const self = Thread::Current();
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008809 for (const ClassLoaderData& data : class_loaders_) {
Mathieu Chartier4843bd52015-10-01 17:08:44 -07008810 // Need to use DecodeJObject so that we get null for cleared JNI weak globals.
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008811 ObjPtr<mirror::ClassLoader> class_loader = ObjPtr<mirror::ClassLoader>::DownCast(
8812 self->DecodeJObject(data.weak_root));
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008813 if (class_loader != nullptr) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008814 visitor->Visit(class_loader.Ptr());
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008815 }
8816 }
8817}
8818
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008819void ClassLinker::InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file,
8820 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier00310e02015-10-17 12:46:42 -07008821 DCHECK(dex_file != nullptr);
Mathieu Chartier00310e02015-10-17 12:46:42 -07008822 Thread* const self = Thread::Current();
8823 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008824 ClassTable* const table = ClassTableForClassLoader(class_loader.Ptr());
Mathieu Chartier00310e02015-10-17 12:46:42 -07008825 DCHECK(table != nullptr);
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07008826 if (table->InsertStrongRoot(dex_file) && class_loader != nullptr) {
Mathieu Chartier00310e02015-10-17 12:46:42 -07008827 // It was not already inserted, perform the write barrier to let the GC know the class loader's
8828 // class table was modified.
8829 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
8830 }
8831}
8832
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008833void ClassLinker::CleanupClassLoaders() {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008834 Thread* const self = Thread::Current();
Mathieu Chartier65975772016-08-05 10:46:36 -07008835 std::vector<ClassLoaderData> to_delete;
8836 // Do the delete outside the lock to avoid lock violation in jit code cache.
8837 {
8838 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
8839 for (auto it = class_loaders_.begin(); it != class_loaders_.end(); ) {
8840 const ClassLoaderData& data = *it;
8841 // Need to use DecodeJObject so that we get null for cleared JNI weak globals.
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008842 ObjPtr<mirror::ClassLoader> class_loader =
8843 ObjPtr<mirror::ClassLoader>::DownCast(self->DecodeJObject(data.weak_root));
Mathieu Chartier65975772016-08-05 10:46:36 -07008844 if (class_loader != nullptr) {
8845 ++it;
8846 } else {
8847 VLOG(class_linker) << "Freeing class loader";
8848 to_delete.push_back(data);
8849 it = class_loaders_.erase(it);
8850 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008851 }
8852 }
Mathieu Chartier65975772016-08-05 10:46:36 -07008853 for (ClassLoaderData& data : to_delete) {
8854 DeleteClassLoader(self, data);
8855 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008856}
8857
Vladimir Marko21300532017-01-24 18:06:55 +00008858class GetResolvedClassesVisitor : public ClassVisitor {
8859 public:
8860 GetResolvedClassesVisitor(std::set<DexCacheResolvedClasses>* result, bool ignore_boot_classes)
8861 : result_(result),
8862 ignore_boot_classes_(ignore_boot_classes),
8863 last_resolved_classes_(result->end()),
8864 last_dex_file_(nullptr),
8865 vlog_is_on_(VLOG_IS_ON(class_linker)),
8866 extra_stats_(),
8867 last_extra_stats_(extra_stats_.end()) { }
8868
8869 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
8870 if (!klass->IsProxyClass() &&
8871 !klass->IsArrayClass() &&
8872 klass->IsResolved() &&
8873 !klass->IsErroneousResolved() &&
8874 (!ignore_boot_classes_ || klass->GetClassLoader() != nullptr)) {
8875 const DexFile& dex_file = klass->GetDexFile();
8876 if (&dex_file != last_dex_file_) {
8877 last_dex_file_ = &dex_file;
8878 DexCacheResolvedClasses resolved_classes(dex_file.GetLocation(),
8879 dex_file.GetBaseLocation(),
8880 dex_file.GetLocationChecksum());
8881 last_resolved_classes_ = result_->find(resolved_classes);
8882 if (last_resolved_classes_ == result_->end()) {
8883 last_resolved_classes_ = result_->insert(resolved_classes).first;
8884 }
8885 }
8886 bool added = last_resolved_classes_->AddClass(klass->GetDexTypeIndex());
8887 if (UNLIKELY(vlog_is_on_) && added) {
8888 const DexCacheResolvedClasses* resolved_classes = std::addressof(*last_resolved_classes_);
8889 if (last_extra_stats_ == extra_stats_.end() ||
8890 last_extra_stats_->first != resolved_classes) {
8891 last_extra_stats_ = extra_stats_.find(resolved_classes);
8892 if (last_extra_stats_ == extra_stats_.end()) {
8893 last_extra_stats_ =
8894 extra_stats_.emplace(resolved_classes, ExtraStats(dex_file.NumClassDefs())).first;
8895 }
8896 }
8897 }
8898 }
8899 return true;
8900 }
8901
8902 void PrintStatistics() const {
8903 if (vlog_is_on_) {
8904 for (const DexCacheResolvedClasses& resolved_classes : *result_) {
8905 auto it = extra_stats_.find(std::addressof(resolved_classes));
8906 DCHECK(it != extra_stats_.end());
8907 const ExtraStats& extra_stats = it->second;
8908 LOG(INFO) << "Dex location " << resolved_classes.GetDexLocation()
8909 << " has " << resolved_classes.GetClasses().size() << " / "
8910 << extra_stats.number_of_class_defs_ << " resolved classes";
8911 }
8912 }
8913 }
8914
8915 private:
8916 struct ExtraStats {
8917 explicit ExtraStats(uint32_t number_of_class_defs)
8918 : number_of_class_defs_(number_of_class_defs) {}
8919 uint32_t number_of_class_defs_;
8920 };
8921
8922 std::set<DexCacheResolvedClasses>* result_;
8923 bool ignore_boot_classes_;
8924 std::set<DexCacheResolvedClasses>::iterator last_resolved_classes_;
8925 const DexFile* last_dex_file_;
8926
8927 // Statistics.
8928 bool vlog_is_on_;
8929 std::map<const DexCacheResolvedClasses*, ExtraStats> extra_stats_;
8930 std::map<const DexCacheResolvedClasses*, ExtraStats>::iterator last_extra_stats_;
8931};
8932
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008933std::set<DexCacheResolvedClasses> ClassLinker::GetResolvedClasses(bool ignore_boot_classes) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08008934 ScopedTrace trace(__PRETTY_FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008935 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier268764d2016-09-13 12:09:38 -07008936 ScopedAssertNoThreadSuspension ants(__FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008937 std::set<DexCacheResolvedClasses> ret;
8938 VLOG(class_linker) << "Collecting resolved classes";
8939 const uint64_t start_time = NanoTime();
Vladimir Marko21300532017-01-24 18:06:55 +00008940 GetResolvedClassesVisitor visitor(&ret, ignore_boot_classes);
8941 VisitClasses(&visitor);
8942 if (VLOG_IS_ON(class_linker)) {
8943 visitor.PrintStatistics();
8944 LOG(INFO) << "Collecting class profile took " << PrettyDuration(NanoTime() - start_time);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008945 }
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008946 return ret;
8947}
8948
8949std::unordered_set<std::string> ClassLinker::GetClassDescriptorsForProfileKeys(
8950 const std::set<DexCacheResolvedClasses>& classes) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08008951 ScopedTrace trace(__PRETTY_FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008952 std::unordered_set<std::string> ret;
8953 Thread* const self = Thread::Current();
8954 std::unordered_map<std::string, const DexFile*> location_to_dex_file;
8955 ScopedObjectAccess soa(self);
Mathieu Chartier268764d2016-09-13 12:09:38 -07008956 ScopedAssertNoThreadSuspension ants(__FUNCTION__);
Andreas Gampecc1b5352016-12-01 16:58:38 -08008957 ReaderMutexLock mu(self, *Locks::dex_lock_);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008958 for (const ClassLinker::DexCacheData& data : GetDexCachesData()) {
8959 if (!self->IsJWeakCleared(data.weak_root)) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008960 ObjPtr<mirror::DexCache> dex_cache = soa.Decode<mirror::DexCache>(data.weak_root);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008961 if (dex_cache != nullptr) {
8962 const DexFile* dex_file = dex_cache->GetDexFile();
8963 // There could be duplicates if two dex files with the same location are mapped.
8964 location_to_dex_file.emplace(
8965 ProfileCompilationInfo::GetProfileDexFileKey(dex_file->GetLocation()), dex_file);
8966 }
8967 }
8968 }
8969 for (const DexCacheResolvedClasses& info : classes) {
8970 const std::string& profile_key = info.GetDexLocation();
8971 auto found = location_to_dex_file.find(profile_key);
8972 if (found != location_to_dex_file.end()) {
8973 const DexFile* dex_file = found->second;
8974 VLOG(profiler) << "Found opened dex file for " << dex_file->GetLocation() << " with "
8975 << info.GetClasses().size() << " classes";
8976 DCHECK_EQ(dex_file->GetLocationChecksum(), info.GetLocationChecksum());
Andreas Gampea5b09a62016-11-17 15:21:22 -08008977 for (dex::TypeIndex type_idx : info.GetClasses()) {
Jeff Hao54b58552016-11-16 15:15:04 -08008978 const DexFile::TypeId& type_id = dex_file->GetTypeId(type_idx);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008979 const char* descriptor = dex_file->GetTypeDescriptor(type_id);
8980 ret.insert(descriptor);
8981 }
8982 } else {
8983 VLOG(class_linker) << "Failed to find opened dex file for profile key " << profile_key;
8984 }
8985 }
8986 return ret;
8987}
8988
Mathieu Chartier65975772016-08-05 10:46:36 -07008989class ClassLinker::FindVirtualMethodHolderVisitor : public ClassVisitor {
8990 public:
8991 FindVirtualMethodHolderVisitor(const ArtMethod* method, PointerSize pointer_size)
8992 : method_(method),
8993 pointer_size_(pointer_size) {}
8994
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008995 bool operator()(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier65975772016-08-05 10:46:36 -07008996 if (klass->GetVirtualMethodsSliceUnchecked(pointer_size_).Contains(method_)) {
8997 holder_ = klass;
8998 }
8999 // Return false to stop searching if holder_ is not null.
9000 return holder_ == nullptr;
9001 }
9002
Mathieu Chartier28357fa2016-10-18 16:27:40 -07009003 ObjPtr<mirror::Class> holder_ = nullptr;
Mathieu Chartier65975772016-08-05 10:46:36 -07009004 const ArtMethod* const method_;
9005 const PointerSize pointer_size_;
9006};
9007
9008mirror::Class* ClassLinker::GetHoldingClassOfCopiedMethod(ArtMethod* method) {
9009 ScopedTrace trace(__FUNCTION__); // Since this function is slow, have a trace to notify people.
9010 CHECK(method->IsCopied());
9011 FindVirtualMethodHolderVisitor visitor(method, image_pointer_size_);
9012 VisitClasses(&visitor);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07009013 return visitor.holder_.Ptr();
Mathieu Chartier65975772016-08-05 10:46:36 -07009014}
9015
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08009016// Instantiate ResolveMethod.
9017template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kForceICCECheck>(
9018 const DexFile& dex_file,
9019 uint32_t method_idx,
9020 Handle<mirror::DexCache> dex_cache,
9021 Handle<mirror::ClassLoader> class_loader,
9022 ArtMethod* referrer,
9023 InvokeType type);
9024template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kNoICCECheckForCache>(
9025 const DexFile& dex_file,
9026 uint32_t method_idx,
9027 Handle<mirror::DexCache> dex_cache,
9028 Handle<mirror::ClassLoader> class_loader,
9029 ArtMethod* referrer,
9030 InvokeType type);
9031
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07009032} // namespace art