blob: f936db92f58374cd1ac73865a058174e1bb30d67 [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 Marko8d6768d2017-03-14 10:13:21 +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
Mathieu Chartiercdca4762016-04-28 09:44:54 -0700755 // Create conflict tables that depend on the class linker.
756 runtime->FixupConflictTables();
757
Ian Rogers98379392014-02-24 16:53:16 -0800758 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700759
Brian Carlstroma004aa92012-02-08 18:05:09 -0800760 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800761
762 return true;
Brian Carlstroma663ea52011-08-19 23:33:41 -0700763}
764
Ian Rogers98379392014-02-24 16:53:16 -0800765void ClassLinker::FinishInit(Thread* self) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800766 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700767
768 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700769 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700770 // as the types of the field can't be resolved prior to the runtime being
771 // fully initialized
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700772 StackHandleScope<2> hs(self);
773 Handle<mirror::Class> java_lang_ref_Reference = hs.NewHandle(GetClassRoot(kJavaLangRefReference));
774 Handle<mirror::Class> java_lang_ref_FinalizerReference =
775 hs.NewHandle(FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800776
Mathieu Chartierc7853442015-03-27 14:35:38 -0700777 ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700778 CHECK_STREQ(pendingNext->GetName(), "pendingNext");
779 CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700780
Mathieu Chartierc7853442015-03-27 14:35:38 -0700781 ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700782 CHECK_STREQ(queue->GetName(), "queue");
783 CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700784
Mathieu Chartierc7853442015-03-27 14:35:38 -0700785 ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700786 CHECK_STREQ(queueNext->GetName(), "queueNext");
787 CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700788
Mathieu Chartierc7853442015-03-27 14:35:38 -0700789 ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700790 CHECK_STREQ(referent->GetName(), "referent");
791 CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700792
Mathieu Chartierc7853442015-03-27 14:35:38 -0700793 ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700794 CHECK_STREQ(zombie->GetName(), "zombie");
795 CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700796
Brian Carlstroma663ea52011-08-19 23:33:41 -0700797 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700798 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700799 ClassRoot class_root = static_cast<ClassRoot>(i);
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700800 ObjPtr<mirror::Class> klass = GetClassRoot(class_root);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700801 CHECK(klass != nullptr);
802 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != nullptr);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700803 // note SetClassRoot does additional validation.
804 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700805 }
806
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700807 CHECK(!array_iftable_.IsNull());
Elliott Hughes92f14b22011-10-06 12:29:54 -0700808
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700809 // disable the slow paths in FindClass and CreatePrimitiveClass now
810 // that Object, Class, and Object[] are setup
811 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700812
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800813 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700814}
815
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700816void ClassLinker::RunRootClinits() {
817 Thread* self = Thread::Current();
818 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700819 ObjPtr<mirror::Class> c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700820 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700821 StackHandleScope<1> hs(self);
822 Handle<mirror::Class> h_class(hs.NewHandle(GetClassRoot(ClassRoot(i))));
Ian Rogers7b078e82014-09-10 14:44:24 -0700823 EnsureInitialized(self, h_class, true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700824 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700825 }
826 }
827}
828
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200829// Set image methods' entry point to interpreter.
830class SetInterpreterEntrypointArtMethodVisitor : public ArtMethodVisitor {
831 public:
Andreas Gampe542451c2016-07-26 09:02:02 -0700832 explicit SetInterpreterEntrypointArtMethodVisitor(PointerSize image_pointer_size)
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200833 : image_pointer_size_(image_pointer_size) {}
834
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700835 void Visit(ArtMethod* method) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200836 if (kIsDebugBuild && !method->IsRuntimeMethod()) {
837 CHECK(method->GetDeclaringClass() != nullptr);
838 }
839 if (!method->IsNative() && !method->IsRuntimeMethod() && !method->IsResolutionMethod()) {
840 method->SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(),
841 image_pointer_size_);
842 }
843 }
844
845 private:
Andreas Gampe542451c2016-07-26 09:02:02 -0700846 const PointerSize image_pointer_size_;
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200847
848 DISALLOW_COPY_AND_ASSIGN(SetInterpreterEntrypointArtMethodVisitor);
849};
850
Jeff Haodcdc85b2015-12-04 14:06:18 -0800851struct TrampolineCheckData {
852 const void* quick_resolution_trampoline;
853 const void* quick_imt_conflict_trampoline;
854 const void* quick_generic_jni_trampoline;
855 const void* quick_to_interpreter_bridge_trampoline;
Andreas Gampe542451c2016-07-26 09:02:02 -0700856 PointerSize pointer_size;
Jeff Haodcdc85b2015-12-04 14:06:18 -0800857 ArtMethod* m;
858 bool error;
859};
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800860
Jeff Haodcdc85b2015-12-04 14:06:18 -0800861static void CheckTrampolines(mirror::Object* obj, void* arg) NO_THREAD_SAFETY_ANALYSIS {
862 if (obj->IsClass()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700863 ObjPtr<mirror::Class> klass = obj->AsClass();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800864 TrampolineCheckData* d = reinterpret_cast<TrampolineCheckData*>(arg);
865 for (ArtMethod& m : klass->GetMethods(d->pointer_size)) {
866 const void* entrypoint = m.GetEntryPointFromQuickCompiledCodePtrSize(d->pointer_size);
867 if (entrypoint == d->quick_resolution_trampoline ||
868 entrypoint == d->quick_imt_conflict_trampoline ||
869 entrypoint == d->quick_generic_jni_trampoline ||
870 entrypoint == d->quick_to_interpreter_bridge_trampoline) {
871 d->m = &m;
872 d->error = true;
873 return;
874 }
875 }
876 }
877}
878
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800879bool ClassLinker::InitFromBootImage(std::string* error_msg) {
880 VLOG(startup) << __FUNCTION__ << " entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700881 CHECK(!init_done_);
882
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700883 Runtime* const runtime = Runtime::Current();
884 Thread* const self = Thread::Current();
885 gc::Heap* const heap = runtime->GetHeap();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800886 std::vector<gc::space::ImageSpace*> spaces = heap->GetBootImageSpaces();
887 CHECK(!spaces.empty());
Andreas Gampe542451c2016-07-26 09:02:02 -0700888 uint32_t pointer_size_unchecked = spaces[0]->GetImageHeader().GetPointerSizeUnchecked();
889 if (!ValidPointerSize(pointer_size_unchecked)) {
890 *error_msg = StringPrintf("Invalid image pointer size: %u", pointer_size_unchecked);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800891 return false;
892 }
Andreas Gampe542451c2016-07-26 09:02:02 -0700893 image_pointer_size_ = spaces[0]->GetImageHeader().GetPointerSize();
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800894 if (!runtime->IsAotCompiler()) {
895 // Only the Aot compiler supports having an image with a different pointer size than the
896 // runtime. This happens on the host for compiling 32 bit tests since we use a 64 bit libart
897 // compiler. We may also use 32 bit dex2oat on a system with 64 bit apps.
Andreas Gampe542451c2016-07-26 09:02:02 -0700898 if (image_pointer_size_ != kRuntimePointerSize) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800899 *error_msg = StringPrintf("Runtime must use current image pointer size: %zu vs %zu",
Andreas Gampe542451c2016-07-26 09:02:02 -0700900 static_cast<size_t>(image_pointer_size_),
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800901 sizeof(void*));
902 return false;
903 }
904 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800905 std::vector<const OatFile*> oat_files =
906 runtime->GetOatFileManager().RegisterImageOatFiles(spaces);
907 DCHECK(!oat_files.empty());
908 const OatHeader& default_oat_header = oat_files[0]->GetOatHeader();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800909 CHECK_EQ(default_oat_header.GetImageFileLocationOatDataBegin(), 0U);
910 const char* image_file_location = oat_files[0]->GetOatHeader().
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700911 GetStoreValueByKey(OatHeader::kImageLocationKey);
912 CHECK(image_file_location == nullptr || *image_file_location == 0);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800913 quick_resolution_trampoline_ = default_oat_header.GetQuickResolutionTrampoline();
914 quick_imt_conflict_trampoline_ = default_oat_header.GetQuickImtConflictTrampoline();
915 quick_generic_jni_trampoline_ = default_oat_header.GetQuickGenericJniTrampoline();
916 quick_to_interpreter_bridge_trampoline_ = default_oat_header.GetQuickToInterpreterBridge();
917 if (kIsDebugBuild) {
918 // Check that the other images use the same trampoline.
919 for (size_t i = 1; i < oat_files.size(); ++i) {
920 const OatHeader& ith_oat_header = oat_files[i]->GetOatHeader();
921 const void* ith_quick_resolution_trampoline =
922 ith_oat_header.GetQuickResolutionTrampoline();
923 const void* ith_quick_imt_conflict_trampoline =
924 ith_oat_header.GetQuickImtConflictTrampoline();
925 const void* ith_quick_generic_jni_trampoline =
926 ith_oat_header.GetQuickGenericJniTrampoline();
927 const void* ith_quick_to_interpreter_bridge_trampoline =
928 ith_oat_header.GetQuickToInterpreterBridge();
929 if (ith_quick_resolution_trampoline != quick_resolution_trampoline_ ||
930 ith_quick_imt_conflict_trampoline != quick_imt_conflict_trampoline_ ||
931 ith_quick_generic_jni_trampoline != quick_generic_jni_trampoline_ ||
932 ith_quick_to_interpreter_bridge_trampoline != quick_to_interpreter_bridge_trampoline_) {
933 // Make sure that all methods in this image do not contain those trampolines as
934 // entrypoints. Otherwise the class-linker won't be able to work with a single set.
935 TrampolineCheckData data;
936 data.error = false;
937 data.pointer_size = GetImagePointerSize();
938 data.quick_resolution_trampoline = ith_quick_resolution_trampoline;
939 data.quick_imt_conflict_trampoline = ith_quick_imt_conflict_trampoline;
940 data.quick_generic_jni_trampoline = ith_quick_generic_jni_trampoline;
941 data.quick_to_interpreter_bridge_trampoline = ith_quick_to_interpreter_bridge_trampoline;
942 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
943 spaces[i]->GetLiveBitmap()->Walk(CheckTrampolines, &data);
944 if (data.error) {
945 ArtMethod* m = data.m;
David Sehr709b0702016-10-13 09:12:37 -0700946 LOG(ERROR) << "Found a broken ArtMethod: " << ArtMethod::PrettyMethod(m);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800947 *error_msg = "Found an ArtMethod with a bad entrypoint";
948 return false;
949 }
950 }
951 }
952 }
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700953
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800954 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(
955 down_cast<mirror::ObjectArray<mirror::Class>*>(
956 spaces[0]->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)));
957 mirror::Class::SetClassClass(class_roots_.Read()->Get(kJavaLangClass));
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700958
Brian Carlstromfddf6f62012-03-15 16:56:45 -0700959 // Special case of setting up the String class early so that we can test arbitrary objects
960 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -0700961 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800962
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700963 ObjPtr<mirror::Class> java_lang_Object = GetClassRoot(kJavaLangObject);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700964 java_lang_Object->SetObjectSize(sizeof(mirror::Object));
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800965 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been
966 // cleared without triggering the read barrier and unintentionally mark the sentinel alive.
Jeff Haodcdc85b2015-12-04 14:06:18 -0800967 runtime->SetSentinel(heap->AllocNonMovableObject<true>(
968 self, java_lang_Object, java_lang_Object->GetObjectSize(), VoidFunctor()));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700969
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800970 // reinit array_iftable_ from any array class instance, they should be ==
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700971 array_iftable_ = GcRoot<mirror::IfTable>(GetClassRoot(kObjectArrayClass)->GetIfTable());
Mathieu Chartier2d721012014-11-10 11:08:06 -0800972 DCHECK_EQ(array_iftable_.Read(), GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800973 // String class root was set above
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700974 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
975 mirror::Field::SetArrayClass(GetClassRoot(kJavaLangReflectFieldArrayClass));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700976 mirror::Constructor::SetClass(GetClassRoot(kJavaLangReflectConstructor));
977 mirror::Constructor::SetArrayClass(GetClassRoot(kJavaLangReflectConstructorArrayClass));
978 mirror::Method::SetClass(GetClassRoot(kJavaLangReflectMethod));
979 mirror::Method::SetArrayClass(GetClassRoot(kJavaLangReflectMethodArrayClass));
Narayan Kamathafa48272016-08-03 12:46:58 +0100980 mirror::MethodType::SetClass(GetClassRoot(kJavaLangInvokeMethodType));
981 mirror::MethodHandleImpl::SetClass(GetClassRoot(kJavaLangInvokeMethodHandleImpl));
Orion Hodsonc069a302017-01-18 09:23:12 +0000982 mirror::MethodHandlesLookup::SetClass(GetClassRoot(kJavaLangInvokeMethodHandlesLookup));
983 mirror::CallSite::SetClass(GetClassRoot(kJavaLangInvokeCallSite));
Fred Shih4ee7a662014-07-11 09:59:27 -0700984 mirror::Reference::SetClass(GetClassRoot(kJavaLangRefReference));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800985 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
986 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
987 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
988 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
989 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
990 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
991 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
992 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
993 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
994 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Narayan Kamath000e1882016-10-24 17:14:25 +0100995 mirror::EmulatedStackFrame::SetClass(GetClassRoot(kDalvikSystemEmulatedStackFrame));
Alex Lightd6251582016-10-31 11:12:30 -0700996 mirror::ClassExt::SetClass(GetClassRoot(kDalvikSystemClassExt));
Brian Carlstroma663ea52011-08-19 23:33:41 -0700997
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800998 for (gc::space::ImageSpace* image_space : spaces) {
999 // Boot class loader, use a null handle.
1000 std::vector<std::unique_ptr<const DexFile>> dex_files;
1001 if (!AddImageSpace(image_space,
1002 ScopedNullHandle<mirror::ClassLoader>(),
1003 /*dex_elements*/nullptr,
1004 /*dex_location*/nullptr,
1005 /*out*/&dex_files,
1006 error_msg)) {
1007 return false;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001008 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001009 // Append opened dex files at the end.
1010 boot_dex_files_.insert(boot_dex_files_.end(),
1011 std::make_move_iterator(dex_files.begin()),
1012 std::make_move_iterator(dex_files.end()));
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08001013 }
Ian Rogers98379392014-02-24 16:53:16 -08001014 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001015
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001016 VLOG(startup) << __FUNCTION__ << " exiting";
1017 return true;
1018}
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001019
Jeff Hao5872d7c2016-04-27 11:07:41 -07001020bool ClassLinker::IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001021 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001022 return class_loader == nullptr ||
Mathieu Chartier0795f232016-09-27 18:43:30 -07001023 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader) ==
1024 class_loader->GetClass();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001025}
1026
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001027static bool GetDexPathListElementName(ObjPtr<mirror::Object> element,
1028 ObjPtr<mirror::String>* out_name)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001029 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001030 ArtField* const dex_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001031 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001032 ArtField* const dex_file_name_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001033 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_fileName);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001034 DCHECK(dex_file_field != nullptr);
1035 DCHECK(dex_file_name_field != nullptr);
1036 DCHECK(element != nullptr);
David Sehr709b0702016-10-13 09:12:37 -07001037 CHECK_EQ(dex_file_field->GetDeclaringClass(), element->GetClass()) << element->PrettyTypeOf();
Mathieu Chartier3398c782016-09-30 10:27:43 -07001038 ObjPtr<mirror::Object> dex_file = dex_file_field->GetObject(element);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001039 if (dex_file == nullptr) {
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001040 // Null dex file means it was probably a jar with no dex files, return a null string.
1041 *out_name = nullptr;
1042 return true;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001043 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07001044 ObjPtr<mirror::Object> name_object = dex_file_name_field->GetObject(dex_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001045 if (name_object != nullptr) {
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001046 *out_name = name_object->AsString();
1047 return true;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001048 }
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001049 return false;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001050}
1051
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001052static bool FlattenPathClassLoader(ObjPtr<mirror::ClassLoader> class_loader,
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001053 std::list<ObjPtr<mirror::String>>* out_dex_file_names,
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001054 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001055 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001056 DCHECK(out_dex_file_names != nullptr);
1057 DCHECK(error_msg != nullptr);
1058 ScopedObjectAccessUnchecked soa(Thread::Current());
1059 ArtField* const dex_path_list_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001060 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001061 ArtField* const dex_elements_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001062 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001063 CHECK(dex_path_list_field != nullptr);
1064 CHECK(dex_elements_field != nullptr);
Jeff Hao5872d7c2016-04-27 11:07:41 -07001065 while (!ClassLinker::IsBootClassLoader(soa, class_loader)) {
Mathieu Chartier0795f232016-09-27 18:43:30 -07001066 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader) !=
1067 class_loader->GetClass()) {
David Sehr709b0702016-10-13 09:12:37 -07001068 *error_msg = StringPrintf("Unknown class loader type %s",
1069 class_loader->PrettyTypeOf().c_str());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001070 // Unsupported class loader.
1071 return false;
1072 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07001073 ObjPtr<mirror::Object> dex_path_list = dex_path_list_field->GetObject(class_loader);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001074 if (dex_path_list != nullptr) {
1075 // DexPathList has an array dexElements of Elements[] which each contain a dex file.
Mathieu Chartier3398c782016-09-30 10:27:43 -07001076 ObjPtr<mirror::Object> dex_elements_obj = dex_elements_field->GetObject(dex_path_list);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001077 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
1078 // at the mCookie which is a DexFile vector.
1079 if (dex_elements_obj != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001080 ObjPtr<mirror::ObjectArray<mirror::Object>> dex_elements =
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001081 dex_elements_obj->AsObjectArray<mirror::Object>();
1082 // Reverse order since we insert the parent at the front.
1083 for (int32_t i = dex_elements->GetLength() - 1; i >= 0; --i) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001084 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001085 if (element == nullptr) {
1086 *error_msg = StringPrintf("Null dex element at index %d", i);
1087 return false;
1088 }
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001089 ObjPtr<mirror::String> name;
1090 if (!GetDexPathListElementName(element, &name)) {
1091 *error_msg = StringPrintf("Invalid dex path list element at index %d", i);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001092 return false;
1093 }
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001094 if (name != nullptr) {
1095 out_dex_file_names->push_front(name.Ptr());
1096 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001097 }
1098 }
1099 }
1100 class_loader = class_loader->GetParent();
1101 }
1102 return true;
1103}
1104
1105class FixupArtMethodArrayVisitor : public ArtMethodVisitor {
1106 public:
1107 explicit FixupArtMethodArrayVisitor(const ImageHeader& header) : header_(header) {}
1108
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001109 virtual void Visit(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light36121492016-02-22 13:43:29 -08001110 const bool is_copied = method->IsCopied();
Andreas Gampe542451c2016-07-26 09:02:02 -07001111 ArtMethod** resolved_methods = method->GetDexCacheResolvedMethods(kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001112 if (resolved_methods != nullptr) {
1113 bool in_image_space = false;
Alex Light36121492016-02-22 13:43:29 -08001114 if (kIsDebugBuild || is_copied) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001115 in_image_space = header_.GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains(
1116 reinterpret_cast<const uint8_t*>(resolved_methods) - header_.GetImageBegin());
1117 }
1118 // Must be in image space for non-miranda method.
Alex Light36121492016-02-22 13:43:29 -08001119 DCHECK(is_copied || in_image_space)
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001120 << resolved_methods << " is not in image starting at "
1121 << reinterpret_cast<void*>(header_.GetImageBegin());
Alex Light36121492016-02-22 13:43:29 -08001122 if (!is_copied || in_image_space) {
Vladimir Marko6dd14882016-10-25 11:51:35 +01001123 method->SetDexCacheResolvedMethods(method->GetDexCache()->GetResolvedMethods(),
Andreas Gampe542451c2016-07-26 09:02:02 -07001124 kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001125 }
1126 }
1127 }
1128
1129 private:
1130 const ImageHeader& header_;
1131};
1132
1133class VerifyClassInTableArtMethodVisitor : public ArtMethodVisitor {
1134 public:
1135 explicit VerifyClassInTableArtMethodVisitor(ClassTable* table) : table_(table) {}
1136
1137 virtual void Visit(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001138 REQUIRES_SHARED(Locks::mutator_lock_, Locks::classlinker_classes_lock_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001139 ObjPtr<mirror::Class> klass = method->GetDeclaringClass();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001140 if (klass != nullptr && !Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) {
David Sehr709b0702016-10-13 09:12:37 -07001141 CHECK_EQ(table_->LookupByDescriptor(klass), klass) << mirror::Class::PrettyClass(klass);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001142 }
1143 }
1144
1145 private:
1146 ClassTable* const table_;
1147};
1148
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001149class VerifyDirectInterfacesInTableClassVisitor {
1150 public:
1151 explicit VerifyDirectInterfacesInTableClassVisitor(ObjPtr<mirror::ClassLoader> class_loader)
1152 : class_loader_(class_loader), self_(Thread::Current()) { }
1153
1154 bool operator()(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) {
1155 if (!klass->IsPrimitive() && klass->GetClassLoader() == class_loader_) {
1156 classes_.push_back(klass);
1157 }
1158 return true;
1159 }
1160
1161 void Check() const REQUIRES_SHARED(Locks::mutator_lock_) {
1162 for (ObjPtr<mirror::Class> klass : classes_) {
1163 for (uint32_t i = 0, num = klass->NumDirectInterfaces(); i != num; ++i) {
1164 CHECK(klass->GetDirectInterface(self_, klass, i) != nullptr)
1165 << klass->PrettyDescriptor() << " iface #" << i;
1166 }
1167 }
1168 }
1169
1170 private:
1171 ObjPtr<mirror::ClassLoader> class_loader_;
1172 Thread* self_;
1173 std::vector<ObjPtr<mirror::Class>> classes_;
1174};
1175
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001176class VerifyDeclaringClassVisitor : public ArtMethodVisitor {
1177 public:
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001178 VerifyDeclaringClassVisitor() REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_)
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001179 : live_bitmap_(Runtime::Current()->GetHeap()->GetLiveBitmap()) {}
1180
1181 virtual void Visit(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001182 REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001183 ObjPtr<mirror::Class> klass = method->GetDeclaringClassUnchecked();
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001184 if (klass != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001185 CHECK(live_bitmap_->Test(klass.Ptr())) << "Image method has unmarked declaring class";
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001186 }
1187 }
1188
1189 private:
1190 gc::accounting::HeapBitmap* const live_bitmap_;
1191};
1192
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001193// Copies data from one array to another array at the same position
1194// if pred returns false. If there is a page of continuous data in
1195// the src array for which pred consistently returns true then
1196// corresponding page in the dst array will not be touched.
1197// This should reduce number of allocated physical pages.
1198template <class T, class NullPred>
1199static void CopyNonNull(const T* src, size_t count, T* dst, const NullPred& pred) {
1200 for (size_t i = 0; i < count; ++i) {
1201 if (!pred(src[i])) {
1202 dst[i] = src[i];
1203 }
1204 }
1205}
1206
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001207template <typename T>
1208static void CopyDexCachePairs(const std::atomic<mirror::DexCachePair<T>>* src,
1209 size_t count,
1210 std::atomic<mirror::DexCachePair<T>>* dst) {
1211 DCHECK_NE(count, 0u);
1212 DCHECK(!src[0].load(std::memory_order_relaxed).object.IsNull() ||
1213 src[0].load(std::memory_order_relaxed).index != 0u);
1214 for (size_t i = 0; i < count; ++i) {
1215 DCHECK_EQ(dst[i].load(std::memory_order_relaxed).index, 0u);
1216 DCHECK(dst[i].load(std::memory_order_relaxed).object.IsNull());
1217 mirror::DexCachePair<T> source = src[i].load(std::memory_order_relaxed);
1218 if (source.index != 0u || !source.object.IsNull()) {
1219 dst[i].store(source, std::memory_order_relaxed);
1220 }
1221 }
1222}
1223
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001224bool ClassLinker::UpdateAppImageClassLoadersAndDexCaches(
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001225 gc::space::ImageSpace* space,
1226 Handle<mirror::ClassLoader> class_loader,
1227 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
Mathieu Chartier69731002016-03-02 16:08:31 -08001228 ClassTable::ClassSet* new_class_set,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001229 bool* out_forward_dex_cache_array,
1230 std::string* out_error_msg) {
1231 DCHECK(out_forward_dex_cache_array != nullptr);
1232 DCHECK(out_error_msg != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001233 Thread* const self = Thread::Current();
1234 gc::Heap* const heap = Runtime::Current()->GetHeap();
1235 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001236 {
1237 // Add image classes into the class table for the class loader, and fixup the dex caches and
1238 // class loader fields.
1239 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001240 // Dex cache array fixup is all or nothing, we must reject app images that have mixed since we
1241 // rely on clobering the dex cache arrays in the image to forward to bss.
1242 size_t num_dex_caches_with_bss_arrays = 0;
1243 const size_t num_dex_caches = dex_caches->GetLength();
1244 for (size_t i = 0; i < num_dex_caches; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001245 ObjPtr<mirror::DexCache> const dex_cache = dex_caches->Get(i);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001246 const DexFile* const dex_file = dex_cache->GetDexFile();
1247 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
1248 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
1249 ++num_dex_caches_with_bss_arrays;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001250 }
1251 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001252 *out_forward_dex_cache_array = num_dex_caches_with_bss_arrays != 0;
1253 if (*out_forward_dex_cache_array) {
1254 if (num_dex_caches_with_bss_arrays != num_dex_caches) {
1255 // Reject application image since we cannot forward only some of the dex cache arrays.
1256 // TODO: We could get around this by having a dedicated forwarding slot. It should be an
1257 // uncommon case.
1258 *out_error_msg = StringPrintf("Dex caches in bss does not match total: %zu vs %zu",
1259 num_dex_caches_with_bss_arrays,
1260 num_dex_caches);
1261 return false;
1262 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001263 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001264 // Only add the classes to the class loader after the points where we can return false.
1265 for (size_t i = 0; i < num_dex_caches; i++) {
Vladimir Marko1bc4b172016-10-24 16:53:39 +00001266 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001267 const DexFile* const dex_file = dex_cache->GetDexFile();
1268 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
1269 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01001270 // 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 -08001271 // copy over the arrays.
1272 DCHECK(dex_file != nullptr);
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001273 size_t num_strings = mirror::DexCache::kDexCacheStringCacheSize;
1274 if (dex_file->NumStringIds() < num_strings) {
1275 num_strings = dex_file->NumStringIds();
1276 }
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001277 size_t num_types = mirror::DexCache::kDexCacheTypeCacheSize;
1278 if (dex_file->NumTypeIds() < num_types) {
1279 num_types = dex_file->NumTypeIds();
1280 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001281 const size_t num_methods = dex_file->NumMethodIds();
Vladimir Markof44d36c2017-03-14 14:18:46 +00001282 size_t num_fields = mirror::DexCache::kDexCacheFieldCacheSize;
1283 if (dex_file->NumFieldIds() < num_fields) {
1284 num_fields = dex_file->NumFieldIds();
1285 }
Narayan Kamath269cb432016-10-28 10:19:54 +01001286 size_t num_method_types = mirror::DexCache::kDexCacheMethodTypeCacheSize;
1287 if (dex_file->NumProtoIds() < num_method_types) {
1288 num_method_types = dex_file->NumProtoIds();
Narayan Kamath25352fc2016-08-03 12:46:58 +01001289 }
Orion Hodsonc069a302017-01-18 09:23:12 +00001290 const size_t num_call_sites = dex_file->NumCallSiteIds();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001291 CHECK_EQ(num_strings, dex_cache->NumStrings());
1292 CHECK_EQ(num_types, dex_cache->NumResolvedTypes());
1293 CHECK_EQ(num_methods, dex_cache->NumResolvedMethods());
1294 CHECK_EQ(num_fields, dex_cache->NumResolvedFields());
Narayan Kamath25352fc2016-08-03 12:46:58 +01001295 CHECK_EQ(num_method_types, dex_cache->NumResolvedMethodTypes());
Orion Hodsonc069a302017-01-18 09:23:12 +00001296 CHECK_EQ(num_call_sites, dex_cache->NumResolvedCallSites());
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001297 DexCacheArraysLayout layout(image_pointer_size_, dex_file);
1298 uint8_t* const raw_arrays = oat_dex_file->GetDexCacheArrays();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001299 if (num_strings != 0u) {
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001300 mirror::StringDexCacheType* const image_resolved_strings = dex_cache->GetStrings();
1301 mirror::StringDexCacheType* const strings =
1302 reinterpret_cast<mirror::StringDexCacheType*>(raw_arrays + layout.StringsOffset());
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001303 CopyDexCachePairs(image_resolved_strings, num_strings, strings);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001304 dex_cache->SetStrings(strings);
1305 }
1306 if (num_types != 0u) {
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001307 mirror::TypeDexCacheType* const image_resolved_types = dex_cache->GetResolvedTypes();
1308 mirror::TypeDexCacheType* const types =
1309 reinterpret_cast<mirror::TypeDexCacheType*>(raw_arrays + layout.TypesOffset());
1310 CopyDexCachePairs(image_resolved_types, num_types, types);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001311 dex_cache->SetResolvedTypes(types);
1312 }
1313 if (num_methods != 0u) {
1314 ArtMethod** const methods = reinterpret_cast<ArtMethod**>(
1315 raw_arrays + layout.MethodsOffset());
1316 ArtMethod** const image_resolved_methods = dex_cache->GetResolvedMethods();
1317 for (size_t j = 0; kIsDebugBuild && j < num_methods; ++j) {
1318 DCHECK(methods[j] == nullptr);
1319 }
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001320 CopyNonNull(image_resolved_methods,
1321 num_methods,
1322 methods,
1323 [] (const ArtMethod* method) {
1324 return method == nullptr;
1325 });
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001326 dex_cache->SetResolvedMethods(methods);
1327 }
1328 if (num_fields != 0u) {
Vladimir Markof44d36c2017-03-14 14:18:46 +00001329 mirror::FieldDexCacheType* const image_resolved_fields = dex_cache->GetResolvedFields();
1330 mirror::FieldDexCacheType* const fields =
1331 reinterpret_cast<mirror::FieldDexCacheType*>(raw_arrays + layout.FieldsOffset());
1332 for (size_t j = 0; j < num_fields; ++j) {
1333 DCHECK_EQ(mirror::DexCache::GetNativePairPtrSize(fields, j, image_pointer_size_).index,
1334 0u);
1335 DCHECK(mirror::DexCache::GetNativePairPtrSize(fields, j, image_pointer_size_).object ==
1336 nullptr);
1337 mirror::DexCache::SetNativePairPtrSize(
1338 fields,
1339 j,
1340 mirror::DexCache::GetNativePairPtrSize(image_resolved_fields,
1341 j,
1342 image_pointer_size_),
1343 image_pointer_size_);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001344 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001345 dex_cache->SetResolvedFields(fields);
1346 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01001347 if (num_method_types != 0u) {
1348 // NOTE: We currently (Sep 2016) do not resolve any method types at
1349 // compile time, but plan to in the future. This code exists for the
1350 // sake of completeness.
1351 mirror::MethodTypeDexCacheType* const image_resolved_method_types =
1352 dex_cache->GetResolvedMethodTypes();
1353 mirror::MethodTypeDexCacheType* const method_types =
1354 reinterpret_cast<mirror::MethodTypeDexCacheType*>(
1355 raw_arrays + layout.MethodTypesOffset());
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001356 CopyDexCachePairs(image_resolved_method_types, num_method_types, method_types);
Narayan Kamath25352fc2016-08-03 12:46:58 +01001357 dex_cache->SetResolvedMethodTypes(method_types);
1358 }
Orion Hodsonc069a302017-01-18 09:23:12 +00001359 if (num_call_sites != 0u) {
1360 GcRoot<mirror::CallSite>* const image_resolved_call_sites =
1361 dex_cache->GetResolvedCallSites();
1362 GcRoot<mirror::CallSite>* const call_sites =
1363 reinterpret_cast<GcRoot<mirror::CallSite>*>(raw_arrays + layout.CallSitesOffset());
1364 for (size_t j = 0; kIsDebugBuild && j < num_call_sites; ++j) {
1365 DCHECK(call_sites[j].IsNull());
1366 }
1367 CopyNonNull(image_resolved_call_sites,
1368 num_call_sites,
1369 call_sites,
1370 [](const GcRoot<mirror::CallSite>& elem) {
1371 return elem.IsNull();
1372 });
1373 dex_cache->SetResolvedCallSites(call_sites);
1374 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001375 }
1376 {
Andreas Gampecc1b5352016-12-01 16:58:38 -08001377 WriterMutexLock mu2(self, *Locks::dex_lock_);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001378 // Make sure to do this after we update the arrays since we store the resolved types array
1379 // in DexCacheData in RegisterDexFileLocked. We need the array pointer to be the one in the
1380 // BSS.
Vladimir Markocd556b02017-02-03 11:47:34 +00001381 CHECK(!FindDexCacheDataLocked(*dex_file).IsValid());
1382 RegisterDexFileLocked(*dex_file, dex_cache, class_loader.Get());
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001383 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001384 if (kIsDebugBuild) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01001385 CHECK(new_class_set != nullptr);
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001386 mirror::TypeDexCacheType* const types = dex_cache->GetResolvedTypes();
Vladimir Marko1a1de672016-10-13 12:53:15 +01001387 const size_t num_types = dex_cache->NumResolvedTypes();
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001388 for (size_t j = 0; j != num_types; ++j) {
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001389 // The image space is not yet added to the heap, avoid read barriers.
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001390 ObjPtr<mirror::Class> klass = types[j].load(std::memory_order_relaxed).object.Read();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001391 if (space->HasAddress(klass.Ptr())) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00001392 DCHECK(!klass->IsErroneous()) << klass->GetStatus();
Mathieu Chartier58c3f6a2016-12-01 14:21:11 -08001393 auto it = new_class_set->Find(ClassTable::TableSlot(klass));
Vladimir Marko1a1de672016-10-13 12:53:15 +01001394 DCHECK(it != new_class_set->end());
1395 DCHECK_EQ(it->Read(), klass);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001396 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Vladimir Marko1a1de672016-10-13 12:53:15 +01001397 if (super_class != nullptr && !heap->ObjectIsInBootImageSpace(super_class)) {
Mathieu Chartier58c3f6a2016-12-01 14:21:11 -08001398 auto it2 = new_class_set->Find(ClassTable::TableSlot(super_class));
Vladimir Marko1a1de672016-10-13 12:53:15 +01001399 DCHECK(it2 != new_class_set->end());
1400 DCHECK_EQ(it2->Read(), super_class);
1401 }
1402 for (ArtMethod& m : klass->GetDirectMethods(kRuntimePointerSize)) {
1403 const void* code = m.GetEntryPointFromQuickCompiledCode();
1404 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
1405 if (!IsQuickResolutionStub(code) &&
1406 !IsQuickGenericJniStub(code) &&
1407 !IsQuickToInterpreterBridge(code) &&
1408 !m.IsNative()) {
David Sehr709b0702016-10-13 09:12:37 -07001409 DCHECK_EQ(code, oat_code) << m.PrettyMethod();
Mathieu Chartier69731002016-03-02 16:08:31 -08001410 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001411 }
Vladimir Marko1a1de672016-10-13 12:53:15 +01001412 for (ArtMethod& m : klass->GetVirtualMethods(kRuntimePointerSize)) {
1413 const void* code = m.GetEntryPointFromQuickCompiledCode();
1414 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
1415 if (!IsQuickResolutionStub(code) &&
1416 !IsQuickGenericJniStub(code) &&
1417 !IsQuickToInterpreterBridge(code) &&
1418 !m.IsNative()) {
David Sehr709b0702016-10-13 09:12:37 -07001419 DCHECK_EQ(code, oat_code) << m.PrettyMethod();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001420 }
1421 }
1422 }
1423 }
1424 }
1425 }
Mathieu Chartiera0b95212016-03-07 16:13:54 -08001426 }
1427 if (*out_forward_dex_cache_array) {
1428 ScopedTrace timing("Fixup ArtMethod dex cache arrays");
1429 FixupArtMethodArrayVisitor visitor(header);
Andreas Gampe542451c2016-07-26 09:02:02 -07001430 header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
Mathieu Chartiera0b95212016-03-07 16:13:54 -08001431 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get());
1432 }
1433 if (kVerifyArtMethodDeclaringClasses) {
1434 ScopedTrace timing("Verify declaring classes");
1435 ReaderMutexLock rmu(self, *Locks::heap_bitmap_lock_);
1436 VerifyDeclaringClassVisitor visitor;
Andreas Gampe542451c2016-07-26 09:02:02 -07001437 header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001438 }
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001439 return true;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001440}
1441
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001442// Update the class loader. Should only be used on classes in the image space.
1443class UpdateClassLoaderVisitor {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001444 public:
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001445 UpdateClassLoaderVisitor(gc::space::ImageSpace* space, ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001446 : space_(space),
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001447 class_loader_(class_loader) {}
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001448
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001449 bool operator()(ObjPtr<mirror::Class> klass) const REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00001450 // Do not update class loader for boot image classes where the app image
1451 // class loader is only the initiating loader but not the defining loader.
1452 if (klass->GetClassLoader() != nullptr) {
1453 klass->SetClassLoader(class_loader_);
1454 }
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001455 return true;
1456 }
1457
1458 gc::space::ImageSpace* const space_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001459 ObjPtr<mirror::ClassLoader> const class_loader_;
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001460};
1461
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001462static std::unique_ptr<const DexFile> OpenOatDexFile(const OatFile* oat_file,
1463 const char* location,
1464 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001465 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001466 DCHECK(error_msg != nullptr);
1467 std::unique_ptr<const DexFile> dex_file;
Richard Uhler9a37efc2016-08-05 16:32:55 -07001468 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(location, nullptr, error_msg);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001469 if (oat_dex_file == nullptr) {
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001470 return std::unique_ptr<const DexFile>();
1471 }
1472 std::string inner_error_msg;
1473 dex_file = oat_dex_file->OpenDexFile(&inner_error_msg);
1474 if (dex_file == nullptr) {
1475 *error_msg = StringPrintf("Failed to open dex file %s from within oat file %s error '%s'",
1476 location,
1477 oat_file->GetLocation().c_str(),
1478 inner_error_msg.c_str());
1479 return std::unique_ptr<const DexFile>();
1480 }
1481
1482 if (dex_file->GetLocationChecksum() != oat_dex_file->GetDexFileLocationChecksum()) {
1483 *error_msg = StringPrintf("Checksums do not match for %s: %x vs %x",
1484 location,
1485 dex_file->GetLocationChecksum(),
1486 oat_dex_file->GetDexFileLocationChecksum());
1487 return std::unique_ptr<const DexFile>();
1488 }
1489 return dex_file;
1490}
1491
1492bool ClassLinker::OpenImageDexFiles(gc::space::ImageSpace* space,
1493 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
1494 std::string* error_msg) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07001495 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001496 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001497 ObjPtr<mirror::Object> dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001498 DCHECK(dex_caches_object != nullptr);
1499 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1500 dex_caches_object->AsObjectArray<mirror::DexCache>();
1501 const OatFile* oat_file = space->GetOatFile();
1502 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001503 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001504 std::string dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
1505 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file,
1506 dex_file_location.c_str(),
1507 error_msg);
1508 if (dex_file == nullptr) {
1509 return false;
1510 }
1511 dex_cache->SetDexFile(dex_file.get());
1512 out_dex_files->push_back(std::move(dex_file));
1513 }
1514 return true;
1515}
1516
Andreas Gampe0793bec2016-12-01 11:37:33 -08001517// Helper class for ArtMethod checks when adding an image. Keeps all required functionality
1518// together and caches some intermediate results.
1519class ImageSanityChecks FINAL {
1520 public:
1521 static void CheckObjects(gc::Heap* heap, ClassLinker* class_linker)
1522 REQUIRES_SHARED(Locks::mutator_lock_) {
1523 ImageSanityChecks isc(heap, class_linker);
1524 heap->VisitObjects(ImageSanityChecks::SanityCheckObjectsCallback, &isc);
1525 }
1526
1527 static void CheckPointerArray(gc::Heap* heap,
1528 ClassLinker* class_linker,
1529 ArtMethod** arr,
1530 size_t size)
1531 REQUIRES_SHARED(Locks::mutator_lock_) {
1532 ImageSanityChecks isc(heap, class_linker);
1533 isc.SanityCheckArtMethodPointerArray(arr, size);
1534 }
1535
1536 static void SanityCheckObjectsCallback(mirror::Object* obj, void* arg)
1537 REQUIRES_SHARED(Locks::mutator_lock_) {
1538 DCHECK(obj != nullptr);
1539 CHECK(obj->GetClass() != nullptr) << "Null class in object " << obj;
1540 CHECK(obj->GetClass()->GetClass() != nullptr) << "Null class class " << obj;
1541 if (obj->IsClass()) {
1542 ImageSanityChecks* isc = reinterpret_cast<ImageSanityChecks*>(arg);
1543
1544 auto klass = obj->AsClass();
1545 for (ArtField& field : klass->GetIFields()) {
1546 CHECK_EQ(field.GetDeclaringClass(), klass);
1547 }
1548 for (ArtField& field : klass->GetSFields()) {
1549 CHECK_EQ(field.GetDeclaringClass(), klass);
1550 }
1551 const auto pointer_size = isc->pointer_size_;
1552 for (auto& m : klass->GetMethods(pointer_size)) {
1553 isc->SanityCheckArtMethod(&m, klass);
1554 }
1555 auto* vtable = klass->GetVTable();
1556 if (vtable != nullptr) {
1557 isc->SanityCheckArtMethodPointerArray(vtable, nullptr);
1558 }
1559 if (klass->ShouldHaveImt()) {
1560 ImTable* imt = klass->GetImt(pointer_size);
1561 for (size_t i = 0; i < ImTable::kSize; ++i) {
1562 isc->SanityCheckArtMethod(imt->Get(i, pointer_size), nullptr);
1563 }
1564 }
1565 if (klass->ShouldHaveEmbeddedVTable()) {
1566 for (int32_t i = 0; i < klass->GetEmbeddedVTableLength(); ++i) {
1567 isc->SanityCheckArtMethod(klass->GetEmbeddedVTableEntry(i, pointer_size), nullptr);
1568 }
1569 }
1570 mirror::IfTable* iftable = klass->GetIfTable();
1571 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
1572 if (iftable->GetMethodArrayCount(i) > 0) {
1573 isc->SanityCheckArtMethodPointerArray(iftable->GetMethodArray(i), nullptr);
1574 }
1575 }
1576 }
1577 }
1578
1579 private:
1580 ImageSanityChecks(gc::Heap* heap, ClassLinker* class_linker)
1581 : spaces_(heap->GetBootImageSpaces()),
1582 pointer_size_(class_linker->GetImagePointerSize()) {
1583 space_begin_.reserve(spaces_.size());
1584 method_sections_.reserve(spaces_.size());
1585 runtime_method_sections_.reserve(spaces_.size());
1586 for (gc::space::ImageSpace* space : spaces_) {
1587 space_begin_.push_back(space->Begin());
1588 auto& header = space->GetImageHeader();
1589 method_sections_.push_back(&header.GetMethodsSection());
1590 runtime_method_sections_.push_back(&header.GetRuntimeMethodsSection());
1591 }
1592 }
1593
1594 void SanityCheckArtMethod(ArtMethod* m, ObjPtr<mirror::Class> expected_class)
1595 REQUIRES_SHARED(Locks::mutator_lock_) {
1596 if (m->IsRuntimeMethod()) {
1597 ObjPtr<mirror::Class> declaring_class = m->GetDeclaringClassUnchecked();
1598 CHECK(declaring_class == nullptr) << declaring_class << " " << m->PrettyMethod();
1599 } else if (m->IsCopied()) {
1600 CHECK(m->GetDeclaringClass() != nullptr) << m->PrettyMethod();
1601 } else if (expected_class != nullptr) {
1602 CHECK_EQ(m->GetDeclaringClassUnchecked(), expected_class) << m->PrettyMethod();
1603 }
1604 if (!spaces_.empty()) {
1605 bool contains = false;
1606 for (size_t i = 0; !contains && i != space_begin_.size(); ++i) {
1607 const size_t offset = reinterpret_cast<uint8_t*>(m) - space_begin_[i];
1608 contains = method_sections_[i]->Contains(offset) ||
1609 runtime_method_sections_[i]->Contains(offset);
1610 }
1611 CHECK(contains) << m << " not found";
1612 }
1613 }
1614
1615 void SanityCheckArtMethodPointerArray(ObjPtr<mirror::PointerArray> arr,
1616 ObjPtr<mirror::Class> expected_class)
1617 REQUIRES_SHARED(Locks::mutator_lock_) {
1618 CHECK(arr != nullptr);
1619 for (int32_t j = 0; j < arr->GetLength(); ++j) {
1620 auto* method = arr->GetElementPtrSize<ArtMethod*>(j, pointer_size_);
1621 // expected_class == null means we are a dex cache.
1622 if (expected_class != nullptr) {
1623 CHECK(method != nullptr);
1624 }
1625 if (method != nullptr) {
1626 SanityCheckArtMethod(method, expected_class);
1627 }
1628 }
1629 }
1630
1631 void SanityCheckArtMethodPointerArray(ArtMethod** arr, size_t size)
1632 REQUIRES_SHARED(Locks::mutator_lock_) {
1633 CHECK_EQ(arr != nullptr, size != 0u);
1634 if (arr != nullptr) {
1635 bool contains = false;
1636 for (auto space : spaces_) {
1637 auto offset = reinterpret_cast<uint8_t*>(arr) - space->Begin();
1638 if (space->GetImageHeader().GetImageSection(
1639 ImageHeader::kSectionDexCacheArrays).Contains(offset)) {
1640 contains = true;
1641 break;
1642 }
1643 }
1644 CHECK(contains);
1645 }
1646 for (size_t j = 0; j < size; ++j) {
1647 ArtMethod* method = mirror::DexCache::GetElementPtrSize(arr, j, pointer_size_);
1648 // expected_class == null means we are a dex cache.
1649 if (method != nullptr) {
1650 SanityCheckArtMethod(method, nullptr);
1651 }
1652 }
1653 }
1654
1655 const std::vector<gc::space::ImageSpace*>& spaces_;
1656 const PointerSize pointer_size_;
1657
1658 // Cached sections from the spaces.
1659 std::vector<const uint8_t*> space_begin_;
1660 std::vector<const ImageSection*> method_sections_;
1661 std::vector<const ImageSection*> runtime_method_sections_;
1662};
1663
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001664bool ClassLinker::AddImageSpace(
1665 gc::space::ImageSpace* space,
1666 Handle<mirror::ClassLoader> class_loader,
1667 jobjectArray dex_elements,
1668 const char* dex_location,
1669 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
1670 std::string* error_msg) {
1671 DCHECK(out_dex_files != nullptr);
1672 DCHECK(error_msg != nullptr);
1673 const uint64_t start_time = NanoTime();
Andreas Gampefa4333d2017-02-14 11:10:34 -08001674 const bool app_image = class_loader != nullptr;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001675 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001676 ObjPtr<mirror::Object> dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001677 DCHECK(dex_caches_object != nullptr);
1678 Runtime* const runtime = Runtime::Current();
1679 gc::Heap* const heap = runtime->GetHeap();
1680 Thread* const self = Thread::Current();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001681 // Check that the image is what we are expecting.
1682 if (image_pointer_size_ != space->GetImageHeader().GetPointerSize()) {
1683 *error_msg = StringPrintf("Application image pointer size does not match runtime: %zu vs %zu",
1684 static_cast<size_t>(space->GetImageHeader().GetPointerSize()),
1685 image_pointer_size_);
1686 return false;
1687 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001688 size_t expected_image_roots = ImageHeader::NumberOfImageRoots(app_image);
1689 if (static_cast<size_t>(header.GetImageRoots()->GetLength()) != expected_image_roots) {
1690 *error_msg = StringPrintf("Expected %zu image roots but got %d",
1691 expected_image_roots,
1692 header.GetImageRoots()->GetLength());
1693 return false;
1694 }
1695 StackHandleScope<3> hs(self);
1696 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches(
1697 hs.NewHandle(dex_caches_object->AsObjectArray<mirror::DexCache>()));
1698 Handle<mirror::ObjectArray<mirror::Class>> class_roots(hs.NewHandle(
1699 header.GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>()));
1700 static_assert(ImageHeader::kClassLoader + 1u == ImageHeader::kImageRootsMax,
1701 "Class loader should be the last image root.");
1702 MutableHandle<mirror::ClassLoader> image_class_loader(hs.NewHandle(
1703 app_image ? header.GetImageRoot(ImageHeader::kClassLoader)->AsClassLoader() : nullptr));
Andreas Gampefa4333d2017-02-14 11:10:34 -08001704 DCHECK(class_roots != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001705 if (class_roots->GetLength() != static_cast<int32_t>(kClassRootsMax)) {
1706 *error_msg = StringPrintf("Expected %d class roots but got %d",
1707 class_roots->GetLength(),
1708 static_cast<int32_t>(kClassRootsMax));
1709 return false;
1710 }
1711 // Check against existing class roots to make sure they match the ones in the boot image.
1712 for (size_t i = 0; i < kClassRootsMax; i++) {
1713 if (class_roots->Get(i) != GetClassRoot(static_cast<ClassRoot>(i))) {
1714 *error_msg = "App image class roots must have pointer equality with runtime ones.";
1715 return false;
1716 }
1717 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001718 const OatFile* oat_file = space->GetOatFile();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001719 if (oat_file->GetOatHeader().GetDexFileCount() !=
1720 static_cast<uint32_t>(dex_caches->GetLength())) {
1721 *error_msg = "Dex cache count and dex file count mismatch while trying to initialize from "
1722 "image";
1723 return false;
1724 }
1725
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001726 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Vladimir Markocd556b02017-02-03 11:47:34 +00001727 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
1728 std::string dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001729 // TODO: Only store qualified paths.
1730 // If non qualified, qualify it.
1731 if (dex_file_location.find('/') == std::string::npos) {
1732 std::string dex_location_path = dex_location;
1733 const size_t pos = dex_location_path.find_last_of('/');
1734 CHECK_NE(pos, std::string::npos);
1735 dex_location_path = dex_location_path.substr(0, pos + 1); // Keep trailing '/'
1736 dex_file_location = dex_location_path + dex_file_location;
1737 }
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001738 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file,
1739 dex_file_location.c_str(),
1740 error_msg);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001741 if (dex_file == nullptr) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001742 return false;
1743 }
1744
1745 if (app_image) {
1746 // The current dex file field is bogus, overwrite it so that we can get the dex file in the
1747 // loop below.
Vladimir Markocd556b02017-02-03 11:47:34 +00001748 dex_cache->SetDexFile(dex_file.get());
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001749 mirror::TypeDexCacheType* const types = dex_cache->GetResolvedTypes();
Vladimir Markocd556b02017-02-03 11:47:34 +00001750 for (int32_t j = 0, num_types = dex_cache->NumResolvedTypes(); j < num_types; j++) {
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001751 ObjPtr<mirror::Class> klass = types[j].load(std::memory_order_relaxed).object.Read();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001752 if (klass != nullptr) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00001753 DCHECK(!klass->IsErroneous()) << klass->GetStatus();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001754 }
1755 }
1756 } else {
1757 if (kSanityCheckObjects) {
Andreas Gampe0793bec2016-12-01 11:37:33 -08001758 ImageSanityChecks::CheckPointerArray(heap,
1759 this,
Vladimir Markocd556b02017-02-03 11:47:34 +00001760 dex_cache->GetResolvedMethods(),
1761 dex_cache->NumResolvedMethods());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001762 }
1763 // Register dex files, keep track of existing ones that are conflicts.
Vladimir Markocd556b02017-02-03 11:47:34 +00001764 AppendToBootClassPath(*dex_file.get(), dex_cache);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001765 }
1766 out_dex_files->push_back(std::move(dex_file));
1767 }
1768
1769 if (app_image) {
1770 ScopedObjectAccessUnchecked soa(Thread::Current());
1771 // Check that the class loader resolves the same way as the ones in the image.
1772 // Image class loader [A][B][C][image dex files]
1773 // Class loader = [???][dex_elements][image dex files]
1774 // Need to ensure that [???][dex_elements] == [A][B][C].
1775 // For each class loader, PathClassLoader, the laoder checks the parent first. Also the logic
1776 // for PathClassLoader does this by looping through the array of dex files. To ensure they
1777 // resolve the same way, simply flatten the hierarchy in the way the resolution order would be,
1778 // and check that the dex file names are the same.
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001779 if (IsBootClassLoader(soa, image_class_loader.Get())) {
1780 *error_msg = "Unexpected BootClassLoader in app image";
1781 return false;
1782 }
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001783 std::list<ObjPtr<mirror::String>> image_dex_file_names;
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001784 std::string temp_error_msg;
1785 if (!FlattenPathClassLoader(image_class_loader.Get(), &image_dex_file_names, &temp_error_msg)) {
1786 *error_msg = StringPrintf("Failed to flatten image class loader hierarchy '%s'",
1787 temp_error_msg.c_str());
1788 return false;
1789 }
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001790 std::list<ObjPtr<mirror::String>> loader_dex_file_names;
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001791 if (!FlattenPathClassLoader(class_loader.Get(), &loader_dex_file_names, &temp_error_msg)) {
1792 *error_msg = StringPrintf("Failed to flatten class loader hierarchy '%s'",
1793 temp_error_msg.c_str());
1794 return false;
1795 }
1796 // Add the temporary dex path list elements at the end.
1797 auto elements = soa.Decode<mirror::ObjectArray<mirror::Object>>(dex_elements);
1798 for (size_t i = 0, num_elems = elements->GetLength(); i < num_elems; ++i) {
1799 ObjPtr<mirror::Object> element = elements->GetWithoutChecks(i);
1800 if (element != nullptr) {
1801 // If we are somewhere in the middle of the array, there may be nulls at the end.
Mathieu Chartier8a1691f2017-03-02 12:02:13 -08001802 ObjPtr<mirror::String> name;
1803 if (GetDexPathListElementName(element, &name) && name != nullptr) {
1804 loader_dex_file_names.push_back(name);
1805 }
Nicolas Geoffray1df3b552016-04-26 18:30:31 +01001806 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001807 }
1808 // Ignore the number of image dex files since we are adding those to the class loader anyways.
1809 CHECK_GE(static_cast<size_t>(image_dex_file_names.size()),
1810 static_cast<size_t>(dex_caches->GetLength()));
1811 size_t image_count = image_dex_file_names.size() - dex_caches->GetLength();
1812 // Check that the dex file names match.
1813 bool equal = image_count == loader_dex_file_names.size();
1814 if (equal) {
1815 auto it1 = image_dex_file_names.begin();
1816 auto it2 = loader_dex_file_names.begin();
1817 for (size_t i = 0; equal && i < image_count; ++i, ++it1, ++it2) {
1818 equal = equal && (*it1)->Equals(*it2);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001819 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001820 }
1821 if (!equal) {
1822 VLOG(image) << "Image dex files " << image_dex_file_names.size();
1823 for (ObjPtr<mirror::String> name : image_dex_file_names) {
1824 VLOG(image) << name->ToModifiedUtf8();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001825 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001826 VLOG(image) << "Loader dex files " << loader_dex_file_names.size();
1827 for (ObjPtr<mirror::String> name : loader_dex_file_names) {
1828 VLOG(image) << name->ToModifiedUtf8();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001829 }
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001830 *error_msg = "Rejecting application image due to class loader mismatch";
1831 // Ignore class loader mismatch for now since these would just use possibly incorrect
1832 // oat code anyways. The structural class check should be done in the parent.
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001833 }
1834 }
1835
1836 if (kSanityCheckObjects) {
1837 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
1838 auto* dex_cache = dex_caches->Get(i);
1839 for (size_t j = 0; j < dex_cache->NumResolvedFields(); ++j) {
1840 auto* field = dex_cache->GetResolvedField(j, image_pointer_size_);
1841 if (field != nullptr) {
1842 CHECK(field->GetDeclaringClass()->GetClass() != nullptr);
1843 }
1844 }
1845 }
1846 if (!app_image) {
Andreas Gampe0793bec2016-12-01 11:37:33 -08001847 ImageSanityChecks::CheckObjects(heap, this);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001848 }
1849 }
1850
1851 // Set entry point to interpreter if in InterpretOnly mode.
1852 if (!runtime->IsAotCompiler() && runtime->GetInstrumentation()->InterpretOnly()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001853 SetInterpreterEntrypointArtMethodVisitor visitor(image_pointer_size_);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07001854 header.VisitPackedArtMethods(&visitor, space->Begin(), image_pointer_size_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001855 }
1856
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001857 ClassTable* class_table = nullptr;
1858 {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001859 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001860 class_table = InsertClassTableForClassLoader(class_loader.Get());
Mathieu Chartier69731002016-03-02 16:08:31 -08001861 }
1862 // If we have a class table section, read it and use it for verification in
1863 // UpdateAppImageClassLoadersAndDexCaches.
1864 ClassTable::ClassSet temp_set;
1865 const ImageSection& class_table_section = header.GetImageSection(ImageHeader::kSectionClassTable);
1866 const bool added_class_table = class_table_section.Size() > 0u;
1867 if (added_class_table) {
1868 const uint64_t start_time2 = NanoTime();
1869 size_t read_count = 0;
1870 temp_set = ClassTable::ClassSet(space->Begin() + class_table_section.Offset(),
1871 /*make copy*/false,
1872 &read_count);
Mathieu Chartier69731002016-03-02 16:08:31 -08001873 VLOG(image) << "Adding class table classes took " << PrettyDuration(NanoTime() - start_time2);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001874 }
1875 if (app_image) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001876 bool forward_dex_cache_arrays = false;
1877 if (!UpdateAppImageClassLoadersAndDexCaches(space,
1878 class_loader,
1879 dex_caches,
Vladimir Marko1a1de672016-10-13 12:53:15 +01001880 &temp_set,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001881 /*out*/&forward_dex_cache_arrays,
1882 /*out*/error_msg)) {
1883 return false;
1884 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001885 // Update class loader and resolved strings. If added_class_table is false, the resolved
1886 // strings were forwarded UpdateAppImageClassLoadersAndDexCaches.
Nicolas Geoffrayf9bf2502016-12-14 14:59:04 +00001887 UpdateClassLoaderVisitor visitor(space, class_loader.Get());
1888 for (const ClassTable::TableSlot& root : temp_set) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01001889 visitor(root.Read());
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001890 }
Mathieu Chartier8c4f0412016-02-03 16:40:20 -08001891 // forward_dex_cache_arrays is true iff we copied all of the dex cache arrays into the .bss.
1892 // In this case, madvise away the dex cache arrays section of the image to reduce RAM usage and
1893 // mark as PROT_NONE to catch any invalid accesses.
1894 if (forward_dex_cache_arrays) {
1895 const ImageSection& dex_cache_section = header.GetImageSection(
1896 ImageHeader::kSectionDexCacheArrays);
1897 uint8_t* section_begin = AlignUp(space->Begin() + dex_cache_section.Offset(), kPageSize);
1898 uint8_t* section_end = AlignDown(space->Begin() + dex_cache_section.End(), kPageSize);
1899 if (section_begin < section_end) {
1900 madvise(section_begin, section_end - section_begin, MADV_DONTNEED);
1901 mprotect(section_begin, section_end - section_begin, PROT_NONE);
1902 VLOG(image) << "Released and protected dex cache array image section from "
1903 << reinterpret_cast<const void*>(section_begin) << "-"
1904 << reinterpret_cast<const void*>(section_end);
1905 }
1906 }
Vladimir Marko1998cd02017-01-13 13:02:58 +00001907 }
1908 if (!oat_file->GetBssGcRoots().empty()) {
1909 // Insert oat file to class table for visiting .bss GC roots.
1910 class_table->InsertOatFile(oat_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001911 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001912 if (added_class_table) {
1913 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
1914 class_table->AddClassSet(std::move(temp_set));
1915 }
1916 if (kIsDebugBuild && app_image) {
1917 // This verification needs to happen after the classes have been added to the class loader.
1918 // Since it ensures classes are in the class table.
1919 VerifyClassInTableArtMethodVisitor visitor2(class_table);
Andreas Gampe542451c2016-07-26 09:02:02 -07001920 header.VisitPackedArtMethods(&visitor2, space->Begin(), kRuntimePointerSize);
Vladimir Marko8d6768d2017-03-14 10:13:21 +00001921 // Verify that all direct interfaces of classes in the class table are also resolved.
1922 VerifyDirectInterfacesInTableClassVisitor visitor(class_loader.Get());
1923 class_table->Visit(visitor);
1924 visitor.Check();
1925 // Check that all non-primitive classes in dex caches are also in the class table.
1926 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
1927 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
1928 mirror::TypeDexCacheType* const types = dex_cache->GetResolvedTypes();
1929 for (int32_t j = 0, num_types = dex_cache->NumResolvedTypes(); j < num_types; j++) {
1930 ObjPtr<mirror::Class> klass = types[j].load(std::memory_order_relaxed).object.Read();
1931 if (klass != nullptr && !klass->IsPrimitive()) {
1932 CHECK(class_table->Contains(klass)) << klass->PrettyDescriptor()
1933 << " " << dex_cache->GetDexFile()->GetLocation();
1934 }
1935 }
1936 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001937 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001938 VLOG(class_linker) << "Adding image space took " << PrettyDuration(NanoTime() - start_time);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001939 return true;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001940}
1941
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001942bool ClassLinker::ClassInClassTable(ObjPtr<mirror::Class> klass) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001943 ClassTable* const class_table = ClassTableForClassLoader(klass->GetClassLoader());
1944 return class_table != nullptr && class_table->Contains(klass);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001945}
1946
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001947void ClassLinker::VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) {
Mathieu Chartier7778b882015-10-05 16:41:10 -07001948 // Acquire tracing_enabled before locking class linker lock to prevent lock order violation. Since
1949 // enabling tracing requires the mutator lock, there are no race conditions here.
1950 const bool tracing_enabled = Trace::IsTracingEnabled();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001951 Thread* const self = Thread::Current();
1952 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Vladimir Marko9b03cb42017-02-16 16:37:03 +00001953 if (kUseReadBarrier) {
1954 // We do not track new roots for CC.
1955 DCHECK_EQ(0, flags & (kVisitRootFlagNewRoots |
1956 kVisitRootFlagClearRootLog |
1957 kVisitRootFlagStartLoggingNewRoots |
1958 kVisitRootFlagStopLoggingNewRoots));
1959 }
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001960 if ((flags & kVisitRootFlagAllRoots) != 0) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001961 // Argument for how root visiting deals with ArtField and ArtMethod roots.
1962 // There is 3 GC cases to handle:
1963 // Non moving concurrent:
1964 // This case is easy to handle since the reference members of ArtMethod and ArtFields are held
Mathieu Chartierda7c6502015-07-23 16:01:26 -07001965 // live by the class and class roots.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001966 //
1967 // Moving non-concurrent:
1968 // This case needs to call visit VisitNativeRoots in case the classes or dex cache arrays move.
1969 // To prevent missing roots, this case needs to ensure that there is no
1970 // suspend points between the point which we allocate ArtMethod arrays and place them in a
1971 // class which is in the class table.
1972 //
1973 // Moving concurrent:
1974 // Need to make sure to not copy ArtMethods without doing read barriers since the roots are
1975 // marked concurrently and we don't hold the classlinker_classes_lock_ when we do the copy.
Mathieu Chartier58c3f6a2016-12-01 14:21:11 -08001976 //
1977 // Use an unbuffered visitor since the class table uses a temporary GcRoot for holding decoded
1978 // ClassTable::TableSlot. The buffered root visiting would access a stale stack location for
1979 // these objects.
1980 UnbufferedRootVisitor root_visitor(visitor, RootInfo(kRootStickyClass));
1981 boot_class_table_.VisitRoots(root_visitor);
Mathieu Chartier7778b882015-10-05 16:41:10 -07001982 // If tracing is enabled, then mark all the class loaders to prevent unloading.
neo.chaea2d1b282016-11-08 08:40:46 +09001983 if ((flags & kVisitRootFlagClassLoader) != 0 || tracing_enabled) {
Mathieu Chartier7778b882015-10-05 16:41:10 -07001984 for (const ClassLoaderData& data : class_loaders_) {
1985 GcRoot<mirror::Object> root(GcRoot<mirror::Object>(self->DecodeJObject(data.weak_root)));
1986 root.VisitRoot(visitor, RootInfo(kRootVMInternal));
1987 }
1988 }
Vladimir Marko9b03cb42017-02-16 16:37:03 +00001989 } else if (!kUseReadBarrier && (flags & kVisitRootFlagNewRoots) != 0) {
Mathieu Chartierc2e20622014-11-03 11:41:47 -08001990 for (auto& root : new_class_roots_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001991 ObjPtr<mirror::Class> old_ref = root.Read<kWithoutReadBarrier>();
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001992 root.VisitRoot(visitor, RootInfo(kRootStickyClass));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001993 ObjPtr<mirror::Class> new_ref = root.Read<kWithoutReadBarrier>();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001994 // Concurrent moving GC marked new roots through the to-space invariant.
1995 CHECK_EQ(new_ref, old_ref);
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001996 }
Vladimir Marko1998cd02017-01-13 13:02:58 +00001997 for (const OatFile* oat_file : new_bss_roots_boot_oat_files_) {
1998 for (GcRoot<mirror::Object>& root : oat_file->GetBssGcRoots()) {
1999 ObjPtr<mirror::Object> old_ref = root.Read<kWithoutReadBarrier>();
2000 if (old_ref != nullptr) {
2001 DCHECK(old_ref->IsClass());
2002 root.VisitRoot(visitor, RootInfo(kRootStickyClass));
2003 ObjPtr<mirror::Object> new_ref = root.Read<kWithoutReadBarrier>();
2004 // Concurrent moving GC marked new roots through the to-space invariant.
2005 CHECK_EQ(new_ref, old_ref);
2006 }
2007 }
2008 }
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002009 }
Vladimir Marko9b03cb42017-02-16 16:37:03 +00002010 if (!kUseReadBarrier && (flags & kVisitRootFlagClearRootLog) != 0) {
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002011 new_class_roots_.clear();
Vladimir Marko1998cd02017-01-13 13:02:58 +00002012 new_bss_roots_boot_oat_files_.clear();
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002013 }
Vladimir Marko9b03cb42017-02-16 16:37:03 +00002014 if (!kUseReadBarrier && (flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
Vladimir Marko1998cd02017-01-13 13:02:58 +00002015 log_new_roots_ = true;
Vladimir Marko9b03cb42017-02-16 16:37:03 +00002016 } else if (!kUseReadBarrier && (flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
Vladimir Marko1998cd02017-01-13 13:02:58 +00002017 log_new_roots_ = false;
Mathieu Chartier52e4b432014-06-10 11:22:31 -07002018 }
2019 // We deliberately ignore the class roots in the image since we
2020 // handle image roots by using the MS/CMS rescanning of dirty cards.
2021}
2022
Brian Carlstroma663ea52011-08-19 23:33:41 -07002023// Keep in sync with InitCallback. Anything we visit, we need to
2024// reinit references to when reinitializing a ClassLinker from a
2025// mapped image.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002026void ClassLinker::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) {
Mathieu Chartier31000802015-06-14 14:14:37 -07002027 class_roots_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002028 VisitClassRoots(visitor, flags);
Mathieu Chartier31000802015-06-14 14:14:37 -07002029 array_iftable_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartier6cfc2c02015-10-12 15:06:16 -07002030 // Instead of visiting the find_array_class_cache_ drop it so that it doesn't prevent class
2031 // unloading if we are marking roots.
2032 DropFindArrayClassCache();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07002033}
2034
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002035class VisitClassLoaderClassesVisitor : public ClassLoaderVisitor {
2036 public:
2037 explicit VisitClassLoaderClassesVisitor(ClassVisitor* visitor)
2038 : visitor_(visitor),
2039 done_(false) {}
2040
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002041 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002042 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002043 ClassTable* const class_table = class_loader->GetClassTable();
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002044 if (!done_ && class_table != nullptr) {
2045 DefiningClassLoaderFilterVisitor visitor(class_loader, visitor_);
2046 if (!class_table->Visit(visitor)) {
2047 // If the visitor ClassTable returns false it means that we don't need to continue.
2048 done_ = true;
2049 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002050 }
2051 }
2052
2053 private:
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002054 // Class visitor that limits the class visits from a ClassTable to the classes with
2055 // the provided defining class loader. This filter is used to avoid multiple visits
2056 // of the same class which can be recorded for multiple initiating class loaders.
2057 class DefiningClassLoaderFilterVisitor : public ClassVisitor {
2058 public:
2059 DefiningClassLoaderFilterVisitor(ObjPtr<mirror::ClassLoader> defining_class_loader,
2060 ClassVisitor* visitor)
2061 : defining_class_loader_(defining_class_loader), visitor_(visitor) { }
2062
2063 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
2064 if (klass->GetClassLoader() != defining_class_loader_) {
2065 return true;
2066 }
2067 return (*visitor_)(klass);
2068 }
2069
2070 ObjPtr<mirror::ClassLoader> const defining_class_loader_;
2071 ClassVisitor* const visitor_;
2072 };
2073
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002074 ClassVisitor* const visitor_;
2075 // If done is true then we don't need to do any more visiting.
2076 bool done_;
2077};
2078
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002079void ClassLinker::VisitClassesInternal(ClassVisitor* visitor) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002080 if (boot_class_table_.Visit(*visitor)) {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002081 VisitClassLoaderClassesVisitor loader_visitor(visitor);
2082 VisitClassLoaders(&loader_visitor);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002083 }
2084}
2085
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002086void ClassLinker::VisitClasses(ClassVisitor* visitor) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002087 Thread* const self = Thread::Current();
2088 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
2089 // Not safe to have thread suspension when we are holding a lock.
2090 if (self != nullptr) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002091 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002092 VisitClassesInternal(visitor);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002093 } else {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002094 VisitClassesInternal(visitor);
Elliott Hughesa2155262011-11-16 16:26:58 -08002095 }
2096}
2097
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002098class GetClassesInToVector : public ClassVisitor {
2099 public:
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002100 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002101 classes_.push_back(klass);
2102 return true;
2103 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002104 std::vector<ObjPtr<mirror::Class>> classes_;
Ian Rogersdbf3be02014-08-29 15:40:08 -07002105};
2106
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002107class GetClassInToObjectArray : public ClassVisitor {
2108 public:
2109 explicit GetClassInToObjectArray(mirror::ObjectArray<mirror::Class>* arr)
2110 : arr_(arr), index_(0) {}
2111
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002112 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002113 ++index_;
2114 if (index_ <= arr_->GetLength()) {
2115 arr_->Set(index_ - 1, klass);
2116 return true;
2117 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002118 return false;
2119 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002120
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002121 bool Succeeded() const REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002122 return index_ <= arr_->GetLength();
2123 }
2124
2125 private:
2126 mirror::ObjectArray<mirror::Class>* const arr_;
2127 int32_t index_;
2128};
2129
2130void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002131 // TODO: it may be possible to avoid secondary storage if we iterate over dex caches. The problem
2132 // is avoiding duplicates.
2133 if (!kMovingClasses) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002134 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002135 GetClassesInToVector accumulator;
2136 VisitClasses(&accumulator);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002137 for (ObjPtr<mirror::Class> klass : accumulator.classes_) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002138 if (!visitor->operator()(klass)) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002139 return;
2140 }
2141 }
2142 } else {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002143 Thread* const self = Thread::Current();
Ian Rogersdbf3be02014-08-29 15:40:08 -07002144 StackHandleScope<1> hs(self);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002145 auto classes = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Ian Rogersdbf3be02014-08-29 15:40:08 -07002146 // We size the array assuming classes won't be added to the class table during the visit.
2147 // If this assumption fails we iterate again.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002148 while (true) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002149 size_t class_table_size;
2150 {
Ian Rogers7b078e82014-09-10 14:44:24 -07002151 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002152 // Add 100 in case new classes get loaded when we are filling in the object array.
2153 class_table_size = NumZygoteClasses() + NumNonZygoteClasses() + 100;
Ian Rogersdbf3be02014-08-29 15:40:08 -07002154 }
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07002155 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002156 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
Ian Rogersdbf3be02014-08-29 15:40:08 -07002157 classes.Assign(
2158 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size));
Andreas Gampefa4333d2017-02-14 11:10:34 -08002159 CHECK(classes != nullptr); // OOME.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002160 GetClassInToObjectArray accumulator(classes.Get());
2161 VisitClasses(&accumulator);
2162 if (accumulator.Succeeded()) {
2163 break;
2164 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002165 }
2166 for (int32_t i = 0; i < classes->GetLength(); ++i) {
2167 // If the class table shrank during creation of the clases array we expect null elements. If
2168 // the class table grew then the loop repeats. If classes are created after the loop has
2169 // finished then we don't visit.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002170 ObjPtr<mirror::Class> klass = classes->Get(i);
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002171 if (klass != nullptr && !visitor->operator()(klass)) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002172 return;
2173 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002174 }
2175 }
2176}
2177
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002178ClassLinker::~ClassLinker() {
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002179 mirror::Class::ResetClass();
2180 mirror::Constructor::ResetClass();
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07002181 mirror::Field::ResetClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002182 mirror::Method::ResetClass();
2183 mirror::Reference::ResetClass();
2184 mirror::StackTraceElement::ResetClass();
2185 mirror::String::ResetClass();
2186 mirror::Throwable::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002187 mirror::BooleanArray::ResetArrayClass();
2188 mirror::ByteArray::ResetArrayClass();
2189 mirror::CharArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002190 mirror::Constructor::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002191 mirror::DoubleArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002192 mirror::Field::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002193 mirror::FloatArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002194 mirror::Method::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002195 mirror::IntArray::ResetArrayClass();
2196 mirror::LongArray::ResetArrayClass();
2197 mirror::ShortArray::ResetArrayClass();
Narayan Kamathafa48272016-08-03 12:46:58 +01002198 mirror::MethodType::ResetClass();
2199 mirror::MethodHandleImpl::ResetClass();
Orion Hodsonc069a302017-01-18 09:23:12 +00002200 mirror::MethodHandlesLookup::ResetClass();
2201 mirror::CallSite::ResetClass();
Narayan Kamath000e1882016-10-24 17:14:25 +01002202 mirror::EmulatedStackFrame::ResetClass();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002203 Thread* const self = Thread::Current();
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002204 for (const ClassLoaderData& data : class_loaders_) {
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002205 DeleteClassLoader(self, data);
Mathieu Chartier6b069532015-08-05 15:08:12 -07002206 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002207 class_loaders_.clear();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002208}
2209
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002210void ClassLinker::DeleteClassLoader(Thread* self, const ClassLoaderData& data) {
2211 Runtime* const runtime = Runtime::Current();
2212 JavaVMExt* const vm = runtime->GetJavaVM();
2213 vm->DeleteWeakGlobalRef(self, data.weak_root);
Calin Juravlee5de54c2016-04-20 14:22:09 +01002214 // Notify the JIT that we need to remove the methods and/or profiling info.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002215 if (runtime->GetJit() != nullptr) {
2216 jit::JitCodeCache* code_cache = runtime->GetJit()->GetCodeCache();
2217 if (code_cache != nullptr) {
2218 code_cache->RemoveMethodsIn(self, *data.allocator);
2219 }
2220 }
2221 delete data.allocator;
2222 delete data.class_table;
2223}
2224
Mathieu Chartiere401d142015-04-22 13:56:20 -07002225mirror::PointerArray* ClassLinker::AllocPointerArray(Thread* self, size_t length) {
Andreas Gampe542451c2016-07-26 09:02:02 -07002226 return down_cast<mirror::PointerArray*>(
2227 image_pointer_size_ == PointerSize::k64
2228 ? static_cast<mirror::Array*>(mirror::LongArray::Alloc(self, length))
2229 : static_cast<mirror::Array*>(mirror::IntArray::Alloc(self, length)));
Mathieu Chartiere401d142015-04-22 13:56:20 -07002230}
2231
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002232mirror::DexCache* ClassLinker::AllocDexCache(ObjPtr<mirror::String>* out_location,
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002233 Thread* self,
2234 const DexFile& dex_file) {
2235 StackHandleScope<1> hs(self);
2236 DCHECK(out_location != nullptr);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07002237 auto dex_cache(hs.NewHandle(ObjPtr<mirror::DexCache>::DownCast(
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002238 GetClassRoot(kJavaLangDexCache)->AllocObject(self))));
Andreas Gampefa4333d2017-02-14 11:10:34 -08002239 if (dex_cache == nullptr) {
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002240 self->AssertPendingOOMException();
2241 return nullptr;
2242 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002243 ObjPtr<mirror::String> location = intern_table_->InternStrong(dex_file.GetLocation().c_str());
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002244 if (location == nullptr) {
2245 self->AssertPendingOOMException();
2246 return nullptr;
2247 }
2248 *out_location = location;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002249 return dex_cache.Get();
Brian Carlstroma0808032011-07-18 00:39:23 -07002250}
2251
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002252mirror::DexCache* ClassLinker::AllocAndInitializeDexCache(Thread* self,
2253 const DexFile& dex_file,
2254 LinearAlloc* linear_alloc) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002255 ObjPtr<mirror::String> location = nullptr;
2256 ObjPtr<mirror::DexCache> dex_cache = AllocDexCache(&location, self, dex_file);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002257 if (dex_cache != nullptr) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08002258 WriterMutexLock mu(self, *Locks::dex_lock_);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002259 DCHECK(location != nullptr);
Andreas Gampecc1b5352016-12-01 16:58:38 -08002260 mirror::DexCache::InitializeDexCache(self,
2261 dex_cache,
2262 location,
2263 &dex_file,
2264 linear_alloc,
2265 image_pointer_size_);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002266 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002267 return dex_cache.Ptr();
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002268}
2269
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002270mirror::Class* ClassLinker::AllocClass(Thread* self,
2271 ObjPtr<mirror::Class> java_lang_Class,
Ian Rogers6fac4472014-02-25 17:01:10 -08002272 uint32_t class_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002273 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07002274 gc::Heap* heap = Runtime::Current()->GetHeap();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002275 mirror::Class::InitializeClassVisitor visitor(class_size);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002276 ObjPtr<mirror::Object> k = kMovingClasses ?
Brian Carlstromf3632832014-05-20 15:36:53 -07002277 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) :
2278 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
Ian Rogers6fac4472014-02-25 17:01:10 -08002279 if (UNLIKELY(k == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002280 self->AssertPendingOOMException();
Ian Rogers6fac4472014-02-25 17:01:10 -08002281 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002282 }
Ian Rogers6fac4472014-02-25 17:01:10 -08002283 return k->AsClass();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07002284}
2285
Ian Rogers6fac4472014-02-25 17:01:10 -08002286mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07002287 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07002288}
2289
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002290mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002291 Thread* self,
2292 size_t length) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002293 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
2294 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07002295}
2296
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002297mirror::Class* ClassLinker::EnsureResolved(Thread* self,
2298 const char* descriptor,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002299 ObjPtr<mirror::Class> klass) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002300 DCHECK(klass != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002301 if (kIsDebugBuild) {
2302 StackHandleScope<1> hs(self);
2303 HandleWrapperObjPtr<mirror::Class> h = hs.NewHandleWrapper(&klass);
2304 Thread::PoisonObjectPointersIfDebug();
2305 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002306
2307 // For temporary classes we must wait for them to be retired.
2308 if (init_done_ && klass->IsTemp()) {
2309 CHECK(!klass->IsResolved());
Vladimir Marko72ab6842017-01-20 19:32:50 +00002310 if (klass->IsErroneousUnresolved()) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002311 ThrowEarlierClassFailure(klass);
2312 return nullptr;
2313 }
2314 StackHandleScope<1> hs(self);
2315 Handle<mirror::Class> h_class(hs.NewHandle(klass));
2316 ObjectLock<mirror::Class> lock(self, h_class);
2317 // Loop and wait for the resolving thread to retire this class.
Vladimir Marko72ab6842017-01-20 19:32:50 +00002318 while (!h_class->IsRetired() && !h_class->IsErroneousUnresolved()) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002319 lock.WaitIgnoringInterrupts();
2320 }
Vladimir Marko72ab6842017-01-20 19:32:50 +00002321 if (h_class->IsErroneousUnresolved()) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002322 ThrowEarlierClassFailure(h_class.Get());
2323 return nullptr;
2324 }
2325 CHECK(h_class->IsRetired());
2326 // Get the updated class from class table.
Andreas Gampe34ee6842014-12-02 15:43:52 -08002327 klass = LookupClass(self, descriptor, h_class.Get()->GetClassLoader());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002328 }
2329
Brian Carlstromaded5f72011-10-07 17:15:04 -07002330 // Wait for the class if it has not already been linked.
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002331 size_t index = 0;
2332 // Maximum number of yield iterations until we start sleeping.
2333 static const size_t kNumYieldIterations = 1000;
2334 // How long each sleep is in us.
2335 static const size_t kSleepDurationUS = 1000; // 1 ms.
Vladimir Marko72ab6842017-01-20 19:32:50 +00002336 while (!klass->IsResolved() && !klass->IsErroneousUnresolved()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002337 StackHandleScope<1> hs(self);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002338 HandleWrapperObjPtr<mirror::Class> h_class(hs.NewHandleWrapper(&klass));
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002339 {
2340 ObjectTryLock<mirror::Class> lock(self, h_class);
2341 // Can not use a monitor wait here since it may block when returning and deadlock if another
2342 // thread has locked klass.
2343 if (lock.Acquired()) {
2344 // Check for circular dependencies between classes, the lock is required for SetStatus.
2345 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) {
2346 ThrowClassCircularityError(h_class.Get());
Vladimir Marko72ab6842017-01-20 19:32:50 +00002347 mirror::Class::SetStatus(h_class, mirror::Class::kStatusErrorUnresolved, self);
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002348 return nullptr;
2349 }
2350 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002351 }
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002352 {
2353 // Handle wrapper deals with klass moving.
2354 ScopedThreadSuspension sts(self, kSuspended);
2355 if (index < kNumYieldIterations) {
2356 sched_yield();
2357 } else {
2358 usleep(kSleepDurationUS);
2359 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002360 }
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002361 ++index;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002362 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002363
Vladimir Marko72ab6842017-01-20 19:32:50 +00002364 if (klass->IsErroneousUnresolved()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002365 ThrowEarlierClassFailure(klass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002366 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002367 }
2368 // Return the loaded class. No exceptions should be pending.
David Sehr709b0702016-10-13 09:12:37 -07002369 CHECK(klass->IsResolved()) << klass->PrettyClass();
Ian Rogers62d6c772013-02-27 08:32:07 -08002370 self->AssertNoPendingException();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002371 return klass.Ptr();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002372}
2373
Ian Rogers68b56852014-08-29 20:19:11 -07002374typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry;
2375
2376// Search a collection of DexFiles for a descriptor
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002377ClassPathEntry FindInClassPath(const char* descriptor,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002378 size_t hash, const std::vector<const DexFile*>& class_path) {
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002379 for (const DexFile* dex_file : class_path) {
David Sehr9aa352e2016-09-15 18:13:52 -07002380 const DexFile::ClassDef* dex_class_def = OatDexFile::FindClassDef(*dex_file, descriptor, hash);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002381 if (dex_class_def != nullptr) {
Ian Rogers68b56852014-08-29 20:19:11 -07002382 return ClassPathEntry(dex_file, dex_class_def);
2383 }
2384 }
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002385 return ClassPathEntry(nullptr, nullptr);
Ian Rogers68b56852014-08-29 20:19:11 -07002386}
2387
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002388bool ClassLinker::FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
2389 Thread* self,
2390 const char* descriptor,
2391 size_t hash,
2392 Handle<mirror::ClassLoader> class_loader,
2393 ObjPtr<mirror::Class>* result) {
Andreas Gampef865ea92015-04-13 22:14:19 -07002394 // Termination case: boot class-loader.
2395 if (IsBootClassLoader(soa, class_loader.Get())) {
2396 // The boot class loader, search the boot class path.
2397 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_);
2398 if (pair.second != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002399 ObjPtr<mirror::Class> klass = LookupClass(self, descriptor, hash, nullptr);
Andreas Gampef865ea92015-04-13 22:14:19 -07002400 if (klass != nullptr) {
2401 *result = EnsureResolved(self, descriptor, klass);
2402 } else {
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002403 *result = DefineClass(self,
2404 descriptor,
2405 hash,
2406 ScopedNullHandle<mirror::ClassLoader>(),
2407 *pair.first,
2408 *pair.second);
Andreas Gampef865ea92015-04-13 22:14:19 -07002409 }
2410 if (*result == nullptr) {
2411 CHECK(self->IsExceptionPending()) << descriptor;
2412 self->ClearException();
2413 }
Ian Rogers32427292014-11-19 14:05:21 -08002414 } else {
Andreas Gampef865ea92015-04-13 22:14:19 -07002415 *result = nullptr;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002416 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002417 return true;
2418 }
2419
2420 // Unsupported class-loader?
Mathieu Chartier0795f232016-09-27 18:43:30 -07002421 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader) !=
2422 class_loader->GetClass()) {
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002423 // PathClassLoader is the most common case, so it's the one we check first. For secondary dex
2424 // files, we also check DexClassLoader here.
2425 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DexClassLoader) !=
2426 class_loader->GetClass()) {
2427 *result = nullptr;
2428 return false;
2429 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002430 }
2431
2432 // Handles as RegisterDexFile may allocate dex caches (and cause thread suspension).
2433 StackHandleScope<4> hs(self);
2434 Handle<mirror::ClassLoader> h_parent(hs.NewHandle(class_loader->GetParent()));
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002435 bool recursive_result = FindClassInBaseDexClassLoader(soa,
2436 self,
2437 descriptor,
2438 hash,
2439 h_parent,
2440 result);
Andreas Gampef865ea92015-04-13 22:14:19 -07002441
2442 if (!recursive_result) {
2443 // Something wrong up the chain.
2444 return false;
2445 }
2446
2447 if (*result != nullptr) {
2448 // Found the class up the chain.
2449 return true;
2450 }
2451
2452 // Handle this step.
2453 // Handle as if this is the child PathClassLoader.
2454 // The class loader is a PathClassLoader which inherits from BaseDexClassLoader.
2455 // We need to get the DexPathList and loop through it.
Andreas Gampe08883de2016-11-08 13:20:52 -08002456 ArtField* const cookie_field =
2457 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
Andreas Gampef865ea92015-04-13 22:14:19 -07002458 ArtField* const dex_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08002459 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002460 ObjPtr<mirror::Object> dex_path_list =
Andreas Gampe08883de2016-11-08 13:20:52 -08002461 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList)->
2462 GetObject(class_loader.Get());
Andreas Gampef865ea92015-04-13 22:14:19 -07002463 if (dex_path_list != nullptr && dex_file_field != nullptr && cookie_field != nullptr) {
2464 // DexPathList has an array dexElements of Elements[] which each contain a dex file.
Mathieu Chartier3398c782016-09-30 10:27:43 -07002465 ObjPtr<mirror::Object> dex_elements_obj =
Andreas Gampe08883de2016-11-08 13:20:52 -08002466 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements)->
Andreas Gampef865ea92015-04-13 22:14:19 -07002467 GetObject(dex_path_list);
2468 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
2469 // at the mCookie which is a DexFile vector.
2470 if (dex_elements_obj != nullptr) {
2471 Handle<mirror::ObjectArray<mirror::Object>> dex_elements =
2472 hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>());
2473 for (int32_t i = 0; i < dex_elements->GetLength(); ++i) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07002474 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
Andreas Gampef865ea92015-04-13 22:14:19 -07002475 if (element == nullptr) {
2476 // Should never happen, fall back to java code to throw a NPE.
2477 break;
2478 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07002479 ObjPtr<mirror::Object> dex_file = dex_file_field->GetObject(element);
Andreas Gampef865ea92015-04-13 22:14:19 -07002480 if (dex_file != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07002481 ObjPtr<mirror::LongArray> long_array = cookie_field->GetObject(dex_file)->AsLongArray();
Andreas Gampef865ea92015-04-13 22:14:19 -07002482 if (long_array == nullptr) {
2483 // This should never happen so log a warning.
2484 LOG(WARNING) << "Null DexFile::mCookie for " << descriptor;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002485 break;
2486 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002487 int32_t long_array_size = long_array->GetLength();
Mathieu Chartiere58991b2015-10-13 07:59:34 -07002488 // First element is the oat file.
2489 for (int32_t j = kDexFileIndexStart; j < long_array_size; ++j) {
Andreas Gampef865ea92015-04-13 22:14:19 -07002490 const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(
2491 long_array->GetWithoutChecks(j)));
David Sehr9aa352e2016-09-15 18:13:52 -07002492 const DexFile::ClassDef* dex_class_def =
2493 OatDexFile::FindClassDef(*cp_dex_file, descriptor, hash);
Andreas Gampef865ea92015-04-13 22:14:19 -07002494 if (dex_class_def != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002495 ObjPtr<mirror::Class> klass = DefineClass(self,
Mathieu Chartiere58991b2015-10-13 07:59:34 -07002496 descriptor,
2497 hash,
2498 class_loader,
2499 *cp_dex_file,
2500 *dex_class_def);
Andreas Gampef865ea92015-04-13 22:14:19 -07002501 if (klass == nullptr) {
2502 CHECK(self->IsExceptionPending()) << descriptor;
2503 self->ClearException();
2504 // TODO: Is it really right to break here, and not check the other dex files?
2505 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002506 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002507 *result = klass;
2508 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002509 }
2510 }
2511 }
2512 }
2513 }
Ian Rogers32427292014-11-19 14:05:21 -08002514 self->AssertNoPendingException();
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002515 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002516
2517 // Result is still null from the parent call, no need to set it again...
2518 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002519}
2520
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002521mirror::Class* ClassLinker::FindClass(Thread* self,
2522 const char* descriptor,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07002523 Handle<mirror::ClassLoader> class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08002524 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Ian Rogers98379392014-02-24 16:53:16 -08002525 DCHECK(self != nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002526 self->AssertNoPendingException();
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07002527 self->PoisonObjectPointers(); // For DefineClass, CreateArrayClass, etc...
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002528 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002529 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
2530 // for primitive classes that aren't backed by dex files.
2531 return FindPrimitiveClass(descriptor[0]);
2532 }
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002533 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002534 // Find the class in the loaded classes table.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002535 ObjPtr<mirror::Class> klass = LookupClass(self, descriptor, hash, class_loader.Get());
Ian Rogers68b56852014-08-29 20:19:11 -07002536 if (klass != nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002537 return EnsureResolved(self, descriptor, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002538 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002539 // Class is not yet loaded.
Andreas Gampefa4333d2017-02-14 11:10:34 -08002540 if (descriptor[0] != '[' && class_loader == nullptr) {
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002541 // Non-array class and the boot class loader, search the boot class path.
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002542 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_);
Ian Rogers68b56852014-08-29 20:19:11 -07002543 if (pair.second != nullptr) {
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002544 return DefineClass(self,
2545 descriptor,
2546 hash,
2547 ScopedNullHandle<mirror::ClassLoader>(),
2548 *pair.first,
Ian Rogers7b078e82014-09-10 14:44:24 -07002549 *pair.second);
Ian Rogers63557452014-06-04 16:57:15 -07002550 } else {
2551 // The boot class loader is searched ahead of the application class loader, failures are
2552 // expected and will be wrapped in a ClassNotFoundException. Use the pre-allocated error to
2553 // trigger the chaining with a proper stack trace.
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002554 ObjPtr<mirror::Throwable> pre_allocated =
2555 Runtime::Current()->GetPreAllocatedNoClassDefFoundError();
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002556 self->SetException(pre_allocated);
Ian Rogers63557452014-06-04 16:57:15 -07002557 return nullptr;
Jesse Wilson47daf872011-11-23 11:42:45 -05002558 }
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002559 }
2560 ObjPtr<mirror::Class> result_ptr;
2561 bool descriptor_equals;
2562 if (descriptor[0] == '[') {
2563 result_ptr = CreateArrayClass(self, descriptor, hash, class_loader);
2564 DCHECK_EQ(result_ptr == nullptr, self->IsExceptionPending());
2565 DCHECK(result_ptr == nullptr || result_ptr->DescriptorEquals(descriptor));
2566 descriptor_equals = true;
Jesse Wilson47daf872011-11-23 11:42:45 -05002567 } else {
Ian Rogers98379392014-02-24 16:53:16 -08002568 ScopedObjectAccessUnchecked soa(self);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002569 bool known_hierarchy =
2570 FindClassInBaseDexClassLoader(soa, self, descriptor, hash, class_loader, &result_ptr);
2571 if (result_ptr != nullptr) {
2572 // The chain was understood and we found the class. We still need to add the class to
2573 // the class table to protect from racy programs that can try and redefine the path list
2574 // which would change the Class<?> returned for subsequent evaluation of const-class.
2575 DCHECK(known_hierarchy);
2576 DCHECK(result_ptr->DescriptorEquals(descriptor));
2577 descriptor_equals = true;
2578 } else {
2579 // Either the chain wasn't understood or the class wasn't found.
2580 //
2581 // If the chain was understood but we did not find the class, let the Java-side
2582 // rediscover all this and throw the exception with the right stack trace. Note that
2583 // the Java-side could still succeed for racy programs if another thread is actively
2584 // modifying the class loader's path list.
Andreas Gampef865ea92015-04-13 22:14:19 -07002585
Calin Juravleccd56952016-12-15 17:57:38 +00002586 if (!self->CanCallIntoJava()) {
2587 // Oops, we can't call into java so we can't run actual class-loader code.
2588 // This is true for e.g. for the compiler (jit or aot).
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002589 ObjPtr<mirror::Throwable> pre_allocated =
2590 Runtime::Current()->GetPreAllocatedNoClassDefFoundError();
2591 self->SetException(pre_allocated);
Vladimir Marko2c8c6b62016-12-01 17:42:00 +00002592 return nullptr;
2593 }
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002594
2595 ScopedLocalRef<jobject> class_loader_object(
2596 soa.Env(), soa.AddLocalReference<jobject>(class_loader.Get()));
2597 std::string class_name_string(DescriptorToDot(descriptor));
2598 ScopedLocalRef<jobject> result(soa.Env(), nullptr);
2599 {
2600 ScopedThreadStateChange tsc(self, kNative);
2601 ScopedLocalRef<jobject> class_name_object(
2602 soa.Env(), soa.Env()->NewStringUTF(class_name_string.c_str()));
2603 if (class_name_object.get() == nullptr) {
2604 DCHECK(self->IsExceptionPending()); // OOME.
2605 return nullptr;
2606 }
2607 CHECK(class_loader_object.get() != nullptr);
2608 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
2609 WellKnownClasses::java_lang_ClassLoader_loadClass,
2610 class_name_object.get()));
2611 }
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002612 if (result.get() == nullptr && !self->IsExceptionPending()) {
Vladimir Markoc5798bf2016-12-09 10:20:54 +00002613 // broken loader - throw NPE to be compatible with Dalvik
2614 ThrowNullPointerException(StringPrintf("ClassLoader.loadClass returned null for %s",
2615 class_name_string.c_str()).c_str());
2616 return nullptr;
2617 }
2618 result_ptr = soa.Decode<mirror::Class>(result.get());
2619 // Check the name of the returned class.
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002620 descriptor_equals = (result_ptr != nullptr) && result_ptr->DescriptorEquals(descriptor);
Vladimir Marko2c8c6b62016-12-01 17:42:00 +00002621 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002622 }
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00002623
2624 if (self->IsExceptionPending()) {
2625 // If the ClassLoader threw or array class allocation failed, pass that exception up.
2626 // However, to comply with the RI behavior, first check if another thread succeeded.
2627 result_ptr = LookupClass(self, descriptor, hash, class_loader.Get());
2628 if (result_ptr != nullptr && !result_ptr->IsErroneous()) {
2629 self->ClearException();
2630 return EnsureResolved(self, descriptor, result_ptr);
2631 }
2632 return nullptr;
2633 }
2634
2635 // Try to insert the class to the class table, checking for mismatch.
2636 ObjPtr<mirror::Class> old;
2637 {
2638 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2639 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader.Get());
2640 old = class_table->Lookup(descriptor, hash);
2641 if (old == nullptr) {
2642 old = result_ptr; // For the comparison below, after releasing the lock.
2643 if (descriptor_equals) {
2644 class_table->InsertWithHash(result_ptr.Ptr(), hash);
2645 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get());
2646 } // else throw below, after releasing the lock.
2647 }
2648 }
2649 if (UNLIKELY(old != result_ptr)) {
2650 // Return `old` (even if `!descriptor_equals`) to mimic the RI behavior for parallel
2651 // capable class loaders. (All class loaders are considered parallel capable on Android.)
2652 mirror::Class* loader_class = class_loader->GetClass();
2653 const char* loader_class_name =
2654 loader_class->GetDexFile().StringByTypeIdx(loader_class->GetDexTypeIndex());
2655 LOG(WARNING) << "Initiating class loader of type " << DescriptorToDot(loader_class_name)
2656 << " is not well-behaved; it returned a different Class for racing loadClass(\""
2657 << DescriptorToDot(descriptor) << "\").";
2658 return EnsureResolved(self, descriptor, old);
2659 }
2660 if (UNLIKELY(!descriptor_equals)) {
2661 std::string result_storage;
2662 const char* result_name = result_ptr->GetDescriptor(&result_storage);
2663 std::string loader_storage;
2664 const char* loader_class_name = class_loader->GetClass()->GetDescriptor(&loader_storage);
2665 ThrowNoClassDefFoundError(
2666 "Initiating class loader of type %s returned class %s instead of %s.",
2667 DescriptorToDot(loader_class_name).c_str(),
2668 DescriptorToDot(result_name).c_str(),
2669 DescriptorToDot(descriptor).c_str());
2670 return nullptr;
2671 }
2672 // success, return mirror::Class*
2673 return result_ptr.Ptr();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002674}
2675
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002676mirror::Class* ClassLinker::DefineClass(Thread* self,
2677 const char* descriptor,
2678 size_t hash,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07002679 Handle<mirror::ClassLoader> class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002680 const DexFile& dex_file,
2681 const DexFile::ClassDef& dex_class_def) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002682 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002683 auto klass = hs.NewHandle<mirror::Class>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002684
Brian Carlstromaded5f72011-10-07 17:15:04 -07002685 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002686 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002687 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002688 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002689 klass.Assign(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002690 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002691 klass.Assign(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002692 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002693 klass.Assign(GetClassRoot(kJavaLangString));
Fred Shih4ee7a662014-07-11 09:59:27 -07002694 } else if (strcmp(descriptor, "Ljava/lang/ref/Reference;") == 0) {
2695 klass.Assign(GetClassRoot(kJavaLangRefReference));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002696 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002697 klass.Assign(GetClassRoot(kJavaLangDexCache));
Alex Lightd6251582016-10-31 11:12:30 -07002698 } else if (strcmp(descriptor, "Ldalvik/system/ClassExt;") == 0) {
2699 klass.Assign(GetClassRoot(kDalvikSystemClassExt));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002700 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002701 }
2702
Andreas Gampefa4333d2017-02-14 11:10:34 -08002703 if (klass == nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002704 // Allocate a class with the status of not ready.
2705 // Interface object should get the right size here. Regular class will
2706 // figure out the right size later and be replaced with one of the right
2707 // size when the class becomes resolved.
2708 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002709 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08002710 if (UNLIKELY(klass == nullptr)) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002711 self->AssertPendingOOMException();
Ian Rogersc114b5f2014-07-21 08:55:01 -07002712 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002713 }
Alex Lightb0f11922017-01-23 14:25:17 -08002714 // Get the real dex file. This will return the input if there aren't any callbacks or they do
2715 // nothing.
2716 DexFile const* new_dex_file = nullptr;
2717 DexFile::ClassDef const* new_class_def = nullptr;
2718 // TODO We should ideally figure out some way to move this after we get a lock on the klass so it
2719 // will only be called once.
2720 Runtime::Current()->GetRuntimeCallbacks()->ClassPreDefine(descriptor,
2721 klass,
2722 class_loader,
2723 dex_file,
2724 dex_class_def,
2725 &new_dex_file,
2726 &new_class_def);
Alex Light440b5d92017-01-24 15:32:25 -08002727 // Check to see if an exception happened during runtime callbacks. Return if so.
2728 if (self->IsExceptionPending()) {
2729 return nullptr;
2730 }
Alex Lightb0f11922017-01-23 14:25:17 -08002731 ObjPtr<mirror::DexCache> dex_cache = RegisterDexFile(*new_dex_file, class_loader.Get());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002732 if (dex_cache == nullptr) {
Vladimir Markocd556b02017-02-03 11:47:34 +00002733 self->AssertPendingException();
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002734 return nullptr;
2735 }
2736 klass->SetDexCache(dex_cache);
Alex Lightb0f11922017-01-23 14:25:17 -08002737 SetupClass(*new_dex_file, *new_class_def, klass, class_loader.Get());
Mathieu Chartierc7853442015-03-27 14:35:38 -07002738
Jeff Hao848f70a2014-01-15 13:49:50 -08002739 // Mark the string class by setting its access flag.
2740 if (UNLIKELY(!init_done_)) {
2741 if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
2742 klass->SetStringClass();
2743 }
2744 }
2745
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07002746 ObjectLock<mirror::Class> lock(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002747 klass->SetClinitThreadId(self->GetTid());
Mathieu Chartier1e4841e2016-12-15 14:21:04 -08002748 // Make sure we have a valid empty iftable even if there are errors.
2749 klass->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002750
Mathieu Chartier590fee92013-09-13 13:46:47 -07002751 // Add the newly loaded class to the loaded classes table.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002752 ObjPtr<mirror::Class> existing = InsertClass(descriptor, klass.Get(), hash);
Ian Rogersc114b5f2014-07-21 08:55:01 -07002753 if (existing != nullptr) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002754 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
2755 // this thread to block.
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002756 return EnsureResolved(self, descriptor, existing);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002757 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002758
Mathieu Chartierc7853442015-03-27 14:35:38 -07002759 // Load the fields and other things after we are inserted in the table. This is so that we don't
2760 // end up allocating unfree-able linear alloc resources and then lose the race condition. The
2761 // other reason is that the field roots are only visited from the class table. So we need to be
2762 // inserted before we allocate / fill in these fields.
Alex Lightb0f11922017-01-23 14:25:17 -08002763 LoadClass(self, *new_dex_file, *new_class_def, klass);
Mathieu Chartierc7853442015-03-27 14:35:38 -07002764 if (self->IsExceptionPending()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002765 VLOG(class_linker) << self->GetException()->Dump();
Mathieu Chartierc7853442015-03-27 14:35:38 -07002766 // An exception occured during load, set status to erroneous while holding klass' lock in case
2767 // notification is necessary.
2768 if (!klass->IsErroneous()) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00002769 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Mathieu Chartierc7853442015-03-27 14:35:38 -07002770 }
2771 return nullptr;
2772 }
2773
Brian Carlstromaded5f72011-10-07 17:15:04 -07002774 // Finish loading (if necessary) by finding parents
2775 CHECK(!klass->IsLoaded());
Alex Lightb0f11922017-01-23 14:25:17 -08002776 if (!LoadSuperAndInterfaces(klass, *new_dex_file)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002777 // Loading failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002778 if (!klass->IsErroneous()) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00002779 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002780 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002781 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002782 }
2783 CHECK(klass->IsLoaded());
Andreas Gampe0f01b582017-01-18 15:22:37 -08002784
2785 // At this point the class is loaded. Publish a ClassLoad even.
2786 // Note: this may be a temporary class. It is a listener's responsibility to handle this.
Andreas Gampeac30fa22017-01-18 21:02:36 -08002787 Runtime::Current()->GetRuntimeCallbacks()->ClassLoad(klass);
Andreas Gampe0f01b582017-01-18 15:22:37 -08002788
Brian Carlstromaded5f72011-10-07 17:15:04 -07002789 // Link the class (if necessary)
2790 CHECK(!klass->IsResolved());
Mathieu Chartier590fee92013-09-13 13:46:47 -07002791 // TODO: Use fast jobjects?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002792 auto interfaces = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002793
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002794 MutableHandle<mirror::Class> h_new_class = hs.NewHandle<mirror::Class>(nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002795 if (!LinkClass(self, descriptor, klass, interfaces, &h_new_class)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002796 // Linking failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002797 if (!klass->IsErroneous()) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00002798 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002799 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002800 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002801 }
Mathieu Chartier524507a2014-08-27 15:28:28 -07002802 self->AssertNoPendingException();
Andreas Gampefa4333d2017-02-14 11:10:34 -08002803 CHECK(h_new_class != nullptr) << descriptor;
Vladimir Marko72ab6842017-01-20 19:32:50 +00002804 CHECK(h_new_class->IsResolved() && !h_new_class->IsErroneousResolved()) << descriptor;
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002805
Sebastien Hertza8a697f2015-01-15 12:28:47 +01002806 // Instrumentation may have updated entrypoints for all methods of all
2807 // classes. However it could not update methods of this class while we
2808 // were loading it. Now the class is resolved, we can update entrypoints
2809 // as required by instrumentation.
2810 if (Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
2811 // We must be in the kRunnable state to prevent instrumentation from
2812 // suspending all threads to update entrypoints while we are doing it
2813 // for this class.
2814 DCHECK_EQ(self->GetState(), kRunnable);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002815 Runtime::Current()->GetInstrumentation()->InstallStubsForClass(h_new_class.Get());
Sebastien Hertza8a697f2015-01-15 12:28:47 +01002816 }
2817
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002818 /*
2819 * We send CLASS_PREPARE events to the debugger from here. The
2820 * definition of "preparation" is creating the static fields for a
2821 * class and initializing them to the standard default values, but not
2822 * executing any code (that comes later, during "initialization").
2823 *
2824 * We did the static preparation in LinkClass.
2825 *
2826 * The class has been prepared and resolved but possibly not yet verified
2827 * at this point.
2828 */
Andreas Gampeac30fa22017-01-18 21:02:36 -08002829 Runtime::Current()->GetRuntimeCallbacks()->ClassPrepare(klass, h_new_class);
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002830
Tamas Berghammer160e6df2016-01-05 14:29:02 +00002831 // Notify native debugger of the new class and its layout.
2832 jit::Jit::NewTypeLoadedIfUsingJit(h_new_class.Get());
2833
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002834 return h_new_class.Get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002835}
2836
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002837uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
2838 const DexFile::ClassDef& dex_class_def) {
Ian Rogers13735952014-10-08 12:43:28 -07002839 const uint8_t* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002840 size_t num_ref = 0;
Fred Shih37f05ef2014-07-16 18:38:08 -07002841 size_t num_8 = 0;
2842 size_t num_16 = 0;
Brian Carlstrom4873d462011-08-21 15:23:39 -07002843 size_t num_32 = 0;
2844 size_t num_64 = 0;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002845 if (class_data != nullptr) {
Vladimir Marko879d27b2016-03-15 20:31:50 +00002846 // We allow duplicate definitions of the same field in a class_data_item
2847 // but ignore the repeated indexes here, b/21868015.
2848 uint32_t last_field_idx = DexFile::kDexNoIndex;
Ian Rogers0571d352011-11-03 19:51:38 -07002849 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
Vladimir Marko879d27b2016-03-15 20:31:50 +00002850 uint32_t field_idx = it.GetMemberIndex();
2851 // Ordering enforced by DexFileVerifier.
2852 DCHECK(last_field_idx == DexFile::kDexNoIndex || last_field_idx <= field_idx);
2853 if (UNLIKELY(field_idx == last_field_idx)) {
2854 continue;
2855 }
2856 last_field_idx = field_idx;
2857 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002858 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002859 char c = descriptor[0];
Fred Shih37f05ef2014-07-16 18:38:08 -07002860 switch (c) {
2861 case 'L':
2862 case '[':
2863 num_ref++;
2864 break;
2865 case 'J':
2866 case 'D':
2867 num_64++;
2868 break;
2869 case 'I':
2870 case 'F':
2871 num_32++;
2872 break;
2873 case 'S':
2874 case 'C':
2875 num_16++;
2876 break;
2877 case 'B':
2878 case 'Z':
2879 num_8++;
2880 break;
2881 default:
2882 LOG(FATAL) << "Unknown descriptor: " << c;
Ian Rogerse0a02da2014-12-02 14:10:53 -08002883 UNREACHABLE();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002884 }
2885 }
2886 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002887 return mirror::Class::ComputeClassSize(false,
2888 0,
2889 num_8,
2890 num_16,
2891 num_32,
2892 num_64,
2893 num_ref,
Mathieu Chartiere401d142015-04-22 13:56:20 -07002894 image_pointer_size_);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002895}
2896
TDYa12785321912012-04-01 15:24:56 -07002897// Special case to get oat code without overwriting a trampoline.
Mathieu Chartiere401d142015-04-22 13:56:20 -07002898const void* ClassLinker::GetQuickOatCodeFor(ArtMethod* method) {
David Sehr709b0702016-10-13 09:12:37 -07002899 CHECK(method->IsInvokable()) << method->PrettyMethod();
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00002900 if (method->IsProxyMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002901 return GetQuickProxyInvokeHandler();
Jeff Hao8df6cea2013-07-29 13:54:48 -07002902 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002903 auto* code = method->GetOatMethodQuickCode(GetImagePointerSize());
2904 if (code != nullptr) {
2905 return code;
Mathieu Chartier2535abe2015-02-17 10:38:49 -08002906 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002907 if (method->IsNative()) {
2908 // No code and native? Use generic trampoline.
2909 return GetQuickGenericJniStub();
2910 }
2911 return GetQuickToInterpreterBridge();
TDYa12785321912012-04-01 15:24:56 -07002912}
2913
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002914bool ClassLinker::ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) {
2915 if (UNLIKELY(method->IsNative() || method->IsProxyMethod())) {
2916 return false;
2917 }
2918
Elliott Hughes956af0f2014-12-11 14:34:28 -08002919 if (quick_code == nullptr) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002920 return true;
2921 }
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002922
2923 Runtime* runtime = Runtime::Current();
2924 instrumentation::Instrumentation* instr = runtime->GetInstrumentation();
2925 if (instr->InterpretOnly()) {
2926 return true;
2927 }
2928
2929 if (runtime->GetClassLinker()->IsQuickToInterpreterBridge(quick_code)) {
2930 // Doing this check avoids doing compiled/interpreter transitions.
2931 return true;
2932 }
2933
2934 if (Dbg::IsForcedInterpreterNeededForCalling(Thread::Current(), method)) {
2935 // Force the use of interpreter when it is required by the debugger.
2936 return true;
2937 }
2938
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002939 if (runtime->IsJavaDebuggable()) {
2940 // For simplicity, we ignore precompiled code and go to the interpreter
2941 // assuming we don't already have jitted code.
2942 // We could look at the oat file where `quick_code` is being defined,
2943 // and check whether it's been compiled debuggable, but we decided to
2944 // only rely on the JIT for debuggable apps.
Alex Light6b16d892016-11-11 11:21:04 -08002945 jit::Jit* jit = Runtime::Current()->GetJit();
2946 return (jit == nullptr) || !jit->GetCodeCache()->ContainsPc(quick_code);
2947 }
2948
David Srbeckyf4480162016-03-16 00:06:24 +00002949 if (runtime->IsNativeDebuggable()) {
Calin Juravlee5de54c2016-04-20 14:22:09 +01002950 DCHECK(runtime->UseJitCompilation() && runtime->GetJit()->JitAtFirstUse());
David Srbeckyf4480162016-03-16 00:06:24 +00002951 // If we are doing native debugging, ignore application's AOT code,
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002952 // since we want to JIT it (at first use) with extra stackmaps for native
2953 // debugging. We keep however all AOT code from the boot image,
2954 // since the JIT-at-first-use is blocking and would result in non-negligible
2955 // startup performance impact.
David Srbeckyf4480162016-03-16 00:06:24 +00002956 return !runtime->GetHeap()->IsInBootImageOatFile(quick_code);
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002957 }
2958
2959 return false;
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002960}
2961
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002962void ClassLinker::FixupStaticTrampolines(ObjPtr<mirror::Class> klass) {
David Sehr709b0702016-10-13 09:12:37 -07002963 DCHECK(klass->IsInitialized()) << klass->PrettyDescriptor();
Ian Rogers1c829822013-09-30 18:18:50 -07002964 if (klass->NumDirectMethods() == 0) {
2965 return; // No direct methods => no static methods.
Ian Rogers19846512012-02-24 11:42:47 -08002966 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002967 Runtime* runtime = Runtime::Current();
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07002968 if (!runtime->IsStarted()) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002969 if (runtime->IsAotCompiler() || runtime->GetHeap()->HasBootImageSpace()) {
Alex Light64ad14d2014-08-19 14:23:13 -07002970 return; // OAT file unavailable.
2971 }
Ian Rogers19846512012-02-24 11:42:47 -08002972 }
Alex Light64ad14d2014-08-19 14:23:13 -07002973
Mathieu Chartierf8322842014-05-16 10:59:25 -07002974 const DexFile& dex_file = klass->GetDexFile();
2975 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Ian Rogers1c829822013-09-30 18:18:50 -07002976 CHECK(dex_class_def != nullptr);
Ian Rogers13735952014-10-08 12:43:28 -07002977 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
Ian Rogers1c829822013-09-30 18:18:50 -07002978 // There should always be class data if there were direct methods.
David Sehr709b0702016-10-13 09:12:37 -07002979 CHECK(class_data != nullptr) << klass->PrettyDescriptor();
Ian Rogers19846512012-02-24 11:42:47 -08002980 ClassDataItemIterator it(dex_file, class_data);
2981 // Skip fields
2982 while (it.HasNextStaticField()) {
2983 it.Next();
2984 }
2985 while (it.HasNextInstanceField()) {
2986 it.Next();
2987 }
Ian Rogers97b52f82014-08-14 11:34:07 -07002988 bool has_oat_class;
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002989 OatFile::OatClass oat_class = OatFile::FindOatClass(dex_file,
2990 klass->GetDexClassDefIndex(),
2991 &has_oat_class);
Ian Rogers1c829822013-09-30 18:18:50 -07002992 // Link the code of methods skipped by LinkCode.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002993 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002994 ArtMethod* method = klass->GetDirectMethod(method_index, image_pointer_size_);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002995 if (!method->IsStatic()) {
2996 // Only update static methods.
2997 continue;
Ian Rogers19846512012-02-24 11:42:47 -08002998 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01002999 const void* quick_code = nullptr;
3000 if (has_oat_class) {
3001 OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003002 quick_code = oat_method.GetQuickCode();
3003 }
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003004 // Check whether the method is native, in which case it's generic JNI.
3005 if (quick_code == nullptr && method->IsNative()) {
3006 quick_code = GetQuickGenericJniStub();
3007 } else if (ShouldUseInterpreterEntrypoint(method, quick_code)) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003008 // Use interpreter entry point.
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003009 quick_code = GetQuickToInterpreterBridge();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003010 }
Elliott Hughes956af0f2014-12-11 14:34:28 -08003011 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code);
Ian Rogers19846512012-02-24 11:42:47 -08003012 }
Ian Rogers62d6c772013-02-27 08:32:07 -08003013 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08003014}
3015
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003016// Does anything needed to make sure that the compiler will not generate a direct invoke to this
3017// method. Should only be called on non-invokable methods.
3018inline void EnsureThrowsInvocationError(ClassLinker* class_linker, ArtMethod* method) {
Alex Light9139e002015-10-09 15:59:48 -07003019 DCHECK(method != nullptr);
3020 DCHECK(!method->IsInvokable());
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003021 method->SetEntryPointFromQuickCompiledCodePtrSize(
3022 class_linker->GetQuickToInterpreterBridgeTrampoline(),
3023 class_linker->GetImagePointerSize());
Alex Light9139e002015-10-09 15:59:48 -07003024}
3025
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003026static void LinkCode(ClassLinker* class_linker,
3027 ArtMethod* method,
3028 const OatFile::OatClass* oat_class,
3029 uint32_t class_def_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003030 Runtime* const runtime = Runtime::Current();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08003031 if (runtime->IsAotCompiler()) {
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003032 // The following code only applies to a non-compiler runtime.
3033 return;
3034 }
Ian Rogers62d6c772013-02-27 08:32:07 -08003035 // Method shouldn't have already been linked.
Ian Rogersef7d42f2014-01-06 12:55:46 -08003036 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003037 if (oat_class != nullptr) {
3038 // Every kind of method should at least get an invoke stub from the oat_method.
3039 // non-abstract methods also get their code pointers.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07003040 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003041 oat_method.LinkMethod(method);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003042 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07003043
Tamas Berghammer3a98aae2016-02-08 20:21:54 +00003044 // Install entry point from interpreter.
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003045 const void* quick_code = method->GetEntryPointFromQuickCompiledCode();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003046 bool enter_interpreter = class_linker->ShouldUseInterpreterEntrypoint(method, quick_code);
Jeff Hao16743632013-05-08 10:59:04 -07003047
Alex Light9139e002015-10-09 15:59:48 -07003048 if (!method->IsInvokable()) {
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003049 EnsureThrowsInvocationError(class_linker, method);
Brian Carlstrom92827a52011-10-10 15:50:01 -07003050 return;
3051 }
Ian Rogers19846512012-02-24 11:42:47 -08003052
3053 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003054 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003055 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
3056 // after initializing class (see ClassLinker::InitializeClass method).
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003057 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub());
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003058 } else if (quick_code == nullptr && method->IsNative()) {
3059 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniStub());
Tamas Berghammer3a98aae2016-02-08 20:21:54 +00003060 } else if (enter_interpreter) {
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003061 // Set entry point from compiled code if there's no code or in interpreter only mode.
3062 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08003063 }
jeffhao26c0a1a2012-01-17 16:28:33 -08003064
Ian Rogers62d6c772013-02-27 08:32:07 -08003065 if (method->IsNative()) {
3066 // Unregistering restores the dlsym lookup stub.
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003067 method->UnregisterNative();
Andreas Gampe90546832014-03-12 18:07:19 -07003068
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003069 if (enter_interpreter || quick_code == nullptr) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003070 // We have a native method here without code. Then it should have either the generic JNI
3071 // trampoline as entrypoint (non-static), or the resolution trampoline (static).
3072 // TODO: this doesn't handle all the cases where trampolines may be installed.
3073 const void* entry_point = method->GetEntryPointFromQuickCompiledCode();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003074 DCHECK(class_linker->IsQuickGenericJniStub(entry_point) ||
3075 class_linker->IsQuickResolutionStub(entry_point));
Andreas Gampe90546832014-03-12 18:07:19 -07003076 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07003077 }
3078}
3079
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003080void ClassLinker::SetupClass(const DexFile& dex_file,
3081 const DexFile::ClassDef& dex_class_def,
3082 Handle<mirror::Class> klass,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003083 ObjPtr<mirror::ClassLoader> class_loader) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08003084 CHECK(klass != nullptr);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003085 CHECK(klass->GetDexCache() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003086 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07003087 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003088 CHECK(descriptor != nullptr);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003089
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003090 klass->SetClass(GetClassRoot(kJavaLangClass));
Andreas Gampe51829322014-08-25 15:05:04 -07003091 uint32_t access_flags = dex_class_def.GetJavaAccessFlags();
Brian Carlstrom8e3fb142013-10-09 21:00:27 -07003092 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003093 klass->SetAccessFlags(access_flags);
3094 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08003095 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003096 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, nullptr);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003097
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003098 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003099 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Mathieu Chartierc7853442015-03-27 14:35:38 -07003100}
Brian Carlstrom934486c2011-07-12 23:42:50 -07003101
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003102void ClassLinker::LoadClass(Thread* self,
3103 const DexFile& dex_file,
Mathieu Chartierc7853442015-03-27 14:35:38 -07003104 const DexFile::ClassDef& dex_class_def,
3105 Handle<mirror::Class> klass) {
Ian Rogers13735952014-10-08 12:43:28 -07003106 const uint8_t* class_data = dex_file.GetClassData(dex_class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003107 if (class_data == nullptr) {
Ian Rogers0571d352011-11-03 19:51:38 -07003108 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07003109 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003110 LoadClassMembers(self, dex_file, class_data, klass);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01003111}
3112
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003113LengthPrefixedArray<ArtField>* ClassLinker::AllocArtFieldArray(Thread* self,
3114 LinearAlloc* allocator,
3115 size_t length) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003116 if (length == 0) {
3117 return nullptr;
3118 }
Vladimir Markocf36d492015-08-12 19:27:26 +01003119 // If the ArtField alignment changes, review all uses of LengthPrefixedArray<ArtField>.
3120 static_assert(alignof(ArtField) == 4, "ArtField alignment is expected to be 4.");
3121 size_t storage_size = LengthPrefixedArray<ArtField>::ComputeSize(length);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003122 void* array_storage = allocator->Alloc(self, storage_size);
Vladimir Markocf36d492015-08-12 19:27:26 +01003123 auto* ret = new(array_storage) LengthPrefixedArray<ArtField>(length);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003124 CHECK(ret != nullptr);
3125 std::uninitialized_fill_n(&ret->At(0), length, ArtField());
3126 return ret;
Mathieu Chartierc7853442015-03-27 14:35:38 -07003127}
3128
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003129LengthPrefixedArray<ArtMethod>* ClassLinker::AllocArtMethodArray(Thread* self,
3130 LinearAlloc* allocator,
3131 size_t length) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003132 if (length == 0) {
3133 return nullptr;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003134 }
Vladimir Marko14632852015-08-17 12:07:23 +01003135 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_);
3136 const size_t method_size = ArtMethod::Size(image_pointer_size_);
Vladimir Markocf36d492015-08-12 19:27:26 +01003137 const size_t storage_size =
3138 LengthPrefixedArray<ArtMethod>::ComputeSize(length, method_size, method_alignment);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003139 void* array_storage = allocator->Alloc(self, storage_size);
Vladimir Markocf36d492015-08-12 19:27:26 +01003140 auto* ret = new (array_storage) LengthPrefixedArray<ArtMethod>(length);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003141 CHECK(ret != nullptr);
3142 for (size_t i = 0; i < length; ++i) {
Vladimir Markocf36d492015-08-12 19:27:26 +01003143 new(reinterpret_cast<void*>(&ret->At(i, method_size, method_alignment))) ArtMethod;
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003144 }
3145 return ret;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003146}
3147
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003148LinearAlloc* ClassLinker::GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003149 if (class_loader == nullptr) {
3150 return Runtime::Current()->GetLinearAlloc();
3151 }
3152 LinearAlloc* allocator = class_loader->GetAllocator();
3153 DCHECK(allocator != nullptr);
3154 return allocator;
3155}
3156
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003157LinearAlloc* ClassLinker::GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003158 if (class_loader == nullptr) {
3159 return Runtime::Current()->GetLinearAlloc();
3160 }
3161 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3162 LinearAlloc* allocator = class_loader->GetAllocator();
3163 if (allocator == nullptr) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08003164 RegisterClassLoader(class_loader);
3165 allocator = class_loader->GetAllocator();
3166 CHECK(allocator != nullptr);
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003167 }
3168 return allocator;
3169}
3170
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003171void ClassLinker::LoadClassMembers(Thread* self,
3172 const DexFile& dex_file,
Ian Rogers13735952014-10-08 12:43:28 -07003173 const uint8_t* class_data,
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003174 Handle<mirror::Class> klass) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003175 {
3176 // Note: We cannot have thread suspension until the field and method arrays are setup or else
3177 // Class::VisitFieldRoots may miss some fields or methods.
Mathieu Chartier268764d2016-09-13 12:09:38 -07003178 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003179 // Load static fields.
Vladimir Marko23682bf2015-06-24 14:28:03 +01003180 // We allow duplicate definitions of the same field in a class_data_item
3181 // but ignore the repeated indexes here, b/21868015.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003182 LinearAlloc* const allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
Mathieu Chartiere401d142015-04-22 13:56:20 -07003183 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003184 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self,
3185 allocator,
3186 it.NumStaticFields());
Vladimir Marko23682bf2015-06-24 14:28:03 +01003187 size_t num_sfields = 0;
3188 uint32_t last_field_idx = 0u;
3189 for (; it.HasNextStaticField(); it.Next()) {
3190 uint32_t field_idx = it.GetMemberIndex();
3191 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier.
3192 if (num_sfields == 0 || LIKELY(field_idx > last_field_idx)) {
3193 DCHECK_LT(num_sfields, it.NumStaticFields());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003194 LoadField(it, klass, &sfields->At(num_sfields));
Vladimir Marko23682bf2015-06-24 14:28:03 +01003195 ++num_sfields;
3196 last_field_idx = field_idx;
3197 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003198 }
Orion Hodsonc069a302017-01-18 09:23:12 +00003199
Mathieu Chartiere401d142015-04-22 13:56:20 -07003200 // Load instance fields.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003201 LengthPrefixedArray<ArtField>* ifields = AllocArtFieldArray(self,
3202 allocator,
3203 it.NumInstanceFields());
Vladimir Marko23682bf2015-06-24 14:28:03 +01003204 size_t num_ifields = 0u;
3205 last_field_idx = 0u;
3206 for (; it.HasNextInstanceField(); it.Next()) {
3207 uint32_t field_idx = it.GetMemberIndex();
3208 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier.
3209 if (num_ifields == 0 || LIKELY(field_idx > last_field_idx)) {
3210 DCHECK_LT(num_ifields, it.NumInstanceFields());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003211 LoadField(it, klass, &ifields->At(num_ifields));
Vladimir Marko23682bf2015-06-24 14:28:03 +01003212 ++num_ifields;
3213 last_field_idx = field_idx;
3214 }
3215 }
Orion Hodsonc069a302017-01-18 09:23:12 +00003216
Vladimir Marko23682bf2015-06-24 14:28:03 +01003217 if (UNLIKELY(num_sfields != it.NumStaticFields()) ||
3218 UNLIKELY(num_ifields != it.NumInstanceFields())) {
David Sehr709b0702016-10-13 09:12:37 -07003219 LOG(WARNING) << "Duplicate fields in class " << klass->PrettyDescriptor()
Vladimir Marko23682bf2015-06-24 14:28:03 +01003220 << " (unique static fields: " << num_sfields << "/" << it.NumStaticFields()
3221 << ", unique instance fields: " << num_ifields << "/" << it.NumInstanceFields() << ")";
Vladimir Marko81819db2015-11-05 15:30:12 +00003222 // NOTE: Not shrinking the over-allocated sfields/ifields, just setting size.
3223 if (sfields != nullptr) {
3224 sfields->SetSize(num_sfields);
3225 }
3226 if (ifields != nullptr) {
3227 ifields->SetSize(num_ifields);
3228 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003229 }
Vladimir Marko81819db2015-11-05 15:30:12 +00003230 // Set the field arrays.
3231 klass->SetSFieldsPtr(sfields);
3232 DCHECK_EQ(klass->NumStaticFields(), num_sfields);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003233 klass->SetIFieldsPtr(ifields);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003234 DCHECK_EQ(klass->NumInstanceFields(), num_ifields);
3235 // Load methods.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003236 bool has_oat_class = false;
3237 const OatFile::OatClass oat_class =
3238 (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler())
3239 ? OatFile::FindOatClass(dex_file, klass->GetDexClassDefIndex(), &has_oat_class)
3240 : OatFile::OatClass::Invalid();
3241 const OatFile::OatClass* oat_class_ptr = has_oat_class ? &oat_class : nullptr;
Alex Lighte64300b2015-12-15 15:02:47 -08003242 klass->SetMethodsPtr(
3243 AllocArtMethodArray(self, allocator, it.NumDirectMethods() + it.NumVirtualMethods()),
3244 it.NumDirectMethods(),
3245 it.NumVirtualMethods());
Mathieu Chartiere401d142015-04-22 13:56:20 -07003246 size_t class_def_method_index = 0;
3247 uint32_t last_dex_method_index = DexFile::kDexNoIndex;
3248 size_t last_class_def_method_index = 0;
Alex Lighte64300b2015-12-15 15:02:47 -08003249 // TODO These should really use the iterators.
Mathieu Chartiere401d142015-04-22 13:56:20 -07003250 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
3251 ArtMethod* method = klass->GetDirectMethodUnchecked(i, image_pointer_size_);
Mathieu Chartier268764d2016-09-13 12:09:38 -07003252 LoadMethod(dex_file, it, klass, method);
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003253 LinkCode(this, method, oat_class_ptr, class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003254 uint32_t it_method_index = it.GetMemberIndex();
3255 if (last_dex_method_index == it_method_index) {
3256 // duplicate case
3257 method->SetMethodIndex(last_class_def_method_index);
3258 } else {
3259 method->SetMethodIndex(class_def_method_index);
3260 last_dex_method_index = it_method_index;
3261 last_class_def_method_index = class_def_method_index;
3262 }
3263 class_def_method_index++;
3264 }
3265 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
3266 ArtMethod* method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
Mathieu Chartier268764d2016-09-13 12:09:38 -07003267 LoadMethod(dex_file, it, klass, method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003268 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003269 LinkCode(this, method, oat_class_ptr, class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003270 class_def_method_index++;
3271 }
3272 DCHECK(!it.HasNext());
Ian Rogers0571d352011-11-03 19:51:38 -07003273 }
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07003274 // Ensure that the card is marked so that remembered sets pick up native roots.
3275 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass.Get());
Mathieu Chartierf3f2a7a2015-04-14 15:43:10 -07003276 self->AllowThreadSuspension();
Brian Carlstrom934486c2011-07-12 23:42:50 -07003277}
3278
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003279void ClassLinker::LoadField(const ClassDataItemIterator& it,
3280 Handle<mirror::Class> klass,
Mathieu Chartierc7853442015-03-27 14:35:38 -07003281 ArtField* dst) {
3282 const uint32_t field_idx = it.GetMemberIndex();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003283 dst->SetDexFieldIndex(field_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003284 dst->SetDeclaringClass(klass.Get());
Andreas Gampe51829322014-08-25 15:05:04 -07003285 dst->SetAccessFlags(it.GetFieldAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07003286}
3287
Mathieu Chartier268764d2016-09-13 12:09:38 -07003288void ClassLinker::LoadMethod(const DexFile& dex_file,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003289 const ClassDataItemIterator& it,
3290 Handle<mirror::Class> klass,
3291 ArtMethod* dst) {
Ian Rogers19846512012-02-24 11:42:47 -08003292 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08003293 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07003294 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07003295
Mathieu Chartier268764d2016-09-13 12:09:38 -07003296 ScopedAssertNoThreadSuspension ants("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07003297 dst->SetDexMethodIndex(dex_method_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003298 dst->SetDeclaringClass(klass.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07003299 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Brian Carlstrom934486c2011-07-12 23:42:50 -07003300
Vladimir Marko05792b92015-08-03 11:56:49 +01003301 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods(), image_pointer_size_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07003302
Andreas Gampe51829322014-08-25 15:05:04 -07003303 uint32_t access_flags = it.GetMethodAccessFlags();
Ian Rogers241b5de2013-10-09 17:58:57 -07003304
Ian Rogersdfb325e2013-10-30 01:00:44 -07003305 if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07003306 // Set finalizable flag on declaring class.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003307 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
3308 // Void return type.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003309 if (klass->GetClassLoader() != nullptr) { // All non-boot finalizer methods are flagged.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003310 klass->SetFinalizable();
3311 } else {
Ian Rogers1ff3c982014-08-12 02:30:58 -07003312 std::string temp;
3313 const char* klass_descriptor = klass->GetDescriptor(&temp);
Ian Rogersdfb325e2013-10-30 01:00:44 -07003314 // The Enum class declares a "final" finalize() method to prevent subclasses from
3315 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
3316 // subclasses, so we exclude it here.
3317 // We also want to avoid setting the flag on Object, where we know that finalize() is
3318 // empty.
Ian Rogers1ff3c982014-08-12 02:30:58 -07003319 if (strcmp(klass_descriptor, "Ljava/lang/Object;") != 0 &&
3320 strcmp(klass_descriptor, "Ljava/lang/Enum;") != 0) {
Ian Rogers241b5de2013-10-09 17:58:57 -07003321 klass->SetFinalizable();
Ian Rogers241b5de2013-10-09 17:58:57 -07003322 }
3323 }
3324 }
3325 } else if (method_name[0] == '<') {
3326 // Fix broken access flags for initializers. Bug 11157540.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003327 bool is_init = (strcmp("<init>", method_name) == 0);
3328 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
Ian Rogers241b5de2013-10-09 17:58:57 -07003329 if (UNLIKELY(!is_init && !is_clinit)) {
3330 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
3331 } else {
3332 if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
3333 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
David Sehr709b0702016-10-13 09:12:37 -07003334 << klass->PrettyDescriptor() << " in dex file " << dex_file.GetLocation();
Ian Rogers241b5de2013-10-09 17:58:57 -07003335 access_flags |= kAccConstructor;
3336 }
3337 }
3338 }
3339 dst->SetAccessFlags(access_flags);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003340}
3341
Ian Rogers7b078e82014-09-10 14:44:24 -07003342void ClassLinker::AppendToBootClassPath(Thread* self, const DexFile& dex_file) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003343 ObjPtr<mirror::DexCache> dex_cache = AllocAndInitializeDexCache(
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003344 self,
3345 dex_file,
Vladimir Markocd556b02017-02-03 11:47:34 +00003346 Runtime::Current()->GetLinearAlloc());
3347 CHECK(dex_cache != nullptr) << "Failed to allocate dex cache for " << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003348 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07003349}
3350
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003351void ClassLinker::AppendToBootClassPath(const DexFile& dex_file,
Vladimir Markocd556b02017-02-03 11:47:34 +00003352 ObjPtr<mirror::DexCache> dex_cache) {
3353 CHECK(dex_cache != nullptr) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003354 boot_class_path_.push_back(&dex_file);
Vladimir Markocd556b02017-02-03 11:47:34 +00003355 RegisterBootClassPathDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003356}
3357
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003358void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file,
Vladimir Markocd556b02017-02-03 11:47:34 +00003359 ObjPtr<mirror::DexCache> dex_cache,
3360 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003361 Thread* const self = Thread::Current();
Andreas Gampecc1b5352016-12-01 16:58:38 -08003362 Locks::dex_lock_->AssertExclusiveHeld(self);
Vladimir Markocd556b02017-02-03 11:47:34 +00003363 CHECK(dex_cache != nullptr) << dex_file.GetLocation();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003364 // For app images, the dex cache location may be a suffix of the dex file location since the
3365 // dex file location is an absolute path.
Mathieu Chartier76172162016-01-26 14:54:06 -08003366 const std::string dex_cache_location = dex_cache->GetLocation()->ToModifiedUtf8();
3367 const size_t dex_cache_length = dex_cache_location.length();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003368 CHECK_GT(dex_cache_length, 0u) << dex_file.GetLocation();
3369 std::string dex_file_location = dex_file.GetLocation();
3370 CHECK_GE(dex_file_location.length(), dex_cache_length)
Mathieu Chartier76172162016-01-26 14:54:06 -08003371 << dex_cache_location << " " << dex_file.GetLocation();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003372 // Take suffix.
3373 const std::string dex_file_suffix = dex_file_location.substr(
3374 dex_file_location.length() - dex_cache_length,
3375 dex_cache_length);
3376 // Example dex_cache location is SettingsProvider.apk and
3377 // dex file location is /system/priv-app/SettingsProvider/SettingsProvider.apk
Mathieu Chartier76172162016-01-26 14:54:06 -08003378 CHECK_EQ(dex_cache_location, dex_file_suffix);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003379 // Clean up pass to remove null dex caches.
3380 // Null dex caches can occur due to class unloading and we are lazily removing null entries.
3381 JavaVMExt* const vm = self->GetJniEnv()->vm;
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003382 for (auto it = dex_caches_.begin(); it != dex_caches_.end(); ) {
3383 DexCacheData data = *it;
3384 if (self->IsJWeakCleared(data.weak_root)) {
3385 vm->DeleteWeakGlobalRef(self, data.weak_root);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003386 it = dex_caches_.erase(it);
3387 } else {
3388 ++it;
3389 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003390 }
Vladimir Markocd556b02017-02-03 11:47:34 +00003391 jweak dex_cache_jweak = vm->AddWeakGlobalRef(self, dex_cache);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003392 dex_cache->SetDexFile(&dex_file);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003393 DexCacheData data;
3394 data.weak_root = dex_cache_jweak;
3395 data.dex_file = dex_cache->GetDexFile();
Vladimir Marko942fd312017-01-16 20:52:19 +00003396 data.resolved_methods = dex_cache->GetResolvedMethods();
Vladimir Markocd556b02017-02-03 11:47:34 +00003397 data.class_table = ClassTableForClassLoader(class_loader);
3398 DCHECK(data.class_table != nullptr);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003399 dex_caches_.push_back(data);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003400}
3401
Vladimir Markocd556b02017-02-03 11:47:34 +00003402ObjPtr<mirror::DexCache> ClassLinker::DecodeDexCache(Thread* self, const DexCacheData& data) {
3403 return data.IsValid()
3404 ? ObjPtr<mirror::DexCache>::DownCast(self->DecodeJObject(data.weak_root))
3405 : nullptr;
3406}
3407
3408ObjPtr<mirror::DexCache> ClassLinker::EnsureSameClassLoader(
3409 Thread* self,
3410 ObjPtr<mirror::DexCache> dex_cache,
3411 const DexCacheData& data,
3412 ObjPtr<mirror::ClassLoader> class_loader) {
3413 DCHECK_EQ(dex_cache->GetDexFile(), data.dex_file);
3414 if (data.class_table != ClassTableForClassLoader(class_loader)) {
3415 self->ThrowNewExceptionF("Ljava/lang/InternalError;",
3416 "Attempt to register dex file %s with multiple class loaders",
3417 data.dex_file->GetLocation().c_str());
3418 return nullptr;
3419 }
3420 return dex_cache;
3421}
3422
3423ObjPtr<mirror::DexCache> ClassLinker::RegisterDexFile(const DexFile& dex_file,
3424 ObjPtr<mirror::ClassLoader> class_loader) {
Ian Rogers1f539342012-10-03 21:09:42 -07003425 Thread* self = Thread::Current();
Vladimir Markocd556b02017-02-03 11:47:34 +00003426 DexCacheData old_data;
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003427 {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003428 ReaderMutexLock mu(self, *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003429 old_data = FindDexCacheDataLocked(dex_file);
3430 }
3431 ObjPtr<mirror::DexCache> old_dex_cache = DecodeDexCache(self, old_data);
3432 if (old_dex_cache != nullptr) {
3433 return EnsureSameClassLoader(self, old_dex_cache, old_data, class_loader);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003434 }
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003435 LinearAlloc* const linear_alloc = GetOrCreateAllocatorForClassLoader(class_loader);
3436 DCHECK(linear_alloc != nullptr);
3437 ClassTable* table;
3438 {
3439 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
3440 table = InsertClassTableForClassLoader(class_loader);
3441 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003442 // Don't alloc while holding the lock, since allocation may need to
3443 // suspend all threads and another thread may need the dex_lock_ to
3444 // get to a suspend point.
Vladimir Markocd556b02017-02-03 11:47:34 +00003445 StackHandleScope<3> hs(self);
3446 Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(class_loader));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003447 ObjPtr<mirror::String> location;
Mathieu Chartier6c60d842016-09-15 10:24:43 -07003448 Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(AllocDexCache(/*out*/&location,
3449 self,
3450 dex_file)));
3451 Handle<mirror::String> h_location(hs.NewHandle(location));
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003452 {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003453 WriterMutexLock mu(self, *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003454 old_data = FindDexCacheDataLocked(dex_file);
3455 old_dex_cache = DecodeDexCache(self, old_data);
Andreas Gampefa4333d2017-02-14 11:10:34 -08003456 if (old_dex_cache == nullptr && h_dex_cache != nullptr) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003457 // Do InitializeDexCache while holding dex lock to make sure two threads don't call it at the
3458 // same time with the same dex cache. Since the .bss is shared this can cause failing DCHECK
3459 // that the arrays are null.
3460 mirror::DexCache::InitializeDexCache(self,
3461 h_dex_cache.Get(),
3462 h_location.Get(),
3463 &dex_file,
3464 linear_alloc,
3465 image_pointer_size_);
3466 RegisterDexFileLocked(dex_file, h_dex_cache.Get(), h_class_loader.Get());
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003467 }
Vladimir Markocd556b02017-02-03 11:47:34 +00003468 }
3469 if (old_dex_cache != nullptr) {
3470 // Another thread managed to initialize the dex cache faster, so use that DexCache.
3471 // If this thread encountered OOME, ignore it.
Andreas Gampefa4333d2017-02-14 11:10:34 -08003472 DCHECK_EQ(h_dex_cache == nullptr, self->IsExceptionPending());
Vladimir Markocd556b02017-02-03 11:47:34 +00003473 self->ClearException();
3474 // We cannot call EnsureSameClassLoader() while holding the dex_lock_.
3475 return EnsureSameClassLoader(self, old_dex_cache, old_data, h_class_loader.Get());
3476 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08003477 if (h_dex_cache == nullptr) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003478 self->AssertPendingOOMException();
3479 return nullptr;
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003480 }
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003481 table->InsertStrongRoot(h_dex_cache.Get());
Mathieu Chartiera1467d02017-02-22 09:22:50 -08003482 if (h_class_loader.Get() != nullptr) {
3483 // Since we added a strong root to the class table, do the write barrier as required for
3484 // remembered sets and generational GCs.
3485 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(h_class_loader.Get());
3486 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003487 return h_dex_cache.Get();
Brian Carlstromaded5f72011-10-07 17:15:04 -07003488}
3489
Vladimir Markocd556b02017-02-03 11:47:34 +00003490void ClassLinker::RegisterBootClassPathDexFile(const DexFile& dex_file,
3491 ObjPtr<mirror::DexCache> dex_cache) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003492 WriterMutexLock mu(Thread::Current(), *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003493 RegisterDexFileLocked(dex_file, dex_cache, /* class_loader */ nullptr);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003494}
3495
Vladimir Markocd556b02017-02-03 11:47:34 +00003496bool ClassLinker::IsDexFileRegistered(Thread* self, const DexFile& dex_file) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003497 ReaderMutexLock mu(self, *Locks::dex_lock_);
Vladimir Markocd556b02017-02-03 11:47:34 +00003498 return DecodeDexCache(self, FindDexCacheDataLocked(dex_file)) != nullptr;
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003499}
3500
Vladimir Markocd556b02017-02-03 11:47:34 +00003501ObjPtr<mirror::DexCache> ClassLinker::FindDexCache(Thread* self, const DexFile& dex_file) {
3502 ReaderMutexLock mu(self, *Locks::dex_lock_);
3503 ObjPtr<mirror::DexCache> dex_cache = DecodeDexCache(self, FindDexCacheDataLocked(dex_file));
3504 if (dex_cache != nullptr) {
3505 return dex_cache;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003506 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003507 // Failure, dump diagnostic and abort.
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003508 for (const DexCacheData& data : dex_caches_) {
Vladimir Markocd556b02017-02-03 11:47:34 +00003509 if (DecodeDexCache(self, data) != nullptr) {
Andreas Gampe37c58462017-03-27 15:14:27 -07003510 LOG(FATAL_WITHOUT_ABORT) << "Registered dex file " << data.dex_file->GetLocation();
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003511 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003512 }
Andreas Gampe37c58462017-03-27 15:14:27 -07003513 LOG(FATAL) << "Failed to find DexCache for DexFile " << dex_file.GetLocation();
Ian Rogerse0a02da2014-12-02 14:10:53 -08003514 UNREACHABLE();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003515}
3516
Vladimir Markocd556b02017-02-03 11:47:34 +00003517ClassTable* ClassLinker::FindClassTable(Thread* self, ObjPtr<mirror::DexCache> dex_cache) {
3518 const DexFile* dex_file = dex_cache->GetDexFile();
3519 DCHECK(dex_file != nullptr);
3520 ReaderMutexLock mu(self, *Locks::dex_lock_);
3521 // Search assuming unique-ness of dex file.
3522 for (const DexCacheData& data : dex_caches_) {
3523 // Avoid decoding (and read barriers) other unrelated dex caches.
3524 if (data.dex_file == dex_file) {
3525 ObjPtr<mirror::DexCache> registered_dex_cache = DecodeDexCache(self, data);
3526 if (registered_dex_cache != nullptr) {
3527 CHECK_EQ(registered_dex_cache, dex_cache) << dex_file->GetLocation();
3528 return data.class_table;
3529 }
3530 }
3531 }
3532 return nullptr;
3533}
3534
3535ClassLinker::DexCacheData ClassLinker::FindDexCacheDataLocked(const DexFile& dex_file) {
3536 // Search assuming unique-ness of dex file.
3537 for (const DexCacheData& data : dex_caches_) {
3538 // Avoid decoding (and read barriers) other unrelated dex caches.
3539 if (data.dex_file == &dex_file) {
3540 return data;
3541 }
3542 }
3543 return DexCacheData();
3544}
3545
Mathieu Chartiere401d142015-04-22 13:56:20 -07003546void ClassLinker::FixupDexCaches(ArtMethod* resolution_method) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003547 Thread* const self = Thread::Current();
Andreas Gampecc1b5352016-12-01 16:58:38 -08003548 ReaderMutexLock mu(self, *Locks::dex_lock_);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003549 for (const DexCacheData& data : dex_caches_) {
3550 if (!self->IsJWeakCleared(data.weak_root)) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003551 ObjPtr<mirror::DexCache> dex_cache = ObjPtr<mirror::DexCache>::DownCast(
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003552 self->DecodeJObject(data.weak_root));
3553 if (dex_cache != nullptr) {
3554 dex_cache->Fixup(resolution_method, image_pointer_size_);
3555 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003556 }
Ian Rogers19846512012-02-24 11:42:47 -08003557 }
3558}
3559
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003560mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Mathieu Chartier6beced42016-11-15 15:51:31 -08003561 ObjPtr<mirror::Class> klass =
3562 AllocClass(self, mirror::Class::PrimitiveClassSize(image_pointer_size_));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003563 if (UNLIKELY(klass == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003564 self->AssertPendingOOMException();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003565 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003566 }
3567 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003568}
3569
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003570mirror::Class* ClassLinker::InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003571 Primitive::Type type) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003572 CHECK(primitive_class != nullptr);
Ian Rogers1f539342012-10-03 21:09:42 -07003573 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003574 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003575 StackHandleScope<1> hs(self);
3576 Handle<mirror::Class> h_class(hs.NewHandle(primitive_class));
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003577 ObjectLock<mirror::Class> lock(self, h_class);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003578 h_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
3579 h_class->SetPrimitiveType(type);
Mathieu Chartier6beced42016-11-15 15:51:31 -08003580 h_class->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003581 mirror::Class::SetStatus(h_class, mirror::Class::kStatusInitialized, self);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003582 const char* descriptor = Primitive::Descriptor(type);
Mathieu Chartier6beced42016-11-15 15:51:31 -08003583 ObjPtr<mirror::Class> existing = InsertClass(descriptor,
3584 h_class.Get(),
3585 ComputeModifiedUtf8Hash(descriptor));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003586 CHECK(existing == nullptr) << "InitPrimitiveClass(" << type << ") failed";
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003587 return h_class.Get();
Carl Shapiro565f5072011-07-10 13:39:43 -07003588}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003589
Brian Carlstrombe977852011-07-19 14:54:54 -07003590// Create an array class (i.e. the class object for the array, not the
3591// array itself). "descriptor" looks like "[C" or "[[[[B" or
3592// "[Ljava/lang/String;".
3593//
3594// If "descriptor" refers to an array of primitives, look up the
3595// primitive type's internally-generated class object.
3596//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003597// "class_loader" is the class loader of the class that's referring to
3598// us. It's used to ensure that we're looking for the element type in
3599// the right context. It does NOT become the class loader for the
3600// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07003601//
Mathieu Chartier2cebb242015-04-21 16:50:40 -07003602// Returns null with an exception raised on failure.
Igor Murashkinb1d8c312015-08-04 11:18:43 -07003603mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor, size_t hash,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003604 Handle<mirror::ClassLoader> class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003605 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003606 CHECK_EQ('[', descriptor[0]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003607 StackHandleScope<2> hs(self);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003608 MutableHandle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1,
3609 class_loader)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003610 if (component_type == nullptr) {
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003611 DCHECK(self->IsExceptionPending());
Andreas Gampedc13d7d2014-07-23 20:18:36 -07003612 // We need to accept erroneous classes as component types.
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08003613 const size_t component_hash = ComputeModifiedUtf8Hash(descriptor + 1);
3614 component_type.Assign(LookupClass(self, descriptor + 1, component_hash, class_loader.Get()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003615 if (component_type == nullptr) {
Andreas Gampedc13d7d2014-07-23 20:18:36 -07003616 DCHECK(self->IsExceptionPending());
3617 return nullptr;
3618 } else {
3619 self->ClearException();
3620 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003621 }
Ian Rogers2d10b202014-05-12 19:15:18 -07003622 if (UNLIKELY(component_type->IsPrimitiveVoid())) {
3623 ThrowNoClassDefFoundError("Attempt to create array of void primitive type");
3624 return nullptr;
3625 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003626 // See if the component type is already loaded. Array classes are
3627 // always associated with the class loader of their underlying
3628 // element type -- an array of Strings goes with the loader for
3629 // java/lang/String -- so we need to look for it there. (The
3630 // caller should have checked for the existence of the class
3631 // before calling here, but they did so with *their* class loader,
3632 // not the component type's loader.)
3633 //
3634 // If we find it, the caller adds "loader" to the class' initiating
3635 // loader list, which should prevent us from going through this again.
3636 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003637 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003638 // are the same, because our caller (FindClass) just did the
3639 // lookup. (Even if we get this wrong we still have correct behavior,
3640 // because we effectively do this lookup again when we add the new
3641 // class to the hash table --- necessary because of possible races with
3642 // other threads.)
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003643 if (class_loader.Get() != component_type->GetClassLoader()) {
Vladimir Marko6ad2f6d2017-01-18 15:22:59 +00003644 ObjPtr<mirror::Class> new_class =
3645 LookupClass(self, descriptor, hash, component_type->GetClassLoader());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003646 if (new_class != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003647 return new_class.Ptr();
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003648 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003649 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003650
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003651 // Fill out the fields in the Class.
3652 //
3653 // It is possible to execute some methods against arrays, because
3654 // all arrays are subclasses of java_lang_Object_, so we need to set
3655 // up a vtable. We can just point at the one in java_lang_Object_.
3656 //
3657 // Array classes are simple enough that we don't need to do a full
3658 // link step.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003659 auto new_class = hs.NewHandle<mirror::Class>(nullptr);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003660 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003661 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003662 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003663 new_class.Assign(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003664 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003665 new_class.Assign(GetClassRoot(kObjectArrayClass));
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003666 } else if (strcmp(descriptor, GetClassRootDescriptor(kJavaLangStringArrayClass)) == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003667 new_class.Assign(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003668 } else if (strcmp(descriptor, "[C") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003669 new_class.Assign(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003670 } else if (strcmp(descriptor, "[I") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003671 new_class.Assign(GetClassRoot(kIntArrayClass));
Mathieu Chartierc7853442015-03-27 14:35:38 -07003672 } else if (strcmp(descriptor, "[J") == 0) {
3673 new_class.Assign(GetClassRoot(kLongArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003674 }
3675 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08003676 if (new_class == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003677 new_class.Assign(AllocClass(self, mirror::Array::ClassSize(image_pointer_size_)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003678 if (new_class == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003679 self->AssertPendingOOMException();
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003680 return nullptr;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003681 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003682 new_class->SetComponentType(component_type.Get());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003683 }
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003684 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003685 DCHECK(new_class->GetComponentType() != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003686 ObjPtr<mirror::Class> java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003687 new_class->SetSuperClass(java_lang_Object);
3688 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003689 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003690 new_class->SetClassLoader(component_type->GetClassLoader());
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07003691 if (component_type->IsPrimitive()) {
3692 new_class->SetClassFlags(mirror::kClassFlagNoReferenceFields);
3693 } else {
3694 new_class->SetClassFlags(mirror::kClassFlagObjectArray);
3695 }
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003696 mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self);
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00003697 new_class->PopulateEmbeddedVTable(image_pointer_size_);
3698 ImTable* object_imt = java_lang_Object->GetImt(image_pointer_size_);
3699 new_class->SetImt(object_imt, image_pointer_size_);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003700 mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003701 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07003702 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003703
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003704 // All arrays have java/lang/Cloneable and java/io/Serializable as
3705 // interfaces. We need to set that up here, so that stuff like
3706 // "instanceof" works right.
3707 //
3708 // Note: The GC could run during the call to FindSystemClass,
3709 // so we need to make sure the class object is GC-valid while we're in
3710 // there. Do this by clearing the interface list so the GC will just
3711 // think that the entries are null.
3712
3713
3714 // Use the single, global copies of "interfaces" and "iftable"
3715 // (remember not to free them for arrays).
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003716 {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003717 ObjPtr<mirror::IfTable> array_iftable = array_iftable_.Read();
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003718 CHECK(array_iftable != nullptr);
3719 new_class->SetIfTable(array_iftable);
3720 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003721
Elliott Hughes00626c22013-06-14 15:04:14 -07003722 // Inherit access flags from the component type.
3723 int access_flags = new_class->GetComponentType()->GetAccessFlags();
3724 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
3725 access_flags &= kAccJavaFlagsMask;
3726 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003727 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07003728 access_flags |= kAccAbstract | kAccFinal;
3729 access_flags &= ~kAccInterface;
3730
3731 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003732
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003733 ObjPtr<mirror::Class> existing = InsertClass(descriptor, new_class.Get(), hash);
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003734 if (existing == nullptr) {
Tamas Berghammer160e6df2016-01-05 14:29:02 +00003735 jit::Jit::NewTypeLoadedIfUsingJit(new_class.Get());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003736 return new_class.Get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003737 }
3738 // Another thread must have loaded the class after we
3739 // started but before we finished. Abandon what we've
3740 // done.
3741 //
3742 // (Yes, this happens.)
3743
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003744 return existing.Ptr();
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003745}
3746
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003747mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Ian Rogers62f05122014-03-21 11:21:29 -07003748 switch (type) {
3749 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003750 return GetClassRoot(kPrimitiveByte);
Ian Rogers62f05122014-03-21 11:21:29 -07003751 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003752 return GetClassRoot(kPrimitiveChar);
Ian Rogers62f05122014-03-21 11:21:29 -07003753 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003754 return GetClassRoot(kPrimitiveDouble);
Ian Rogers62f05122014-03-21 11:21:29 -07003755 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003756 return GetClassRoot(kPrimitiveFloat);
Ian Rogers62f05122014-03-21 11:21:29 -07003757 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003758 return GetClassRoot(kPrimitiveInt);
Ian Rogers62f05122014-03-21 11:21:29 -07003759 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003760 return GetClassRoot(kPrimitiveLong);
Ian Rogers62f05122014-03-21 11:21:29 -07003761 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003762 return GetClassRoot(kPrimitiveShort);
Ian Rogers62f05122014-03-21 11:21:29 -07003763 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003764 return GetClassRoot(kPrimitiveBoolean);
Ian Rogers62f05122014-03-21 11:21:29 -07003765 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003766 return GetClassRoot(kPrimitiveVoid);
Ian Rogers62f05122014-03-21 11:21:29 -07003767 default:
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003768 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07003769 }
Elliott Hughesbd935992011-08-22 11:59:34 -07003770 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003771 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003772 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003773}
3774
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003775mirror::Class* ClassLinker::InsertClass(const char* descriptor, ObjPtr<mirror::Class> klass, size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08003776 if (VLOG_IS_ON(class_linker)) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003777 ObjPtr<mirror::DexCache> dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08003778 std::string source;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003779 if (dex_cache != nullptr) {
Brian Carlstromae826982011-11-09 01:33:42 -08003780 source += " from ";
3781 source += dex_cache->GetLocation()->ToModifiedUtf8();
3782 }
3783 LOG(INFO) << "Loaded class " << descriptor << source;
3784 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003785 {
3786 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003787 ObjPtr<mirror::ClassLoader> const class_loader = klass->GetClassLoader();
Mathieu Chartier65975772016-08-05 10:46:36 -07003788 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003789 ObjPtr<mirror::Class> existing = class_table->Lookup(descriptor, hash);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003790 if (existing != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003791 return existing.Ptr();
Mathieu Chartier65975772016-08-05 10:46:36 -07003792 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003793 VerifyObject(klass);
3794 class_table->InsertWithHash(klass, hash);
3795 if (class_loader != nullptr) {
3796 // This is necessary because we need to have the card dirtied for remembered sets.
3797 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
3798 }
Vladimir Marko1998cd02017-01-13 13:02:58 +00003799 if (log_new_roots_) {
Mathieu Chartier65975772016-08-05 10:46:36 -07003800 new_class_roots_.push_back(GcRoot<mirror::Class>(klass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003801 }
3802 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003803 if (kIsDebugBuild) {
3804 // Test that copied methods correctly can find their holder.
3805 for (ArtMethod& method : klass->GetCopiedMethods(image_pointer_size_)) {
3806 CHECK_EQ(GetHoldingClassOfCopiedMethod(&method), klass);
3807 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08003808 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003809 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003810}
3811
Vladimir Marko1998cd02017-01-13 13:02:58 +00003812void ClassLinker::WriteBarrierForBootOatFileBssRoots(const OatFile* oat_file) {
Mathieu Chartiera1467d02017-02-22 09:22:50 -08003813 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3814 DCHECK(!oat_file->GetBssGcRoots().empty()) << oat_file->GetLocation();
3815 if (log_new_roots_ && !ContainsElement(new_bss_roots_boot_oat_files_, oat_file)) {
3816 new_bss_roots_boot_oat_files_.push_back(oat_file);
Vladimir Marko1998cd02017-01-13 13:02:58 +00003817 }
3818}
3819
Alex Lighte64300b2015-12-15 15:02:47 -08003820// TODO This should really be in mirror::Class.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003821void ClassLinker::UpdateClassMethods(ObjPtr<mirror::Class> klass,
Alex Lighte64300b2015-12-15 15:02:47 -08003822 LengthPrefixedArray<ArtMethod>* new_methods) {
3823 klass->SetMethodsPtrUnchecked(new_methods,
3824 klass->NumDirectMethods(),
3825 klass->NumDeclaredVirtualMethods());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003826 // Need to mark the card so that the remembered sets and mod union tables get updated.
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07003827 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003828}
3829
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003830mirror::Class* ClassLinker::LookupClass(Thread* self,
3831 const char* descriptor,
3832 size_t hash,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003833 ObjPtr<mirror::ClassLoader> class_loader) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01003834 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
3835 ClassTable* const class_table = ClassTableForClassLoader(class_loader);
3836 if (class_table != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003837 ObjPtr<mirror::Class> result = class_table->Lookup(descriptor, hash);
Vladimir Marko1a1de672016-10-13 12:53:15 +01003838 if (result != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003839 return result.Ptr();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003840 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07003841 }
Vladimir Marko1a1de672016-10-13 12:53:15 +01003842 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003843}
3844
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003845class MoveClassTableToPreZygoteVisitor : public ClassLoaderVisitor {
3846 public:
3847 explicit MoveClassTableToPreZygoteVisitor() {}
3848
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003849 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003850 REQUIRES(Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003851 REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003852 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier6b069532015-08-05 15:08:12 -07003853 if (class_table != nullptr) {
3854 class_table->FreezeSnapshot();
3855 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07003856 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003857};
3858
3859void ClassLinker::MoveClassTableToPreZygote() {
3860 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3861 boot_class_table_.FreezeSnapshot();
3862 MoveClassTableToPreZygoteVisitor visitor;
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003863 VisitClassLoaders(&visitor);
Mathieu Chartierc2e20622014-11-03 11:41:47 -08003864}
3865
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003866// Look up classes by hash and descriptor and put all matching ones in the result array.
3867class LookupClassesVisitor : public ClassLoaderVisitor {
3868 public:
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003869 LookupClassesVisitor(const char* descriptor,
3870 size_t hash,
3871 std::vector<ObjPtr<mirror::Class>>* result)
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003872 : descriptor_(descriptor),
3873 hash_(hash),
3874 result_(result) {}
3875
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003876 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003877 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003878 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003879 ObjPtr<mirror::Class> klass = class_table->Lookup(descriptor_, hash_);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00003880 // Add `klass` only if `class_loader` is its defining (not just initiating) class loader.
3881 if (klass != nullptr && klass->GetClassLoader() == class_loader) {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003882 result_->push_back(klass);
3883 }
3884 }
3885
3886 private:
3887 const char* const descriptor_;
3888 const size_t hash_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003889 std::vector<ObjPtr<mirror::Class>>* const result_;
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003890};
3891
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003892void ClassLinker::LookupClasses(const char* descriptor,
3893 std::vector<ObjPtr<mirror::Class>>& result) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003894 result.clear();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003895 Thread* const self = Thread::Current();
3896 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003897 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003898 ObjPtr<mirror::Class> klass = boot_class_table_.Lookup(descriptor, hash);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003899 if (klass != nullptr) {
Vladimir Markoc5798bf2016-12-09 10:20:54 +00003900 DCHECK(klass->GetClassLoader() == nullptr);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003901 result.push_back(klass);
3902 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003903 LookupClassesVisitor visitor(descriptor, hash, &result);
3904 VisitClassLoaders(&visitor);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08003905}
3906
Alex Lightf1f10492015-10-07 16:08:36 -07003907bool ClassLinker::AttemptSupertypeVerification(Thread* self,
3908 Handle<mirror::Class> klass,
3909 Handle<mirror::Class> supertype) {
3910 DCHECK(self != nullptr);
Andreas Gampefa4333d2017-02-14 11:10:34 -08003911 DCHECK(klass != nullptr);
3912 DCHECK(supertype != nullptr);
Alex Lightf1f10492015-10-07 16:08:36 -07003913
Alex Lightf1f10492015-10-07 16:08:36 -07003914 if (!supertype->IsVerified() && !supertype->IsErroneous()) {
3915 VerifyClass(self, supertype);
3916 }
Nicolas Geoffray7cc3ae52017-03-07 14:33:37 +00003917
3918 if (supertype->IsVerified() || supertype->ShouldVerifyAtRuntime()) {
3919 // The supertype is either verified, or we soft failed at AOT time.
3920 DCHECK(supertype->IsVerified() || Runtime::Current()->IsAotCompiler());
Alex Lightf1f10492015-10-07 16:08:36 -07003921 return true;
3922 }
3923 // If we got this far then we have a hard failure.
3924 std::string error_msg =
3925 StringPrintf("Rejecting class %s that attempts to sub-type erroneous class %s",
David Sehr709b0702016-10-13 09:12:37 -07003926 klass->PrettyDescriptor().c_str(),
3927 supertype->PrettyDescriptor().c_str());
Alex Lightf1f10492015-10-07 16:08:36 -07003928 LOG(WARNING) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003929 StackHandleScope<1> hs(self);
Alex Lightf1f10492015-10-07 16:08:36 -07003930 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08003931 if (cause != nullptr) {
Alex Lightf1f10492015-10-07 16:08:36 -07003932 // Set during VerifyClass call (if at all).
3933 self->ClearException();
3934 }
3935 // Change into a verify error.
3936 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
Andreas Gampefa4333d2017-02-14 11:10:34 -08003937 if (cause != nullptr) {
Alex Lightf1f10492015-10-07 16:08:36 -07003938 self->GetException()->SetCause(cause.Get());
3939 }
3940 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex());
3941 if (Runtime::Current()->IsAotCompiler()) {
3942 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref);
3943 }
Andreas Gampe884f3b82016-03-30 19:52:58 -07003944 // Need to grab the lock to change status.
3945 ObjectLock<mirror::Class> super_lock(self, klass);
Vladimir Marko72ab6842017-01-20 19:32:50 +00003946 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Alex Lightf1f10492015-10-07 16:08:36 -07003947 return false;
3948}
3949
Andreas Gampecc1b5352016-12-01 16:58:38 -08003950// Ensures that methods have the kAccSkipAccessChecks bit set. We use the
3951// kAccVerificationAttempted bit on the class access flags to determine whether this has been done
3952// before.
3953static void EnsureSkipAccessChecksMethods(Handle<mirror::Class> klass, PointerSize pointer_size)
3954 REQUIRES_SHARED(Locks::mutator_lock_) {
3955 if (!klass->WasVerificationAttempted()) {
3956 klass->SetSkipAccessChecksFlagOnAllMethods(pointer_size);
3957 klass->SetVerificationAttempted();
3958 }
3959}
3960
Nicolas Geoffray08025182016-10-25 17:20:18 +01003961verifier::MethodVerifier::FailureKind ClassLinker::VerifyClass(
3962 Thread* self, Handle<mirror::Class> klass, verifier::HardFailLogMode log_level) {
Andreas Gampe884f3b82016-03-30 19:52:58 -07003963 {
3964 // TODO: assert that the monitor on the Class is held
3965 ObjectLock<mirror::Class> lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08003966
Andreas Gampe884f3b82016-03-30 19:52:58 -07003967 // Is somebody verifying this now?
3968 mirror::Class::Status old_status = klass->GetStatus();
3969 while (old_status == mirror::Class::kStatusVerifying ||
3970 old_status == mirror::Class::kStatusVerifyingAtRuntime) {
3971 lock.WaitIgnoringInterrupts();
Alex Light06039ba2016-04-04 13:23:14 -07003972 CHECK(klass->IsErroneous() || (klass->GetStatus() > old_status))
David Sehr709b0702016-10-13 09:12:37 -07003973 << "Class '" << klass->PrettyClass()
3974 << "' performed an illegal verification state transition from " << old_status
3975 << " to " << klass->GetStatus();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003976 old_status = klass->GetStatus();
3977 }
jeffhao98eacac2011-09-14 16:11:53 -07003978
Andreas Gampe884f3b82016-03-30 19:52:58 -07003979 // The class might already be erroneous, for example at compile time if we attempted to verify
3980 // this class as a parent to another.
3981 if (klass->IsErroneous()) {
3982 ThrowEarlierClassFailure(klass.Get());
Nicolas Geoffray08025182016-10-25 17:20:18 +01003983 return verifier::MethodVerifier::kHardFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003984 }
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08003985
Nicolas Geoffray7cc3ae52017-03-07 14:33:37 +00003986 // Don't attempt to re-verify if already verified.
Andreas Gampe884f3b82016-03-30 19:52:58 -07003987 if (klass->IsVerified()) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08003988 EnsureSkipAccessChecksMethods(klass, image_pointer_size_);
Nicolas Geoffray08025182016-10-25 17:20:18 +01003989 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003990 }
Nicolas Geoffray7cc3ae52017-03-07 14:33:37 +00003991
3992 // For AOT, don't attempt to re-verify if we have already found we should
3993 // verify at runtime.
3994 if (Runtime::Current()->IsAotCompiler() && klass->ShouldVerifyAtRuntime()) {
3995 return verifier::MethodVerifier::kSoftFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003996 }
jeffhao98eacac2011-09-14 16:11:53 -07003997
Andreas Gampe884f3b82016-03-30 19:52:58 -07003998 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
3999 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifying, self);
4000 } else {
4001 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
David Sehr709b0702016-10-13 09:12:37 -07004002 << klass->PrettyClass();
Andreas Gampe884f3b82016-03-30 19:52:58 -07004003 CHECK(!Runtime::Current()->IsAotCompiler());
4004 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifyingAtRuntime, self);
4005 }
4006
4007 // Skip verification if disabled.
4008 if (!Runtime::Current()->IsVerificationEnabled()) {
4009 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Andreas Gampecc1b5352016-12-01 16:58:38 -08004010 EnsureSkipAccessChecksMethods(klass, image_pointer_size_);
Nicolas Geoffray08025182016-10-25 17:20:18 +01004011 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07004012 }
Jeff Hao4a200f52014-04-01 14:58:49 -07004013 }
4014
Ian Rogers9ffb0392012-09-10 11:56:50 -07004015 // Verify super class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004016 StackHandleScope<2> hs(self);
Alex Lightf1f10492015-10-07 16:08:36 -07004017 MutableHandle<mirror::Class> supertype(hs.NewHandle(klass->GetSuperClass()));
4018 // If we have a superclass and we get a hard verification failure we can return immediately.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004019 if (supertype != nullptr && !AttemptSupertypeVerification(self, klass, supertype)) {
Alex Lightf1f10492015-10-07 16:08:36 -07004020 CHECK(self->IsExceptionPending()) << "Verification error should be pending.";
Nicolas Geoffray08025182016-10-25 17:20:18 +01004021 return verifier::MethodVerifier::kHardFailure;
Alex Lightf1f10492015-10-07 16:08:36 -07004022 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08004023
Alex Lightf1f10492015-10-07 16:08:36 -07004024 // Verify all default super-interfaces.
4025 //
4026 // (1) Don't bother if the superclass has already had a soft verification failure.
4027 //
4028 // (2) Interfaces shouldn't bother to do this recursive verification because they cannot cause
4029 // recursive initialization by themselves. This is because when an interface is initialized
4030 // directly it must not initialize its superinterfaces. We are allowed to verify regardless
4031 // but choose not to for an optimization. If the interfaces is being verified due to a class
4032 // initialization (which would need all the default interfaces to be verified) the class code
4033 // will trigger the recursive verification anyway.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004034 if ((supertype == nullptr || supertype->IsVerified()) // See (1)
Alex Lightf1f10492015-10-07 16:08:36 -07004035 && !klass->IsInterface()) { // See (2)
4036 int32_t iftable_count = klass->GetIfTableCount();
4037 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
4038 // Loop through all interfaces this class has defined. It doesn't matter the order.
4039 for (int32_t i = 0; i < iftable_count; i++) {
4040 iface.Assign(klass->GetIfTable()->GetInterface(i));
Andreas Gampefa4333d2017-02-14 11:10:34 -08004041 DCHECK(iface != nullptr);
Alex Lightf1f10492015-10-07 16:08:36 -07004042 // We only care if we have default interfaces and can skip if we are already verified...
4043 if (LIKELY(!iface->HasDefaultMethods() || iface->IsVerified())) {
4044 continue;
4045 } else if (UNLIKELY(!AttemptSupertypeVerification(self, klass, iface))) {
4046 // We had a hard failure while verifying this interface. Just return immediately.
4047 CHECK(self->IsExceptionPending()) << "Verification error should be pending.";
Nicolas Geoffray08025182016-10-25 17:20:18 +01004048 return verifier::MethodVerifier::kHardFailure;
Alex Lightf1f10492015-10-07 16:08:36 -07004049 } else if (UNLIKELY(!iface->IsVerified())) {
4050 // We softly failed to verify the iface. Stop checking and clean up.
4051 // Put the iface into the supertype handle so we know what caused us to fail.
4052 supertype.Assign(iface.Get());
4053 break;
Ian Rogers1c5eb702012-02-01 09:18:34 -08004054 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08004055 }
4056 }
4057
Alex Lightf1f10492015-10-07 16:08:36 -07004058 // At this point if verification failed, then supertype is the "first" supertype that failed
4059 // verification (without a specific order). If verification succeeded, then supertype is either
4060 // null or the original superclass of klass and is verified.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004061 DCHECK(supertype == nullptr ||
Alex Lightf1f10492015-10-07 16:08:36 -07004062 supertype.Get() == klass->GetSuperClass() ||
4063 !supertype->IsVerified());
4064
Elliott Hughes634eb2e2012-03-22 16:06:28 -07004065 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07004066 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004067 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004068 bool preverified = VerifyClassUsingOatFile(dex_file, klass.Get(), oat_file_class_status);
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004069 // If the oat file says the class had an error, re-run the verifier. That way we will get a
4070 // precise error message. To ensure a rerun, test:
Vladimir Marko72ab6842017-01-20 19:32:50 +00004071 // mirror::Class::IsErroneous(oat_file_class_status) => !preverified
4072 DCHECK(!mirror::Class::IsErroneous(oat_file_class_status) || !preverified);
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004073
Ian Rogers62d6c772013-02-27 08:32:07 -08004074 std::string error_msg;
Nicolas Geoffray08025182016-10-25 17:20:18 +01004075 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
jeffhaof1e6b7c2012-06-05 18:33:30 -07004076 if (!preverified) {
Andreas Gampe53e32d12015-12-09 21:03:23 -08004077 Runtime* runtime = Runtime::Current();
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004078 verifier_failure = verifier::MethodVerifier::VerifyClass(self,
4079 klass.Get(),
Andreas Gampe53e32d12015-12-09 21:03:23 -08004080 runtime->GetCompilerCallbacks(),
4081 runtime->IsAotCompiler(),
Andreas Gampe7fe30232016-03-25 16:58:00 -07004082 log_level,
Ian Rogers8b2c0b92013-09-19 02:56:49 -07004083 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07004084 }
Andreas Gampe884f3b82016-03-30 19:52:58 -07004085
4086 // Verification is done, grab the lock again.
4087 ObjectLock<mirror::Class> lock(self, klass);
4088
jeffhaof1e6b7c2012-06-05 18:33:30 -07004089 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07004090 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
David Sehr709b0702016-10-13 09:12:37 -07004091 VLOG(class_linker) << "Soft verification failure in class "
4092 << klass->PrettyDescriptor()
4093 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
4094 << " because: " << error_msg;
Ian Rogers529781d2012-07-23 17:24:29 -07004095 }
Ian Rogers1f539342012-10-03 21:09:42 -07004096 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004097 // Make sure all classes referenced by catch blocks are resolved.
Alex Light5a559862016-01-29 12:24:48 -08004098 ResolveClassExceptionHandlerTypes(klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004099 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Alex Lightf1f10492015-10-07 16:08:36 -07004100 // Even though there were no verifier failures we need to respect whether the super-class and
4101 // super-default-interfaces were verified or requiring runtime reverification.
Andreas Gampefa4333d2017-02-14 11:10:34 -08004102 if (supertype == nullptr || supertype->IsVerified()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004103 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004104 } else {
Alex Lightf1f10492015-10-07 16:08:36 -07004105 CHECK_EQ(supertype->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004106 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
Alex Lightf1f10492015-10-07 16:08:36 -07004107 // Pretend a soft failure occurred so that we don't consider the class verified below.
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004108 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004109 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004110 } else {
4111 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
4112 // Soft failures at compile time should be retried at runtime. Soft
4113 // failures at runtime will be handled by slow paths in the generated
4114 // code. Set status accordingly.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004115 if (Runtime::Current()->IsAotCompiler()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004116 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004117 } else {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004118 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Igor Murashkindf707e42016-02-02 16:56:50 -08004119 // As this is a fake verified status, make sure the methods are _not_ marked
4120 // kAccSkipAccessChecks later.
4121 klass->SetVerificationAttempted();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004122 }
4123 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07004124 } else {
David Sehr709b0702016-10-13 09:12:37 -07004125 VLOG(verifier) << "Verification failed on class " << klass->PrettyDescriptor()
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004126 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
4127 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004128 self->AssertNoPendingException();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004129 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
Vladimir Marko72ab6842017-01-20 19:32:50 +00004130 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07004131 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004132 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004133 // Class is verified so we don't need to do any access check on its methods.
Igor Murashkindf707e42016-02-02 16:56:50 -08004134 // Let the interpreter know it by setting the kAccSkipAccessChecks flag onto each
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004135 // method.
4136 // Note: we're going here during compilation and at runtime. When we set the
Igor Murashkindf707e42016-02-02 16:56:50 -08004137 // kAccSkipAccessChecks flag when compiling image classes, the flag is recorded
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004138 // in the image and is set when loading the image.
Igor Murashkindf707e42016-02-02 16:56:50 -08004139
4140 if (UNLIKELY(Runtime::Current()->IsVerificationSoftFail())) {
4141 // Never skip access checks if the verification soft fail is forced.
4142 // Mark the class as having a verification attempt to avoid re-running the verifier.
4143 klass->SetVerificationAttempted();
4144 } else {
Andreas Gampecc1b5352016-12-01 16:58:38 -08004145 EnsureSkipAccessChecksMethods(klass, image_pointer_size_);
Igor Murashkindf707e42016-02-02 16:56:50 -08004146 }
Andreas Gampe48498592014-09-10 19:48:05 -07004147 }
Nicolas Geoffray08025182016-10-25 17:20:18 +01004148 return verifier_failure;
Andreas Gampe48498592014-09-10 19:48:05 -07004149}
4150
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004151bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004152 ObjPtr<mirror::Class> klass,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004153 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004154 // If we're compiling, we can only verify the class using the oat file if
4155 // we are not compiling the image or if the class we're verifying is not part of
4156 // the app. In other words, we will only check for preverification of bootclasspath
4157 // classes.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004158 if (Runtime::Current()->IsAotCompiler()) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004159 // Are we compiling the bootclasspath?
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07004160 if (Runtime::Current()->GetCompilerCallbacks()->IsBootImage()) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004161 return false;
4162 }
4163 // We are compiling an app (not the image).
4164
4165 // Is this an app class? (I.e. not a bootclasspath class)
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004166 if (klass->GetClassLoader() != nullptr) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004167 return false;
4168 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004169 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004170
Richard Uhler07b3c232015-03-31 15:57:54 -07004171 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004172 // In case we run without an image there won't be a backing oat file.
Mathieu Chartier1b868492016-11-16 16:22:37 -08004173 if (oat_dex_file == nullptr || oat_dex_file->GetOatFile() == nullptr) {
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07004174 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
Narayan Kamath6b2dc312017-03-14 13:26:12 +00004411 CHECK_EQ(klass.Get()->GetProxyInterfaces(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004412 soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces));
Narayan Kamath6b2dc312017-03-14 13:26:12 +00004413 CHECK_EQ(klass.Get()->GetProxyThrows(),
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
Igor Murashkin9d3d7522017-02-27 10:39:49 -08004430 // Find the <init>(InvocationHandler)V method. The exact method offset varies depending
4431 // on which front-end compiler was used to build the libcore DEX files.
4432 ArtMethod* proxy_constructor = GetClassRoot(kJavaLangReflectProxy)->
4433 FindDeclaredDirectMethod("<init>",
4434 "(Ljava/lang/reflect/InvocationHandler;)V",
4435 image_pointer_size_);
4436 DCHECK(proxy_constructor != nullptr)
4437 << "Could not find <init> method in java.lang.reflect.Proxy";
4438
Sebastien Hertzae94e352014-08-27 15:32:56 +02004439 // Ensure constructor is in dex cache so that we can use the dex cache to look up the overridden
4440 // constructor method.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004441 GetClassRoot(kJavaLangReflectProxy)->GetDexCache()->SetResolvedMethod(
Mathieu Chartiere401d142015-04-22 13:56:20 -07004442 proxy_constructor->GetDexMethodIndex(), proxy_constructor, image_pointer_size_);
Jeff Haodb8a6642014-08-14 17:18:52 -07004443 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
4444 // code_ too)
Mathieu Chartiere401d142015-04-22 13:56:20 -07004445 DCHECK(out != nullptr);
4446 out->CopyFrom(proxy_constructor, image_pointer_size_);
Ian Rogers466bb252011-10-14 03:29:56 -07004447 // Make this constructor public and fix the class to be our Proxy version
Mathieu Chartiere401d142015-04-22 13:56:20 -07004448 out->SetAccessFlags((out->GetAccessFlags() & ~kAccProtected) | kAccPublic);
4449 out->SetDeclaringClass(klass.Get());
Ian Rogersc2b44472011-12-14 21:17:17 -08004450}
4451
Mathieu Chartiere401d142015-04-22 13:56:20 -07004452void ClassLinker::CheckProxyConstructor(ArtMethod* constructor) const {
Ian Rogers466bb252011-10-14 03:29:56 -07004453 CHECK(constructor->IsConstructor());
Mathieu Chartiere401d142015-04-22 13:56:20 -07004454 auto* np = constructor->GetInterfaceMethodIfProxy(image_pointer_size_);
4455 CHECK_STREQ(np->GetName(), "<init>");
4456 CHECK_STREQ(np->GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V");
Ian Rogers466bb252011-10-14 03:29:56 -07004457 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04004458}
4459
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004460void ClassLinker::CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004461 ArtMethod* out) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004462 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
4463 // prototype method
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004464 auto* dex_cache = prototype->GetDeclaringClass()->GetDexCache();
4465 // Avoid dirtying the dex cache unless we need to.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004466 if (dex_cache->GetResolvedMethod(prototype->GetDexMethodIndex(), image_pointer_size_) !=
4467 prototype) {
4468 dex_cache->SetResolvedMethod(
4469 prototype->GetDexMethodIndex(), prototype, image_pointer_size_);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004470 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004471 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07004472 // as necessary
Mathieu Chartiere401d142015-04-22 13:56:20 -07004473 DCHECK(out != nullptr);
4474 out->CopyFrom(prototype, image_pointer_size_);
Ian Rogers466bb252011-10-14 03:29:56 -07004475
Alex Lighte9dd04f2016-03-16 16:09:45 -07004476 // Set class to be the concrete proxy class.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004477 out->SetDeclaringClass(klass.Get());
Alex Lighte9dd04f2016-03-16 16:09:45 -07004478 // Clear the abstract, default and conflict flags to ensure that defaults aren't picked in
4479 // preference to the invocation handler.
4480 const uint32_t kRemoveFlags = kAccAbstract | kAccDefault | kAccDefaultConflict;
4481 // Make the method final.
4482 const uint32_t kAddFlags = kAccFinal;
4483 out->SetAccessFlags((out->GetAccessFlags() & ~kRemoveFlags) | kAddFlags);
4484
4485 // Clear the dex_code_item_offset_. It needs to be 0 since proxy methods have no CodeItems but the
4486 // method they copy might (if it's a default method).
4487 out->SetCodeItemOffset(0);
Jesse Wilson95caa792011-10-12 18:14:17 -04004488
Ian Rogers466bb252011-10-14 03:29:56 -07004489 // At runtime the method looks like a reference and argument saving method, clone the code
4490 // related parameters from this method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004491 out->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler());
Ian Rogersc2b44472011-12-14 21:17:17 -08004492}
Jesse Wilson95caa792011-10-12 18:14:17 -04004493
Mathieu Chartiere401d142015-04-22 13:56:20 -07004494void ClassLinker::CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const {
Ian Rogers466bb252011-10-14 03:29:56 -07004495 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004496 CHECK(!prototype->IsFinal());
4497 CHECK(method->IsFinal());
Alex Light9139e002015-10-09 15:59:48 -07004498 CHECK(method->IsInvokable());
Ian Rogers19846512012-02-24 11:42:47 -08004499
4500 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
4501 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
Vladimir Marko05792b92015-08-03 11:56:49 +01004502 CHECK(prototype->HasSameDexCacheResolvedMethods(method, image_pointer_size_));
Mathieu Chartiere401d142015-04-22 13:56:20 -07004503 auto* np = method->GetInterfaceMethodIfProxy(image_pointer_size_);
4504 CHECK_EQ(prototype->GetDeclaringClass()->GetDexCache(), np->GetDexCache());
Ian Rogers19846512012-02-24 11:42:47 -08004505 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
4506
Mathieu Chartiere401d142015-04-22 13:56:20 -07004507 CHECK_STREQ(np->GetName(), prototype->GetName());
4508 CHECK_STREQ(np->GetShorty(), prototype->GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07004509 // More complex sanity - via dex cache
Vladimir Marko942fd312017-01-16 20:52:19 +00004510 CHECK_EQ(np->GetReturnType(true /* resolve */), prototype->GetReturnType(true /* resolve */));
Jesse Wilson95caa792011-10-12 18:14:17 -04004511}
4512
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004513bool ClassLinker::CanWeInitializeClass(ObjPtr<mirror::Class> klass, bool can_init_statics,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004514 bool can_init_parents) {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08004515 if (can_init_statics && can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004516 return true;
4517 }
4518 if (!can_init_statics) {
4519 // Check if there's a class initializer.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004520 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004521 if (clinit != nullptr) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004522 return false;
4523 }
4524 // Check if there are encoded static values needing initialization.
4525 if (klass->NumStaticFields() != 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004526 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004527 DCHECK(dex_class_def != nullptr);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004528 if (dex_class_def->static_values_off_ != 0) {
4529 return false;
4530 }
4531 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004532 // If we are a class we need to initialize all interfaces with default methods when we are
4533 // initialized. Check all of them.
4534 if (!klass->IsInterface()) {
4535 size_t num_interfaces = klass->GetIfTableCount();
4536 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004537 ObjPtr<mirror::Class> iface = klass->GetIfTable()->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07004538 if (iface->HasDefaultMethods() &&
4539 !CanWeInitializeClass(iface, can_init_statics, can_init_parents)) {
4540 return false;
4541 }
4542 }
4543 }
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004544 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07004545 if (klass->IsInterface() || !klass->HasSuperClass()) {
4546 return true;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004547 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004548 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Mathieu Chartiere401d142015-04-22 13:56:20 -07004549 if (!can_init_parents && !super_class->IsInitialized()) {
4550 return false;
4551 }
4552 return CanWeInitializeClass(super_class, can_init_statics, can_init_parents);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004553}
4554
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004555bool ClassLinker::InitializeClass(Thread* self, Handle<mirror::Class> klass,
4556 bool can_init_statics, bool can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004557 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
4558
4559 // Are we already initialized and therefore done?
4560 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
4561 // an initialized class will never change its state.
4562 if (klass->IsInitialized()) {
4563 return true;
4564 }
4565
4566 // Fast fail if initialization requires a full runtime. Not part of the JLS.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004567 if (!CanWeInitializeClass(klass.Get(), can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004568 return false;
4569 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004570
Ian Rogers7b078e82014-09-10 14:44:24 -07004571 self->AllowThreadSuspension();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004572 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004573 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004574 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004575
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004576 // Re-check under the lock in case another thread initialized ahead of us.
4577 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004578 return true;
4579 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004580
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004581 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07004582 if (klass->IsErroneous()) {
Andreas Gampecb086952015-11-02 16:20:00 -08004583 ThrowEarlierClassFailure(klass.Get(), true);
Brian Carlstromb23eab12014-10-08 17:55:21 -07004584 VlogClassInitializationFailure(klass);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004585 return false;
4586 }
4587
Vladimir Marko72ab6842017-01-20 19:32:50 +00004588 CHECK(klass->IsResolved() && !klass->IsErroneousResolved())
4589 << klass->PrettyClass() << ": state=" << klass->GetStatus();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004590
4591 if (!klass->IsVerified()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004592 VerifyClass(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004593 if (!klass->IsVerified()) {
4594 // We failed to verify, expect either the klass to be erroneous or verification failed at
4595 // compile time.
4596 if (klass->IsErroneous()) {
Andreas Gampefc49fa02016-04-21 12:21:55 -07004597 // The class is erroneous. This may be a verifier error, or another thread attempted
4598 // verification and/or initialization and failed. We can distinguish those cases by
4599 // whether an exception is already pending.
4600 if (self->IsExceptionPending()) {
4601 // Check that it's a VerifyError.
4602 DCHECK_EQ("java.lang.Class<java.lang.VerifyError>",
David Sehr709b0702016-10-13 09:12:37 -07004603 mirror::Class::PrettyClass(self->GetException()->GetClass()));
Andreas Gampefc49fa02016-04-21 12:21:55 -07004604 } else {
4605 // Check that another thread attempted initialization.
4606 DCHECK_NE(0, klass->GetClinitThreadId());
4607 DCHECK_NE(self->GetTid(), klass->GetClinitThreadId());
4608 // Need to rethrow the previous failure now.
4609 ThrowEarlierClassFailure(klass.Get(), true);
4610 }
Brian Carlstromb23eab12014-10-08 17:55:21 -07004611 VlogClassInitializationFailure(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004612 } else {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004613 CHECK(Runtime::Current()->IsAotCompiler());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004614 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07004615 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004616 return false;
Mathieu Chartier524507a2014-08-27 15:28:28 -07004617 } else {
4618 self->AssertNoPendingException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004619 }
Andreas Gampefc49fa02016-04-21 12:21:55 -07004620
4621 // A separate thread could have moved us all the way to initialized. A "simple" example
4622 // involves a subclass of the current class being initialized at the same time (which
4623 // will implicitly initialize the superclass, if scheduled that way). b/28254258
Vladimir Marko72ab6842017-01-20 19:32:50 +00004624 DCHECK(!klass->IsErroneous()) << klass->GetStatus();
Andreas Gampefc49fa02016-04-21 12:21:55 -07004625 if (klass->IsInitialized()) {
4626 return true;
4627 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004628 }
4629
Brian Carlstromd1422f82011-09-28 11:37:09 -07004630 // If the class is kStatusInitializing, either this thread is
4631 // initializing higher up the stack or another thread has beat us
4632 // to initializing and we need to wait. Either way, this
4633 // invocation of InitializeClass will not be responsible for
4634 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004635 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Mathieu Chartier524507a2014-08-27 15:28:28 -07004636 // Could have got an exception during verification.
4637 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004638 VlogClassInitializationFailure(klass);
Mathieu Chartier524507a2014-08-27 15:28:28 -07004639 return false;
4640 }
Elliott Hughes005ab2e2011-09-11 17:15:31 -07004641 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07004642 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004643 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004644 return true;
4645 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07004646 // No. That's fine. Wait for another thread to finish initializing.
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004647 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004648 }
4649
4650 if (!ValidateSuperClassDescriptors(klass)) {
Vladimir Marko72ab6842017-01-20 19:32:50 +00004651 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004652 return false;
4653 }
Ian Rogers7b078e82014-09-10 14:44:24 -07004654 self->AllowThreadSuspension();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004655
David Sehr709b0702016-10-13 09:12:37 -07004656 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << klass->PrettyClass()
Andreas Gampe9510ccd2016-04-20 09:55:25 -07004657 << " self.tid=" << self->GetTid() << " clinit.tid=" << klass->GetClinitThreadId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004658
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004659 // From here out other threads may observe that we're initializing and so changes of state
4660 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07004661 klass->SetClinitThreadId(self->GetTid());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004662 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004663
4664 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004665 }
4666
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004667 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004668 if (!klass->IsInterface() && klass->HasSuperClass()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004669 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004670 if (!super_class->IsInitialized()) {
4671 CHECK(!super_class->IsInterface());
4672 CHECK(can_init_parents);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004673 StackHandleScope<1> hs(self);
4674 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class));
Ian Rogers7b078e82014-09-10 14:44:24 -07004675 bool super_initialized = InitializeClass(self, handle_scope_super, can_init_statics, true);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004676 if (!super_initialized) {
4677 // The super class was verified ahead of entering initializing, we should only be here if
4678 // the super class became erroneous due to initialization.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004679 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending())
Brian Carlstromf3632832014-05-20 15:36:53 -07004680 << "Super class initialization failed for "
David Sehr709b0702016-10-13 09:12:37 -07004681 << handle_scope_super->PrettyDescriptor()
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004682 << " that has unexpected status " << handle_scope_super->GetStatus()
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004683 << "\nPending exception:\n"
Nicolas Geoffray14691c52015-03-05 10:40:17 +00004684 << (self->GetException() != nullptr ? self->GetException()->Dump() : "");
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004685 ObjectLock<mirror::Class> lock(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004686 // Initialization failed because the super-class is erroneous.
Vladimir Marko72ab6842017-01-20 19:32:50 +00004687 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004688 return false;
4689 }
Ian Rogers1bddec32012-02-04 12:27:34 -08004690 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004691 }
4692
Alex Lighteb7c1442015-08-31 13:17:42 -07004693 if (!klass->IsInterface()) {
4694 // Initialize interfaces with default methods for the JLS.
4695 size_t num_direct_interfaces = klass->NumDirectInterfaces();
Alex Light56a40f52015-10-14 11:07:41 -07004696 // Only setup the (expensive) handle scope if we actually need to.
4697 if (UNLIKELY(num_direct_interfaces > 0)) {
Alex Lighteb7c1442015-08-31 13:17:42 -07004698 StackHandleScope<1> hs_iface(self);
Alex Light56a40f52015-10-14 11:07:41 -07004699 MutableHandle<mirror::Class> handle_scope_iface(hs_iface.NewHandle<mirror::Class>(nullptr));
4700 for (size_t i = 0; i < num_direct_interfaces; i++) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00004701 handle_scope_iface.Assign(mirror::Class::GetDirectInterface(self, klass.Get(), i));
Vladimir Marko8d6768d2017-03-14 10:13:21 +00004702 CHECK(handle_scope_iface != nullptr) << klass->PrettyDescriptor() << " iface #" << i;
Alex Light56a40f52015-10-14 11:07:41 -07004703 CHECK(handle_scope_iface->IsInterface());
4704 if (handle_scope_iface->HasBeenRecursivelyInitialized()) {
4705 // We have already done this for this interface. Skip it.
4706 continue;
4707 }
4708 // We cannot just call initialize class directly because we need to ensure that ALL
4709 // interfaces with default methods are initialized. Non-default interface initialization
4710 // will not affect other non-default super-interfaces.
4711 bool iface_initialized = InitializeDefaultInterfaceRecursive(self,
4712 handle_scope_iface,
4713 can_init_statics,
4714 can_init_parents);
4715 if (!iface_initialized) {
4716 ObjectLock<mirror::Class> lock(self, klass);
4717 // Initialization failed because one of our interfaces with default methods is erroneous.
Vladimir Marko72ab6842017-01-20 19:32:50 +00004718 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Alex Light56a40f52015-10-14 11:07:41 -07004719 return false;
4720 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004721 }
4722 }
4723 }
4724
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004725 const size_t num_static_fields = klass->NumStaticFields();
4726 if (num_static_fields > 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004727 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004728 CHECK(dex_class_def != nullptr);
Mathieu Chartierf8322842014-05-16 10:59:25 -07004729 const DexFile& dex_file = klass->GetDexFile();
Hiroshi Yamauchi67ef46a2014-08-21 15:59:43 -07004730 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004731 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
Mathieu Chartierf8322842014-05-16 10:59:25 -07004732 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache()));
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004733
4734 // Eagerly fill in static fields so that the we don't have to do as many expensive
4735 // Class::FindStaticField in ResolveField.
4736 for (size_t i = 0; i < num_static_fields; ++i) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004737 ArtField* field = klass->GetStaticField(i);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004738 const uint32_t field_idx = field->GetDexFieldIndex();
Mathieu Chartierc7853442015-03-27 14:35:38 -07004739 ArtField* resolved_field = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004740 if (resolved_field == nullptr) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004741 dex_cache->SetResolvedField(field_idx, field, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07004742 } else {
4743 DCHECK_EQ(field, resolved_field);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004744 }
4745 }
4746
David Sehr9323e6e2016-09-13 08:58:35 -07004747 annotations::RuntimeEncodedStaticFieldValueIterator value_it(dex_file,
4748 &dex_cache,
4749 &class_loader,
4750 this,
4751 *dex_class_def);
Ian Rogers13735952014-10-08 12:43:28 -07004752 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004753 ClassDataItemIterator field_it(dex_file, class_data);
4754 if (value_it.HasNext()) {
4755 DCHECK(field_it.HasNextStaticField());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004756 CHECK(can_init_statics);
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004757 for ( ; value_it.HasNext(); value_it.Next(), field_it.Next()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004758 ArtField* field = ResolveField(
4759 dex_file, field_it.GetMemberIndex(), dex_cache, class_loader, true);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004760 if (Runtime::Current()->IsActiveTransaction()) {
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004761 value_it.ReadValueToField<true>(field);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004762 } else {
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004763 value_it.ReadValueToField<false>(field);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004764 }
Mathieu Chartierda595be2016-08-10 13:57:39 -07004765 if (self->IsExceptionPending()) {
4766 break;
4767 }
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004768 DCHECK(!value_it.HasNext() || field_it.HasNextStaticField());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004769 }
4770 }
4771 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004772
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004773
Mathieu Chartierda595be2016-08-10 13:57:39 -07004774 if (!self->IsExceptionPending()) {
4775 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
4776 if (clinit != nullptr) {
4777 CHECK(can_init_statics);
4778 JValue result;
4779 clinit->Invoke(self, nullptr, 0, &result, "V");
4780 }
4781 }
Ian Rogers7b078e82014-09-10 14:44:24 -07004782 self->AllowThreadSuspension();
Elliott Hughes83df2ac2011-10-11 16:37:54 -07004783 uint64_t t1 = NanoTime();
4784
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004785 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004786 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004787 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004788
4789 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004790 WrapExceptionInInitializer(klass);
Vladimir Marko72ab6842017-01-20 19:32:50 +00004791 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004792 success = false;
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01004793 } else if (Runtime::Current()->IsTransactionAborted()) {
4794 // The exception thrown when the transaction aborted has been caught and cleared
4795 // so we need to throw it again now.
David Sehr709b0702016-10-13 09:12:37 -07004796 VLOG(compiler) << "Return from class initializer of "
4797 << mirror::Class::PrettyDescriptor(klass.Get())
Sebastien Hertzbd9cf9f2015-03-03 12:16:13 +01004798 << " without exception while transaction was aborted: re-throw it now.";
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02004799 Runtime::Current()->ThrowTransactionAbortError(self);
Vladimir Marko72ab6842017-01-20 19:32:50 +00004800 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01004801 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004802 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07004803 RuntimeStats* global_stats = Runtime::Current()->GetStats();
4804 RuntimeStats* thread_stats = self->GetStats();
4805 ++global_stats->class_init_count;
4806 ++thread_stats->class_init_count;
4807 global_stats->class_init_time_ns += (t1 - t0);
4808 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07004809 // Set the class as initialized except if failed to initialize static fields.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004810 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004811 if (VLOG_IS_ON(class_linker)) {
Ian Rogers1ff3c982014-08-12 02:30:58 -07004812 std::string temp;
4813 LOG(INFO) << "Initialized class " << klass->GetDescriptor(&temp) << " from " <<
Mathieu Chartierf8322842014-05-16 10:59:25 -07004814 klass->GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08004815 }
Brian Carlstrom073278c2014-02-19 15:21:21 -08004816 // Opportunistically set static method trampolines to their destination.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004817 FixupStaticTrampolines(klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004818 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004819 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004820 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004821}
4822
Alex Lighteb7c1442015-08-31 13:17:42 -07004823// We recursively run down the tree of interfaces. We need to do this in the order they are declared
4824// and perform the initialization only on those interfaces that contain default methods.
4825bool ClassLinker::InitializeDefaultInterfaceRecursive(Thread* self,
4826 Handle<mirror::Class> iface,
4827 bool can_init_statics,
4828 bool can_init_parents) {
4829 CHECK(iface->IsInterface());
4830 size_t num_direct_ifaces = iface->NumDirectInterfaces();
Alex Light56a40f52015-10-14 11:07:41 -07004831 // Only create the (expensive) handle scope if we need it.
4832 if (UNLIKELY(num_direct_ifaces > 0)) {
4833 StackHandleScope<1> hs(self);
4834 MutableHandle<mirror::Class> handle_super_iface(hs.NewHandle<mirror::Class>(nullptr));
4835 // First we initialize all of iface's super-interfaces recursively.
4836 for (size_t i = 0; i < num_direct_ifaces; i++) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00004837 ObjPtr<mirror::Class> super_iface = mirror::Class::GetDirectInterface(self, iface.Get(), i);
Vladimir Marko8d6768d2017-03-14 10:13:21 +00004838 CHECK(super_iface != nullptr) << iface->PrettyDescriptor() << " iface #" << i;
Alex Light56a40f52015-10-14 11:07:41 -07004839 if (!super_iface->HasBeenRecursivelyInitialized()) {
4840 // Recursive step
4841 handle_super_iface.Assign(super_iface);
4842 if (!InitializeDefaultInterfaceRecursive(self,
4843 handle_super_iface,
4844 can_init_statics,
4845 can_init_parents)) {
4846 return false;
4847 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004848 }
4849 }
4850 }
4851
4852 bool result = true;
4853 // Then we initialize 'iface' if it has default methods. We do not need to (and in fact must not)
4854 // initialize if we don't have default methods.
4855 if (iface->HasDefaultMethods()) {
4856 result = EnsureInitialized(self, iface, can_init_statics, can_init_parents);
4857 }
4858
4859 // Mark that this interface has undergone recursive default interface initialization so we know we
4860 // can skip it on any later class initializations. We do this even if we are not a default
4861 // interface since we can still avoid the traversal. This is purely a performance optimization.
4862 if (result) {
4863 // TODO This should be done in a better way
4864 ObjectLock<mirror::Class> lock(self, iface);
4865 iface->SetRecursivelyInitialized();
4866 }
4867 return result;
4868}
4869
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004870bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass,
4871 Thread* self,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004872 ObjectLock<mirror::Class>& lock)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004873 REQUIRES_SHARED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004874 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004875 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004876 CHECK(!klass->IsInitialized());
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004877 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004878
4879 // When we wake up, repeat the test for init-in-progress. If
4880 // there's an exception pending (only possible if
Brian Carlstromb23eab12014-10-08 17:55:21 -07004881 // we were not using WaitIgnoringInterrupts), bail out.
Brian Carlstromd1422f82011-09-28 11:37:09 -07004882 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004883 WrapExceptionInInitializer(klass);
Vladimir Marko72ab6842017-01-20 19:32:50 +00004884 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorResolved, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004885 return false;
4886 }
4887 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004888 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004889 continue;
4890 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004891 if (klass->GetStatus() == mirror::Class::kStatusVerified &&
4892 Runtime::Current()->IsAotCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07004893 // Compile time initialization failed.
4894 return false;
4895 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07004896 if (klass->IsErroneous()) {
4897 // The caller wants an exception, but it was thrown in a
4898 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07004899 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
David Sehr709b0702016-10-13 09:12:37 -07004900 klass->PrettyDescriptor().c_str());
Brian Carlstromb23eab12014-10-08 17:55:21 -07004901 VlogClassInitializationFailure(klass);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004902 return false;
4903 }
4904 if (klass->IsInitialized()) {
4905 return true;
4906 }
David Sehr709b0702016-10-13 09:12:37 -07004907 LOG(FATAL) << "Unexpected class status. " << klass->PrettyClass() << " is "
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004908 << klass->GetStatus();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004909 }
Ian Rogers07140832014-09-30 15:43:59 -07004910 UNREACHABLE();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004911}
4912
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004913static void ThrowSignatureCheckResolveReturnTypeException(Handle<mirror::Class> klass,
4914 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004915 ArtMethod* method,
4916 ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004917 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004918 DCHECK(Thread::Current()->IsExceptionPending());
4919 DCHECK(!m->IsProxyMethod());
4920 const DexFile* dex_file = m->GetDexFile();
4921 const DexFile::MethodId& method_id = dex_file->GetMethodId(m->GetDexMethodIndex());
4922 const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
Andreas Gampea5b09a62016-11-17 15:21:22 -08004923 dex::TypeIndex return_type_idx = proto_id.return_type_idx_;
David Sehr709b0702016-10-13 09:12:37 -07004924 std::string return_type = dex_file->PrettyType(return_type_idx);
4925 std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004926 ThrowWrappedLinkageError(klass.Get(),
4927 "While checking class %s method %s signature against %s %s: "
4928 "Failed to resolve return type %s with %s",
David Sehr709b0702016-10-13 09:12:37 -07004929 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
4930 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004931 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07004932 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004933 return_type.c_str(), class_loader.c_str());
4934}
4935
4936static void ThrowSignatureCheckResolveArgException(Handle<mirror::Class> klass,
4937 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004938 ArtMethod* method,
4939 ArtMethod* m,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004940 uint32_t index,
Andreas Gampea5b09a62016-11-17 15:21:22 -08004941 dex::TypeIndex arg_type_idx)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004942 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004943 DCHECK(Thread::Current()->IsExceptionPending());
4944 DCHECK(!m->IsProxyMethod());
4945 const DexFile* dex_file = m->GetDexFile();
David Sehr709b0702016-10-13 09:12:37 -07004946 std::string arg_type = dex_file->PrettyType(arg_type_idx);
4947 std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004948 ThrowWrappedLinkageError(klass.Get(),
4949 "While checking class %s method %s signature against %s %s: "
4950 "Failed to resolve arg %u type %s with %s",
David Sehr709b0702016-10-13 09:12:37 -07004951 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
4952 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004953 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07004954 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004955 index, arg_type.c_str(), class_loader.c_str());
4956}
4957
4958static void ThrowSignatureMismatch(Handle<mirror::Class> klass,
4959 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004960 ArtMethod* method,
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004961 const std::string& error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004962 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004963 ThrowLinkageError(klass.Get(),
4964 "Class %s method %s resolves differently in %s %s: %s",
David Sehr709b0702016-10-13 09:12:37 -07004965 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
4966 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004967 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07004968 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004969 error_msg.c_str());
4970}
4971
Ian Rogersb5fb2072014-12-02 17:22:02 -08004972static bool HasSameSignatureWithDifferentClassLoaders(Thread* self,
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004973 Handle<mirror::Class> klass,
4974 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004975 ArtMethod* method1,
4976 ArtMethod* method2)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004977 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersb5fb2072014-12-02 17:22:02 -08004978 {
4979 StackHandleScope<1> hs(self);
Vladimir Marko942fd312017-01-16 20:52:19 +00004980 Handle<mirror::Class> return_type(hs.NewHandle(method1->GetReturnType(true /* resolve */)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08004981 if (UNLIKELY(return_type == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004982 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method1);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004983 return false;
4984 }
Vladimir Marko942fd312017-01-16 20:52:19 +00004985 ObjPtr<mirror::Class> other_return_type = method2->GetReturnType(true /* resolve */);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004986 if (UNLIKELY(other_return_type == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004987 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method2);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004988 return false;
4989 }
Vladimir Marko862f43c2015-02-10 18:22:57 +00004990 if (UNLIKELY(other_return_type != return_type.Get())) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004991 ThrowSignatureMismatch(klass, super_klass, method1,
4992 StringPrintf("Return types mismatch: %s(%p) vs %s(%p)",
David Sehr709b0702016-10-13 09:12:37 -07004993 return_type->PrettyClassAndClassLoader().c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004994 return_type.Get(),
David Sehr709b0702016-10-13 09:12:37 -07004995 other_return_type->PrettyClassAndClassLoader().c_str(),
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004996 other_return_type.Ptr()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08004997 return false;
4998 }
4999 }
5000 const DexFile::TypeList* types1 = method1->GetParameterTypeList();
5001 const DexFile::TypeList* types2 = method2->GetParameterTypeList();
5002 if (types1 == nullptr) {
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005003 if (types2 != nullptr && types2->Size() != 0) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005004 ThrowSignatureMismatch(klass, super_klass, method1,
5005 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07005006 method2->PrettyMethod(true).c_str()));
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005007 return false;
5008 }
5009 return true;
Ian Rogersb5fb2072014-12-02 17:22:02 -08005010 } else if (UNLIKELY(types2 == nullptr)) {
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005011 if (types1->Size() != 0) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005012 ThrowSignatureMismatch(klass, super_klass, method1,
5013 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07005014 method2->PrettyMethod(true).c_str()));
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005015 return false;
5016 }
5017 return true;
Ian Rogersb5fb2072014-12-02 17:22:02 -08005018 }
5019 uint32_t num_types = types1->Size();
5020 if (UNLIKELY(num_types != types2->Size())) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005021 ThrowSignatureMismatch(klass, super_klass, method1,
5022 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07005023 method2->PrettyMethod(true).c_str()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08005024 return false;
5025 }
5026 for (uint32_t i = 0; i < num_types; ++i) {
Vladimir Marko862f43c2015-02-10 18:22:57 +00005027 StackHandleScope<1> hs(self);
Andreas Gampea5b09a62016-11-17 15:21:22 -08005028 dex::TypeIndex param_type_idx = types1->GetTypeItem(i).type_idx_;
Vladimir Marko862f43c2015-02-10 18:22:57 +00005029 Handle<mirror::Class> param_type(hs.NewHandle(
Vladimir Marko942fd312017-01-16 20:52:19 +00005030 method1->GetClassFromTypeIndex(param_type_idx, true /* resolve */)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005031 if (UNLIKELY(param_type == nullptr)) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005032 ThrowSignatureCheckResolveArgException(klass, super_klass, method1,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005033 method1, i, param_type_idx);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005034 return false;
5035 }
Andreas Gampea5b09a62016-11-17 15:21:22 -08005036 dex::TypeIndex other_param_type_idx = types2->GetTypeItem(i).type_idx_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005037 ObjPtr<mirror::Class> other_param_type =
Vladimir Marko942fd312017-01-16 20:52:19 +00005038 method2->GetClassFromTypeIndex(other_param_type_idx, true /* resolve */);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005039 if (UNLIKELY(other_param_type == nullptr)) {
5040 ThrowSignatureCheckResolveArgException(klass, super_klass, method1,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005041 method2, i, other_param_type_idx);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005042 return false;
5043 }
Vladimir Marko862f43c2015-02-10 18:22:57 +00005044 if (UNLIKELY(param_type.Get() != other_param_type)) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005045 ThrowSignatureMismatch(klass, super_klass, method1,
5046 StringPrintf("Parameter %u type mismatch: %s(%p) vs %s(%p)",
5047 i,
David Sehr709b0702016-10-13 09:12:37 -07005048 param_type->PrettyClassAndClassLoader().c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005049 param_type.Get(),
David Sehr709b0702016-10-13 09:12:37 -07005050 other_param_type->PrettyClassAndClassLoader().c_str(),
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005051 other_param_type.Ptr()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08005052 return false;
5053 }
5054 }
5055 return true;
5056}
5057
5058
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005059bool ClassLinker::ValidateSuperClassDescriptors(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005060 if (klass->IsInterface()) {
5061 return true;
5062 }
Ian Rogers151f2212014-05-06 11:27:27 -07005063 // Begin with the methods local to the superclass.
Ian Rogersded66a02014-10-28 18:12:55 -07005064 Thread* self = Thread::Current();
Mathieu Chartiere401d142015-04-22 13:56:20 -07005065 StackHandleScope<1> hs(self);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005066 MutableHandle<mirror::Class> super_klass(hs.NewHandle<mirror::Class>(nullptr));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005067 if (klass->HasSuperClass() &&
5068 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005069 super_klass.Assign(klass->GetSuperClass());
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005070 for (int i = klass->GetSuperClass()->GetVTableLength() - 1; i >= 0; --i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005071 auto* m = klass->GetVTableEntry(i, image_pointer_size_);
5072 auto* super_m = klass->GetSuperClass()->GetVTableEntry(i, image_pointer_size_);
5073 if (m != super_m) {
Vladimir Marko942fd312017-01-16 20:52:19 +00005074 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self,
5075 klass,
5076 super_klass,
5077 m,
5078 super_m))) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005079 self->AssertPendingException();
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005080 return false;
5081 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005082 }
5083 }
5084 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07005085 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005086 super_klass.Assign(klass->GetIfTable()->GetInterface(i));
5087 if (klass->GetClassLoader() != super_klass->GetClassLoader()) {
5088 uint32_t num_methods = super_klass->NumVirtualMethods();
Ian Rogers151f2212014-05-06 11:27:27 -07005089 for (uint32_t j = 0; j < num_methods; ++j) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005090 auto* m = klass->GetIfTable()->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>(
5091 j, image_pointer_size_);
5092 auto* super_m = super_klass->GetVirtualMethod(j, image_pointer_size_);
5093 if (m != super_m) {
Vladimir Marko942fd312017-01-16 20:52:19 +00005094 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self,
5095 klass,
5096 super_klass,
5097 m,
5098 super_m))) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005099 self->AssertPendingException();
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005100 return false;
5101 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005102 }
5103 }
5104 }
5105 }
5106 return true;
5107}
5108
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005109bool ClassLinker::EnsureInitialized(Thread* self,
5110 Handle<mirror::Class> c,
5111 bool can_init_fields,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005112 bool can_init_parents) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08005113 DCHECK(c != nullptr);
Mathieu Chartier524507a2014-08-27 15:28:28 -07005114 if (c->IsInitialized()) {
Andreas Gampecc1b5352016-12-01 16:58:38 -08005115 EnsureSkipAccessChecksMethods(c, image_pointer_size_);
Mathieu Chartier8502f722016-06-08 15:09:08 -07005116 self->AssertNoPendingException();
Mathieu Chartier524507a2014-08-27 15:28:28 -07005117 return true;
5118 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005119 const bool success = InitializeClass(self, c, can_init_fields, can_init_parents);
Mathieu Chartier524507a2014-08-27 15:28:28 -07005120 if (!success) {
5121 if (can_init_fields && can_init_parents) {
David Sehr709b0702016-10-13 09:12:37 -07005122 CHECK(self->IsExceptionPending()) << c->PrettyClass();
Mathieu Chartier524507a2014-08-27 15:28:28 -07005123 }
5124 } else {
5125 self->AssertNoPendingException();
Ian Rogers595799e2012-01-11 17:32:51 -08005126 }
5127 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07005128}
5129
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005130void ClassLinker::FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class,
5131 ObjPtr<mirror::Class> new_class) {
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005132 DCHECK_EQ(temp_class->NumInstanceFields(), 0u);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005133 for (ArtField& field : new_class->GetIFields()) {
5134 if (field.GetDeclaringClass() == temp_class) {
5135 field.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005136 }
5137 }
5138
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005139 DCHECK_EQ(temp_class->NumStaticFields(), 0u);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005140 for (ArtField& field : new_class->GetSFields()) {
5141 if (field.GetDeclaringClass() == temp_class) {
5142 field.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005143 }
5144 }
5145
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005146 DCHECK_EQ(temp_class->NumDirectMethods(), 0u);
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005147 DCHECK_EQ(temp_class->NumVirtualMethods(), 0u);
Alex Lighte64300b2015-12-15 15:02:47 -08005148 for (auto& method : new_class->GetMethods(image_pointer_size_)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005149 if (method.GetDeclaringClass() == temp_class) {
5150 method.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005151 }
5152 }
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005153
5154 // Make sure the remembered set and mod-union tables know that we updated some of the native
5155 // roots.
5156 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005157}
5158
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005159void ClassLinker::RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08005160 CHECK(class_loader->GetAllocator() == nullptr);
5161 CHECK(class_loader->GetClassTable() == nullptr);
5162 Thread* const self = Thread::Current();
5163 ClassLoaderData data;
5164 data.weak_root = self->GetJniEnv()->vm->AddWeakGlobalRef(self, class_loader);
5165 // Create and set the class table.
5166 data.class_table = new ClassTable;
5167 class_loader->SetClassTable(data.class_table);
5168 // Create and set the linear allocator.
5169 data.allocator = Runtime::Current()->CreateLinearAlloc();
5170 class_loader->SetAllocator(data.allocator);
5171 // Add to the list so that we know to free the data later.
5172 class_loaders_.push_back(data);
5173}
5174
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005175ClassTable* ClassLinker::InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07005176 if (class_loader == nullptr) {
5177 return &boot_class_table_;
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005178 }
Mathieu Chartier6b069532015-08-05 15:08:12 -07005179 ClassTable* class_table = class_loader->GetClassTable();
5180 if (class_table == nullptr) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08005181 RegisterClassLoader(class_loader);
5182 class_table = class_loader->GetClassTable();
5183 DCHECK(class_table != nullptr);
Mathieu Chartier6b069532015-08-05 15:08:12 -07005184 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005185 return class_table;
5186}
5187
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005188ClassTable* ClassLinker::ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07005189 return class_loader == nullptr ? &boot_class_table_ : class_loader->GetClassTable();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005190}
5191
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005192static ImTable* FindSuperImt(ObjPtr<mirror::Class> klass, PointerSize pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005193 REQUIRES_SHARED(Locks::mutator_lock_) {
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005194 while (klass->HasSuperClass()) {
5195 klass = klass->GetSuperClass();
5196 if (klass->ShouldHaveImt()) {
5197 return klass->GetImt(pointer_size);
5198 }
5199 }
5200 return nullptr;
5201}
5202
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005203bool ClassLinker::LinkClass(Thread* self,
5204 const char* descriptor,
5205 Handle<mirror::Class> klass,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005206 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005207 MutableHandle<mirror::Class>* h_new_class_out) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005208 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005209
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005210 if (!LinkSuperClass(klass)) {
5211 return false;
5212 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005213 ArtMethod* imt_data[ImTable::kSize];
5214 // If there are any new conflicts compared to super class.
5215 bool new_conflict = false;
5216 std::fill_n(imt_data, arraysize(imt_data), Runtime::Current()->GetImtUnimplementedMethod());
5217 if (!LinkMethods(self, klass, interfaces, &new_conflict, imt_data)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005218 return false;
5219 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005220 if (!LinkInstanceFields(self, klass)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005221 return false;
5222 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005223 size_t class_size;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005224 if (!LinkStaticFields(self, klass, &class_size)) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07005225 return false;
5226 }
5227 CreateReferenceInstanceOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005228 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005229
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005230 ImTable* imt = nullptr;
5231 if (klass->ShouldHaveImt()) {
5232 // If there are any new conflicts compared to the super class we can not make a copy. There
5233 // can be cases where both will have a conflict method at the same slot without having the same
5234 // set of conflicts. In this case, we can not share the IMT since the conflict table slow path
5235 // will possibly create a table that is incorrect for either of the classes.
5236 // Same IMT with new_conflict does not happen very often.
5237 if (!new_conflict) {
5238 ImTable* super_imt = FindSuperImt(klass.Get(), image_pointer_size_);
5239 if (super_imt != nullptr) {
5240 bool imt_equals = true;
5241 for (size_t i = 0; i < ImTable::kSize && imt_equals; ++i) {
5242 imt_equals = imt_equals && (super_imt->Get(i, image_pointer_size_) == imt_data[i]);
5243 }
5244 if (imt_equals) {
5245 imt = super_imt;
5246 }
5247 }
5248 }
5249 if (imt == nullptr) {
5250 LinearAlloc* allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
5251 imt = reinterpret_cast<ImTable*>(
5252 allocator->Alloc(self, ImTable::SizeInBytes(image_pointer_size_)));
5253 if (imt == nullptr) {
5254 return false;
5255 }
5256 imt->Populate(imt_data, image_pointer_size_);
5257 }
5258 }
5259
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005260 if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) {
5261 // We don't need to retire this class as it has no embedded tables or it was created the
5262 // correct size during class linker initialization.
David Sehr709b0702016-10-13 09:12:37 -07005263 CHECK_EQ(klass->GetClassSize(), class_size) << klass->PrettyDescriptor();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005264
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005265 if (klass->ShouldHaveEmbeddedVTable()) {
5266 klass->PopulateEmbeddedVTable(image_pointer_size_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005267 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005268 if (klass->ShouldHaveImt()) {
5269 klass->SetImt(imt, image_pointer_size_);
5270 }
Mingyao Yang063fc772016-08-02 11:02:54 -07005271
5272 // Update CHA info based on whether we override methods.
5273 // Have to do this before setting the class as resolved which allows
5274 // instantiation of klass.
5275 Runtime::Current()->GetClassHierarchyAnalysis()->UpdateAfterLoadingOf(klass);
5276
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005277 // This will notify waiters on klass that saw the not yet resolved
5278 // class in the class_table_ during EnsureResolved.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005279 mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005280 h_new_class_out->Assign(klass.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005281 } else {
5282 CHECK(!klass->IsResolved());
5283 // Retire the temporary class and create the correctly sized resolved class.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005284 StackHandleScope<1> hs(self);
Mathieu Chartiere401d142015-04-22 13:56:20 -07005285 auto h_new_class = hs.NewHandle(klass->CopyOf(self, class_size, imt, image_pointer_size_));
Mathieu Chartier3ee25bb2015-08-10 10:13:02 -07005286 // Set arrays to null since we don't want to have multiple classes with the same ArtField or
5287 // ArtMethod array pointers. If this occurs, it causes bugs in remembered sets since the GC
5288 // may not see any references to the target space and clean the card for a class if another
5289 // class had the same array pointer.
Alex Lighte64300b2015-12-15 15:02:47 -08005290 klass->SetMethodsPtrUnchecked(nullptr, 0, 0);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005291 klass->SetSFieldsPtrUnchecked(nullptr);
5292 klass->SetIFieldsPtrUnchecked(nullptr);
Andreas Gampefa4333d2017-02-14 11:10:34 -08005293 if (UNLIKELY(h_new_class == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005294 self->AssertPendingOOMException();
Vladimir Marko72ab6842017-01-20 19:32:50 +00005295 mirror::Class::SetStatus(klass, mirror::Class::kStatusErrorUnresolved, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005296 return false;
5297 }
5298
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005299 CHECK_EQ(h_new_class->GetClassSize(), class_size);
5300 ObjectLock<mirror::Class> lock(self, h_new_class);
5301 FixupTemporaryDeclaringClass(klass.Get(), h_new_class.Get());
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005302
5303 {
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005304 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005305 ObjPtr<mirror::ClassLoader> const class_loader = h_new_class.Get()->GetClassLoader();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005306 ClassTable* const table = InsertClassTableForClassLoader(class_loader);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005307 ObjPtr<mirror::Class> existing = table->UpdateClass(descriptor, h_new_class.Get(),
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005308 ComputeModifiedUtf8Hash(descriptor));
Mathieu Chartier05aa4d32015-09-19 12:44:38 -07005309 if (class_loader != nullptr) {
5310 // We updated the class in the class table, perform the write barrier so that the GC knows
5311 // about the change.
5312 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
5313 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005314 CHECK_EQ(existing, klass.Get());
Vladimir Marko1998cd02017-01-13 13:02:58 +00005315 if (log_new_roots_) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005316 new_class_roots_.push_back(GcRoot<mirror::Class>(h_new_class.Get()));
5317 }
5318 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005319
Mingyao Yang063fc772016-08-02 11:02:54 -07005320 // Update CHA info based on whether we override methods.
5321 // Have to do this before setting the class as resolved which allows
5322 // instantiation of klass.
5323 Runtime::Current()->GetClassHierarchyAnalysis()->UpdateAfterLoadingOf(h_new_class);
5324
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005325 // This will notify waiters on temp class that saw the not yet resolved class in the
5326 // class_table_ during EnsureResolved.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005327 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetired, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005328
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005329 CHECK_EQ(h_new_class->GetStatus(), mirror::Class::kStatusResolving);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005330 // This will notify waiters on new_class that saw the not yet resolved
5331 // class in the class_table_ during EnsureResolved.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005332 mirror::Class::SetStatus(h_new_class, mirror::Class::kStatusResolved, self);
5333 // Return the new class.
5334 h_new_class_out->Assign(h_new_class.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005335 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005336 return true;
5337}
5338
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005339static void CountMethodsAndFields(ClassDataItemIterator& dex_data,
5340 size_t* virtual_methods,
5341 size_t* direct_methods,
5342 size_t* static_fields,
5343 size_t* instance_fields) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005344 *virtual_methods = *direct_methods = *static_fields = *instance_fields = 0;
5345
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005346 while (dex_data.HasNextStaticField()) {
5347 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005348 (*static_fields)++;
5349 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005350 while (dex_data.HasNextInstanceField()) {
5351 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005352 (*instance_fields)++;
5353 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005354 while (dex_data.HasNextDirectMethod()) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005355 (*direct_methods)++;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005356 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005357 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005358 while (dex_data.HasNextVirtualMethod()) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005359 (*virtual_methods)++;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005360 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005361 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005362 DCHECK(!dex_data.HasNext());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005363}
5364
5365static void DumpClass(std::ostream& os,
5366 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
5367 const char* suffix) {
5368 ClassDataItemIterator dex_data(dex_file, dex_file.GetClassData(dex_class_def));
5369 os << dex_file.GetClassDescriptor(dex_class_def) << suffix << ":\n";
5370 os << " Static fields:\n";
5371 while (dex_data.HasNextStaticField()) {
5372 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex());
5373 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n";
5374 dex_data.Next();
5375 }
5376 os << " Instance fields:\n";
5377 while (dex_data.HasNextInstanceField()) {
5378 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex());
5379 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n";
5380 dex_data.Next();
5381 }
5382 os << " Direct methods:\n";
5383 while (dex_data.HasNextDirectMethod()) {
5384 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex());
5385 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n";
5386 dex_data.Next();
5387 }
5388 os << " Virtual methods:\n";
5389 while (dex_data.HasNextVirtualMethod()) {
5390 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex());
5391 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n";
5392 dex_data.Next();
5393 }
5394}
5395
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005396static std::string DumpClasses(const DexFile& dex_file1,
5397 const DexFile::ClassDef& dex_class_def1,
5398 const DexFile& dex_file2,
5399 const DexFile::ClassDef& dex_class_def2) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005400 std::ostringstream os;
5401 DumpClass(os, dex_file1, dex_class_def1, " (Compile time)");
5402 DumpClass(os, dex_file2, dex_class_def2, " (Runtime)");
5403 return os.str();
5404}
5405
5406
5407// Very simple structural check on whether the classes match. Only compares the number of
5408// methods and fields.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005409static bool SimpleStructuralCheck(const DexFile& dex_file1,
5410 const DexFile::ClassDef& dex_class_def1,
5411 const DexFile& dex_file2,
5412 const DexFile::ClassDef& dex_class_def2,
Andreas Gampefd9eb392014-11-06 16:52:58 -08005413 std::string* error_msg) {
5414 ClassDataItemIterator dex_data1(dex_file1, dex_file1.GetClassData(dex_class_def1));
5415 ClassDataItemIterator dex_data2(dex_file2, dex_file2.GetClassData(dex_class_def2));
5416
5417 // Counters for current dex file.
5418 size_t dex_virtual_methods1, dex_direct_methods1, dex_static_fields1, dex_instance_fields1;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005419 CountMethodsAndFields(dex_data1,
5420 &dex_virtual_methods1,
5421 &dex_direct_methods1,
5422 &dex_static_fields1,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005423 &dex_instance_fields1);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005424 // Counters for compile-time dex file.
5425 size_t dex_virtual_methods2, dex_direct_methods2, dex_static_fields2, dex_instance_fields2;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005426 CountMethodsAndFields(dex_data2,
5427 &dex_virtual_methods2,
5428 &dex_direct_methods2,
5429 &dex_static_fields2,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005430 &dex_instance_fields2);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005431
5432 if (dex_virtual_methods1 != dex_virtual_methods2) {
5433 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005434 *error_msg = StringPrintf("Virtual method count off: %zu vs %zu\n%s",
5435 dex_virtual_methods1,
5436 dex_virtual_methods2,
5437 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005438 return false;
5439 }
5440 if (dex_direct_methods1 != dex_direct_methods2) {
5441 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005442 *error_msg = StringPrintf("Direct method count off: %zu vs %zu\n%s",
5443 dex_direct_methods1,
5444 dex_direct_methods2,
5445 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005446 return false;
5447 }
5448 if (dex_static_fields1 != dex_static_fields2) {
5449 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005450 *error_msg = StringPrintf("Static field count off: %zu vs %zu\n%s",
5451 dex_static_fields1,
5452 dex_static_fields2,
5453 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005454 return false;
5455 }
5456 if (dex_instance_fields1 != dex_instance_fields2) {
5457 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005458 *error_msg = StringPrintf("Instance field count off: %zu vs %zu\n%s",
5459 dex_instance_fields1,
5460 dex_instance_fields2,
5461 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005462 return false;
5463 }
5464
5465 return true;
5466}
5467
5468// Checks whether a the super-class changed from what we had at compile-time. This would
5469// invalidate quickening.
5470static bool CheckSuperClassChange(Handle<mirror::Class> klass,
5471 const DexFile& dex_file,
5472 const DexFile::ClassDef& class_def,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005473 ObjPtr<mirror::Class> super_class)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005474 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005475 // Check for unexpected changes in the superclass.
5476 // Quick check 1) is the super_class class-loader the boot class loader? This always has
5477 // precedence.
5478 if (super_class->GetClassLoader() != nullptr &&
5479 // Quick check 2) different dex cache? Breaks can only occur for different dex files,
5480 // which is implied by different dex cache.
5481 klass->GetDexCache() != super_class->GetDexCache()) {
5482 // Now comes the expensive part: things can be broken if (a) the klass' dex file has a
5483 // definition for the super-class, and (b) the files are in separate oat files. The oat files
5484 // are referenced from the dex file, so do (b) first. Only relevant if we have oat files.
Richard Uhler07b3c232015-03-31 15:57:54 -07005485 const OatDexFile* class_oat_dex_file = dex_file.GetOatDexFile();
5486 const OatFile* class_oat_file = nullptr;
5487 if (class_oat_dex_file != nullptr) {
5488 class_oat_file = class_oat_dex_file->GetOatFile();
5489 }
5490
Andreas Gampefd9eb392014-11-06 16:52:58 -08005491 if (class_oat_file != nullptr) {
Richard Uhler07b3c232015-03-31 15:57:54 -07005492 const OatDexFile* loaded_super_oat_dex_file = super_class->GetDexFile().GetOatDexFile();
5493 const OatFile* loaded_super_oat_file = nullptr;
5494 if (loaded_super_oat_dex_file != nullptr) {
5495 loaded_super_oat_file = loaded_super_oat_dex_file->GetOatFile();
5496 }
5497
Andreas Gampefd9eb392014-11-06 16:52:58 -08005498 if (loaded_super_oat_file != nullptr && class_oat_file != loaded_super_oat_file) {
5499 // Now check (a).
5500 const DexFile::ClassDef* super_class_def = dex_file.FindClassDef(class_def.superclass_idx_);
5501 if (super_class_def != nullptr) {
5502 // Uh-oh, we found something. Do our check.
5503 std::string error_msg;
5504 if (!SimpleStructuralCheck(dex_file, *super_class_def,
5505 super_class->GetDexFile(), *super_class->GetClassDef(),
5506 &error_msg)) {
5507 // Print a warning to the log. This exception might be caught, e.g., as common in test
5508 // drivers. When the class is later tried to be used, we re-throw a new instance, as we
5509 // only save the type of the exception.
5510 LOG(WARNING) << "Incompatible structural change detected: " <<
5511 StringPrintf(
5512 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
David Sehr709b0702016-10-13 09:12:37 -07005513 dex_file.PrettyType(super_class_def->class_idx_).c_str(),
Andreas Gampefd9eb392014-11-06 16:52:58 -08005514 class_oat_file->GetLocation().c_str(),
5515 loaded_super_oat_file->GetLocation().c_str(),
5516 error_msg.c_str());
5517 ThrowIncompatibleClassChangeError(klass.Get(),
5518 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
David Sehr709b0702016-10-13 09:12:37 -07005519 dex_file.PrettyType(super_class_def->class_idx_).c_str(),
Andreas Gampefd9eb392014-11-06 16:52:58 -08005520 class_oat_file->GetLocation().c_str(),
5521 loaded_super_oat_file->GetLocation().c_str(),
5522 error_msg.c_str());
5523 return false;
5524 }
5525 }
5526 }
5527 }
5528 }
5529 return true;
5530}
5531
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005532bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005533 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers8b2c0b92013-09-19 02:56:49 -07005534 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
Andreas Gampea5b09a62016-11-17 15:21:22 -08005535 dex::TypeIndex super_class_idx = class_def.superclass_idx_;
5536 if (super_class_idx.IsValid()) {
Roland Levillain90328ac2016-05-18 12:25:38 +01005537 // Check that a class does not inherit from itself directly.
5538 //
5539 // TODO: This is a cheap check to detect the straightforward case
5540 // of a class extending itself (b/28685551), but we should do a
5541 // proper cycle detection on loaded classes, to detect all cases
5542 // of class circularity errors (b/28830038).
5543 if (super_class_idx == class_def.class_idx_) {
5544 ThrowClassCircularityError(klass.Get(),
5545 "Class %s extends itself",
David Sehr709b0702016-10-13 09:12:37 -07005546 klass->PrettyDescriptor().c_str());
Roland Levillain90328ac2016-05-18 12:25:38 +01005547 return false;
5548 }
5549
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005550 ObjPtr<mirror::Class> super_class = ResolveType(dex_file, super_class_idx, klass.Get());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005551 if (super_class == nullptr) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07005552 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005553 return false;
5554 }
Ian Rogersbe125a92012-01-11 15:19:49 -08005555 // Verify
5556 if (!klass->CanAccess(super_class)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005557 ThrowIllegalAccessError(klass.Get(), "Class %s extended by class %s is inaccessible",
David Sehr709b0702016-10-13 09:12:37 -07005558 super_class->PrettyDescriptor().c_str(),
5559 klass->PrettyDescriptor().c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08005560 return false;
5561 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005562 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005563 klass->SetSuperClass(super_class);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005564
5565 if (!CheckSuperClassChange(klass, dex_file, class_def, super_class)) {
5566 DCHECK(Thread::Current()->IsExceptionPending());
5567 return false;
5568 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005569 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07005570 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005571 if (interfaces != nullptr) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005572 for (size_t i = 0; i < interfaces->Size(); i++) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08005573 dex::TypeIndex idx = interfaces->GetTypeItem(i).type_idx_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005574 ObjPtr<mirror::Class> interface = ResolveType(dex_file, idx, klass.Get());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005575 if (interface == nullptr) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005576 DCHECK(Thread::Current()->IsExceptionPending());
5577 return false;
5578 }
5579 // Verify
5580 if (!klass->CanAccess(interface)) {
5581 // TODO: the RI seemed to ignore this in my testing.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005582 ThrowIllegalAccessError(klass.Get(),
5583 "Interface %s implemented by class %s is inaccessible",
David Sehr709b0702016-10-13 09:12:37 -07005584 interface->PrettyDescriptor().c_str(),
5585 klass->PrettyDescriptor().c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005586 return false;
5587 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005588 }
5589 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07005590 // Mark the class as loaded.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005591 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, nullptr);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005592 return true;
5593}
5594
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005595bool ClassLinker::LinkSuperClass(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005596 CHECK(!klass->IsPrimitive());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005597 ObjPtr<mirror::Class> super = klass->GetSuperClass();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005598 if (klass.Get() == GetClassRoot(kJavaLangObject)) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005599 if (super != nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005600 ThrowClassFormatError(klass.Get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005601 return false;
5602 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005603 return true;
5604 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005605 if (super == nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005606 ThrowLinkageError(klass.Get(), "No superclass defined for class %s",
David Sehr709b0702016-10-13 09:12:37 -07005607 klass->PrettyDescriptor().c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005608 return false;
5609 }
5610 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07005611 if (super->IsFinal() || super->IsInterface()) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005612 ThrowIncompatibleClassChangeError(klass.Get(),
5613 "Superclass %s of %s is %s",
David Sehr709b0702016-10-13 09:12:37 -07005614 super->PrettyDescriptor().c_str(),
5615 klass->PrettyDescriptor().c_str(),
Ian Rogers62d6c772013-02-27 08:32:07 -08005616 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005617 return false;
5618 }
5619 if (!klass->CanAccess(super)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005620 ThrowIllegalAccessError(klass.Get(), "Superclass %s is inaccessible to class %s",
David Sehr709b0702016-10-13 09:12:37 -07005621 super->PrettyDescriptor().c_str(),
5622 klass->PrettyDescriptor().c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005623 return false;
5624 }
Elliott Hughes20cde902011-10-04 17:37:27 -07005625
Brian Carlstromf3632832014-05-20 15:36:53 -07005626 // Inherit kAccClassIsFinalizable from the superclass in case this
5627 // class doesn't override finalize.
Elliott Hughes20cde902011-10-04 17:37:27 -07005628 if (super->IsFinalizable()) {
5629 klass->SetFinalizable();
5630 }
5631
Mathieu Chartiere4275c02015-08-06 15:34:15 -07005632 // Inherit class loader flag form super class.
5633 if (super->IsClassLoaderClass()) {
5634 klass->SetClassLoaderClass();
5635 }
5636
Elliott Hughes2da50362011-10-10 16:57:08 -07005637 // Inherit reference flags (if any) from the superclass.
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07005638 uint32_t reference_flags = (super->GetClassFlags() & mirror::kClassFlagReference);
Elliott Hughes2da50362011-10-10 16:57:08 -07005639 if (reference_flags != 0) {
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07005640 CHECK_EQ(klass->GetClassFlags(), 0u);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07005641 klass->SetClassFlags(klass->GetClassFlags() | reference_flags);
Elliott Hughes2da50362011-10-10 16:57:08 -07005642 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07005643 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07005644 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005645 ThrowLinkageError(klass.Get(),
Ian Rogers62d6c772013-02-27 08:32:07 -08005646 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
David Sehr709b0702016-10-13 09:12:37 -07005647 klass->PrettyDescriptor().c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07005648 return false;
5649 }
Elliott Hughes2da50362011-10-10 16:57:08 -07005650
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005651 if (kIsDebugBuild) {
5652 // Ensure super classes are fully resolved prior to resolving fields..
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005653 while (super != nullptr) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005654 CHECK(super->IsResolved());
5655 super = super->GetSuperClass();
5656 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005657 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005658 return true;
5659}
5660
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005661// Populate the class vtable and itable. Compute return type indices.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005662bool ClassLinker::LinkMethods(Thread* self,
5663 Handle<mirror::Class> klass,
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005664 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005665 bool* out_new_conflict,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005666 ArtMethod** out_imt) {
Ian Rogers7b078e82014-09-10 14:44:24 -07005667 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07005668 // A map from vtable indexes to the method they need to be updated to point to. Used because we
5669 // need to have default methods be in the virtuals array of each class but we don't set that up
5670 // until LinkInterfaceMethods.
Alex Light9139e002015-10-09 15:59:48 -07005671 std::unordered_map<size_t, ClassLinker::MethodTranslation> default_translations;
Alex Lighteb7c1442015-08-31 13:17:42 -07005672 // Link virtual methods then interface methods.
5673 // We set up the interface lookup table first because we need it to determine if we need to update
5674 // any vtable entries with new default method implementations.
5675 return SetupInterfaceLookupTable(self, klass, interfaces)
5676 && LinkVirtualMethods(self, klass, /*out*/ &default_translations)
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005677 && LinkInterfaceMethods(self, klass, default_translations, out_new_conflict, out_imt);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005678}
5679
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005680// Comparator for name and signature of a method, used in finding overriding methods. Implementation
5681// avoids the use of handles, if it didn't then rather than compare dex files we could compare dex
5682// caches in the implementation below.
5683class MethodNameAndSignatureComparator FINAL : public ValueObject {
5684 public:
Mathieu Chartiere401d142015-04-22 13:56:20 -07005685 explicit MethodNameAndSignatureComparator(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005686 REQUIRES_SHARED(Locks::mutator_lock_) :
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005687 dex_file_(method->GetDexFile()), mid_(&dex_file_->GetMethodId(method->GetDexMethodIndex())),
5688 name_(nullptr), name_len_(0) {
David Sehr709b0702016-10-13 09:12:37 -07005689 DCHECK(!method->IsProxyMethod()) << method->PrettyMethod();
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005690 }
5691
5692 const char* GetName() {
5693 if (name_ == nullptr) {
5694 name_ = dex_file_->StringDataAndUtf16LengthByIdx(mid_->name_idx_, &name_len_);
5695 }
5696 return name_;
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005697 }
5698
Mathieu Chartiere401d142015-04-22 13:56:20 -07005699 bool HasSameNameAndSignature(ArtMethod* other)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005700 REQUIRES_SHARED(Locks::mutator_lock_) {
David Sehr709b0702016-10-13 09:12:37 -07005701 DCHECK(!other->IsProxyMethod()) << other->PrettyMethod();
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005702 const DexFile* other_dex_file = other->GetDexFile();
5703 const DexFile::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex());
5704 if (dex_file_ == other_dex_file) {
5705 return mid_->name_idx_ == other_mid.name_idx_ && mid_->proto_idx_ == other_mid.proto_idx_;
5706 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005707 GetName(); // Only used to make sure its calculated.
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005708 uint32_t other_name_len;
5709 const char* other_name = other_dex_file->StringDataAndUtf16LengthByIdx(other_mid.name_idx_,
5710 &other_name_len);
5711 if (name_len_ != other_name_len || strcmp(name_, other_name) != 0) {
5712 return false;
5713 }
5714 return dex_file_->GetMethodSignature(*mid_) == other_dex_file->GetMethodSignature(other_mid);
5715 }
5716
5717 private:
5718 // Dex file for the method to compare against.
5719 const DexFile* const dex_file_;
5720 // MethodId for the method to compare against.
5721 const DexFile::MethodId* const mid_;
5722 // Lazily computed name from the dex file's strings.
5723 const char* name_;
5724 // Lazily computed name length.
5725 uint32_t name_len_;
5726};
5727
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005728class LinkVirtualHashTable {
5729 public:
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005730 LinkVirtualHashTable(Handle<mirror::Class> klass,
5731 size_t hash_size,
5732 uint32_t* hash_table,
Andreas Gampe542451c2016-07-26 09:02:02 -07005733 PointerSize image_pointer_size)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005734 : klass_(klass),
5735 hash_size_(hash_size),
5736 hash_table_(hash_table),
Mathieu Chartiere401d142015-04-22 13:56:20 -07005737 image_pointer_size_(image_pointer_size) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005738 std::fill(hash_table_, hash_table_ + hash_size_, invalid_index_);
5739 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005740
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005741 void Add(uint32_t virtual_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005742 ArtMethod* local_method = klass_->GetVirtualMethodDuringLinking(
5743 virtual_method_index, image_pointer_size_);
5744 const char* name = local_method->GetInterfaceMethodIfProxy(image_pointer_size_)->GetName();
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08005745 uint32_t hash = ComputeModifiedUtf8Hash(name);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005746 uint32_t index = hash % hash_size_;
5747 // Linear probe until we have an empty slot.
5748 while (hash_table_[index] != invalid_index_) {
5749 if (++index == hash_size_) {
5750 index = 0;
5751 }
5752 }
5753 hash_table_[index] = virtual_method_index;
5754 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005755
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005756 uint32_t FindAndRemove(MethodNameAndSignatureComparator* comparator)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005757 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005758 const char* name = comparator->GetName();
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08005759 uint32_t hash = ComputeModifiedUtf8Hash(name);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005760 size_t index = hash % hash_size_;
5761 while (true) {
5762 const uint32_t value = hash_table_[index];
5763 // Since linear probe makes continuous blocks, hitting an invalid index means we are done
5764 // the block and can safely assume not found.
5765 if (value == invalid_index_) {
5766 break;
5767 }
5768 if (value != removed_index_) { // This signifies not already overriden.
Mathieu Chartiere401d142015-04-22 13:56:20 -07005769 ArtMethod* virtual_method =
5770 klass_->GetVirtualMethodDuringLinking(value, image_pointer_size_);
5771 if (comparator->HasSameNameAndSignature(
5772 virtual_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005773 hash_table_[index] = removed_index_;
5774 return value;
5775 }
5776 }
5777 if (++index == hash_size_) {
5778 index = 0;
5779 }
5780 }
5781 return GetNotFoundIndex();
5782 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005783
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005784 static uint32_t GetNotFoundIndex() {
5785 return invalid_index_;
5786 }
5787
5788 private:
5789 static const uint32_t invalid_index_;
5790 static const uint32_t removed_index_;
5791
5792 Handle<mirror::Class> klass_;
5793 const size_t hash_size_;
5794 uint32_t* const hash_table_;
Andreas Gampe542451c2016-07-26 09:02:02 -07005795 const PointerSize image_pointer_size_;
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005796};
5797
5798const uint32_t LinkVirtualHashTable::invalid_index_ = std::numeric_limits<uint32_t>::max();
5799const uint32_t LinkVirtualHashTable::removed_index_ = std::numeric_limits<uint32_t>::max() - 1;
5800
Stephen Hines1ddd9132017-02-08 01:51:18 -08005801bool ClassLinker::LinkVirtualMethods(
Alex Lighteb7c1442015-08-31 13:17:42 -07005802 Thread* self,
5803 Handle<mirror::Class> klass,
Alex Light9139e002015-10-09 15:59:48 -07005804 /*out*/std::unordered_map<size_t, ClassLinker::MethodTranslation>* default_translations) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005805 const size_t num_virtual_methods = klass->NumVirtualMethods();
Alex Lighteb7c1442015-08-31 13:17:42 -07005806 if (klass->IsInterface()) {
5807 // No vtable.
5808 if (!IsUint<16>(num_virtual_methods)) {
5809 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zu", num_virtual_methods);
5810 return false;
5811 }
5812 bool has_defaults = false;
Alex Lighteb7c1442015-08-31 13:17:42 -07005813 // Assign each method an IMT index and set the default flag.
5814 for (size_t i = 0; i < num_virtual_methods; ++i) {
5815 ArtMethod* m = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
5816 m->SetMethodIndex(i);
5817 if (!m->IsAbstract()) {
5818 m->SetAccessFlags(m->GetAccessFlags() | kAccDefault);
5819 has_defaults = true;
5820 }
5821 }
5822 // Mark that we have default methods so that we won't need to scan the virtual_methods_ array
5823 // during initialization. This is a performance optimization. We could simply traverse the
5824 // virtual_methods_ array again during initialization.
5825 if (has_defaults) {
5826 klass->SetHasDefaultMethods();
5827 }
5828 return true;
5829 } else if (klass->HasSuperClass()) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005830 const size_t super_vtable_length = klass->GetSuperClass()->GetVTableLength();
5831 const size_t max_count = num_virtual_methods + super_vtable_length;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005832 StackHandleScope<2> hs(self);
Mingyao Yang38eecb02014-08-13 14:51:03 -07005833 Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass()));
Mathieu Chartiere401d142015-04-22 13:56:20 -07005834 MutableHandle<mirror::PointerArray> vtable;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005835 if (super_class->ShouldHaveEmbeddedVTable()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005836 vtable = hs.NewHandle(AllocPointerArray(self, max_count));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005837 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005838 self->AssertPendingOOMException();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005839 return false;
5840 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005841 for (size_t i = 0; i < super_vtable_length; i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005842 vtable->SetElementPtrSize(
5843 i, super_class->GetEmbeddedVTableEntry(i, image_pointer_size_), image_pointer_size_);
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005844 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005845 // We might need to change vtable if we have new virtual methods or new interfaces (since that
5846 // might give us new default methods). If no new interfaces then we can skip the rest since
5847 // the class cannot override any of the super-class's methods. This is required for
5848 // correctness since without it we might not update overridden default method vtable entries
5849 // correctly.
5850 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005851 klass->SetVTable(vtable.Get());
5852 return true;
5853 }
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005854 } else {
Alex Lighteb7c1442015-08-31 13:17:42 -07005855 DCHECK(super_class->IsAbstract() && !super_class->IsArrayClass());
Mathieu Chartiere401d142015-04-22 13:56:20 -07005856 auto* super_vtable = super_class->GetVTable();
David Sehr709b0702016-10-13 09:12:37 -07005857 CHECK(super_vtable != nullptr) << super_class->PrettyClass();
Alex Lighteb7c1442015-08-31 13:17:42 -07005858 // We might need to change vtable if we have new virtual methods or new interfaces (since that
5859 // might give us new default methods). See comment above.
5860 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005861 klass->SetVTable(super_vtable);
5862 return true;
5863 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005864 vtable = hs.NewHandle(down_cast<mirror::PointerArray*>(
5865 super_vtable->CopyOf(self, max_count)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08005866 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005867 self->AssertPendingOOMException();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005868 return false;
5869 }
Ian Rogersa436fde2013-08-27 23:34:06 -07005870 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005871 // How the algorithm works:
5872 // 1. Populate hash table by adding num_virtual_methods from klass. The values in the hash
5873 // table are: invalid_index for unused slots, index super_vtable_length + i for a virtual
5874 // method which has not been matched to a vtable method, and j if the virtual method at the
5875 // index overrode the super virtual method at index j.
5876 // 2. Loop through super virtual methods, if they overwrite, update hash table to j
5877 // (j < super_vtable_length) to avoid redundant checks. (TODO maybe use this info for reducing
5878 // the need for the initial vtable which we later shrink back down).
5879 // 3. Add non overridden methods to the end of the vtable.
5880 static constexpr size_t kMaxStackHash = 250;
Alex Lighteb7c1442015-08-31 13:17:42 -07005881 // + 1 so that even if we only have new default methods we will still be able to use this hash
5882 // table (i.e. it will never have 0 size).
5883 const size_t hash_table_size = num_virtual_methods * 3 + 1;
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005884 uint32_t* hash_table_ptr;
5885 std::unique_ptr<uint32_t[]> hash_heap_storage;
5886 if (hash_table_size <= kMaxStackHash) {
5887 hash_table_ptr = reinterpret_cast<uint32_t*>(
5888 alloca(hash_table_size * sizeof(*hash_table_ptr)));
5889 } else {
5890 hash_heap_storage.reset(new uint32_t[hash_table_size]);
5891 hash_table_ptr = hash_heap_storage.get();
5892 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005893 LinkVirtualHashTable hash_table(klass, hash_table_size, hash_table_ptr, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005894 // Add virtual methods to the hash table.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005895 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005896 DCHECK(klass->GetVirtualMethodDuringLinking(
5897 i, image_pointer_size_)->GetDeclaringClass() != nullptr);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005898 hash_table.Add(i);
5899 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005900 // 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 -07005901 // the hash table.
5902 for (size_t j = 0; j < super_vtable_length; ++j) {
Alex Lighteb7c1442015-08-31 13:17:42 -07005903 // Search the hash table to see if we are overridden by any method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07005904 ArtMethod* super_method = vtable->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
Alex Lightc7a420c2016-10-18 14:33:18 -07005905 if (!klass->CanAccessMember(super_method->GetDeclaringClass(),
5906 super_method->GetAccessFlags())) {
5907 // Continue on to the next method since this one is package private and canot be overridden.
5908 // Before Android 4.1, the package-private method super_method might have been incorrectly
5909 // overridden.
5910 continue;
5911 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005912 MethodNameAndSignatureComparator super_method_name_comparator(
Mathieu Chartiere401d142015-04-22 13:56:20 -07005913 super_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Lightc7a420c2016-10-18 14:33:18 -07005914 // We remove the method so that subsequent lookups will be faster by making the hash-map
5915 // smaller as we go on.
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005916 uint32_t hash_index = hash_table.FindAndRemove(&super_method_name_comparator);
5917 if (hash_index != hash_table.GetNotFoundIndex()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005918 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(
5919 hash_index, image_pointer_size_);
Alex Lightc7a420c2016-10-18 14:33:18 -07005920 if (super_method->IsFinal()) {
5921 ThrowLinkageError(klass.Get(), "Method %s overrides final method in class %s",
5922 virtual_method->PrettyMethod().c_str(),
5923 super_method->GetDeclaringClassDescriptor());
5924 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005925 }
Alex Lightc7a420c2016-10-18 14:33:18 -07005926 vtable->SetElementPtrSize(j, virtual_method, image_pointer_size_);
5927 virtual_method->SetMethodIndex(j);
Alex Light9139e002015-10-09 15:59:48 -07005928 } else if (super_method->IsOverridableByDefaultMethod()) {
Alex Lighteb7c1442015-08-31 13:17:42 -07005929 // We didn't directly override this method but we might through default methods...
5930 // Check for default method update.
5931 ArtMethod* default_method = nullptr;
Alex Light9139e002015-10-09 15:59:48 -07005932 switch (FindDefaultMethodImplementation(self,
5933 super_method,
5934 klass,
5935 /*out*/&default_method)) {
5936 case DefaultMethodSearchResult::kDefaultConflict: {
5937 // A conflict was found looking for default methods. Note this (assuming it wasn't
5938 // pre-existing) in the translations map.
5939 if (UNLIKELY(!super_method->IsDefaultConflicting())) {
5940 // Don't generate another conflict method to reduce memory use as an optimization.
5941 default_translations->insert(
5942 {j, ClassLinker::MethodTranslation::CreateConflictingMethod()});
5943 }
5944 break;
5945 }
5946 case DefaultMethodSearchResult::kAbstractFound: {
5947 // No conflict but method is abstract.
5948 // We note that this vtable entry must be made abstract.
5949 if (UNLIKELY(!super_method->IsAbstract())) {
5950 default_translations->insert(
5951 {j, ClassLinker::MethodTranslation::CreateAbstractMethod()});
5952 }
5953 break;
5954 }
5955 case DefaultMethodSearchResult::kDefaultFound: {
5956 if (UNLIKELY(super_method->IsDefaultConflicting() ||
5957 default_method->GetDeclaringClass() != super_method->GetDeclaringClass())) {
5958 // Found a default method implementation that is new.
5959 // TODO Refactor this add default methods to virtuals here and not in
5960 // LinkInterfaceMethods maybe.
5961 // The problem is default methods might override previously present
5962 // default-method or miranda-method vtable entries from the superclass.
5963 // Unfortunately we need these to be entries in this class's virtuals. We do not
5964 // give these entries there until LinkInterfaceMethods so we pass this map around
5965 // to let it know which vtable entries need to be updated.
5966 // Make a note that vtable entry j must be updated, store what it needs to be updated
5967 // to. We will allocate a virtual method slot in LinkInterfaceMethods and fix it up
5968 // then.
5969 default_translations->insert(
5970 {j, ClassLinker::MethodTranslation::CreateTranslatedMethod(default_method)});
David Sehr709b0702016-10-13 09:12:37 -07005971 VLOG(class_linker) << "Method " << super_method->PrettyMethod()
5972 << " overridden by default "
5973 << default_method->PrettyMethod()
5974 << " in " << mirror::Class::PrettyClass(klass.Get());
Alex Light9139e002015-10-09 15:59:48 -07005975 }
5976 break;
5977 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005978 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005979 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005980 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005981 size_t actual_count = super_vtable_length;
Alex Lighteb7c1442015-08-31 13:17:42 -07005982 // Add the non-overridden methods at the end.
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005983 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005984 ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005985 size_t method_idx = local_method->GetMethodIndexDuringLinking();
5986 if (method_idx < super_vtable_length &&
Mathieu Chartiere401d142015-04-22 13:56:20 -07005987 local_method == vtable->GetElementPtrSize<ArtMethod*>(method_idx, image_pointer_size_)) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005988 continue;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005989 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005990 vtable->SetElementPtrSize(actual_count, local_method, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005991 local_method->SetMethodIndex(actual_count);
5992 ++actual_count;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005993 }
Andreas Gampeab1eb0d2015-02-13 19:23:55 -08005994 if (!IsUint<16>(actual_count)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005995 ThrowClassFormatError(klass.Get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005996 return false;
5997 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005998 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005999 CHECK_LE(actual_count, max_count);
6000 if (actual_count < max_count) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006001 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, actual_count)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006002 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006003 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006004 return false;
6005 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006006 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07006007 klass->SetVTable(vtable.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006008 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07006009 CHECK_EQ(klass.Get(), GetClassRoot(kJavaLangObject));
Andreas Gampeab1eb0d2015-02-13 19:23:55 -08006010 if (!IsUint<16>(num_virtual_methods)) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006011 ThrowClassFormatError(klass.Get(), "Too many methods: %d",
6012 static_cast<int>(num_virtual_methods));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006013 return false;
6014 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07006015 auto* vtable = AllocPointerArray(self, num_virtual_methods);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006016 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006017 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006018 return false;
6019 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07006020 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006021 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
6022 vtable->SetElementPtrSize(i, virtual_method, image_pointer_size_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07006023 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006024 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006025 klass->SetVTable(vtable);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006026 }
6027 return true;
6028}
6029
Alex Light9139e002015-10-09 15:59:48 -07006030// Determine if the given iface has any subinterface in the given list that declares the method
6031// specified by 'target'.
6032//
6033// Arguments
6034// - self: The thread we are running on
6035// - target: A comparator that will match any method that overrides the method we are checking for
6036// - iftable: The iftable we are searching for an overriding method on.
6037// - ifstart: The index of the interface we are checking to see if anything overrides
6038// - iface: The interface we are checking to see if anything overrides.
6039// - image_pointer_size:
6040// The image pointer size.
6041//
6042// Returns
6043// - True: There is some method that matches the target comparator defined in an interface that
6044// is a subtype of iface.
6045// - False: There is no method that matches the target comparator in any interface that is a subtype
6046// of iface.
6047static bool ContainsOverridingMethodOf(Thread* self,
6048 MethodNameAndSignatureComparator& target,
6049 Handle<mirror::IfTable> iftable,
6050 size_t ifstart,
6051 Handle<mirror::Class> iface,
Andreas Gampe542451c2016-07-26 09:02:02 -07006052 PointerSize image_pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006053 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light9139e002015-10-09 15:59:48 -07006054 DCHECK(self != nullptr);
Andreas Gampefa4333d2017-02-14 11:10:34 -08006055 DCHECK(iface != nullptr);
6056 DCHECK(iftable != nullptr);
Alex Light9139e002015-10-09 15:59:48 -07006057 DCHECK_GE(ifstart, 0u);
6058 DCHECK_LT(ifstart, iftable->Count());
6059 DCHECK_EQ(iface.Get(), iftable->GetInterface(ifstart));
6060 DCHECK(iface->IsInterface());
6061
6062 size_t iftable_count = iftable->Count();
6063 StackHandleScope<1> hs(self);
6064 MutableHandle<mirror::Class> current_iface(hs.NewHandle<mirror::Class>(nullptr));
6065 for (size_t k = ifstart + 1; k < iftable_count; k++) {
6066 // Skip ifstart since our current interface obviously cannot override itself.
6067 current_iface.Assign(iftable->GetInterface(k));
Alex Lighte64300b2015-12-15 15:02:47 -08006068 // Iterate through every method on this interface. The order does not matter.
6069 for (ArtMethod& current_method : current_iface->GetDeclaredVirtualMethods(image_pointer_size)) {
Alex Light9139e002015-10-09 15:59:48 -07006070 if (UNLIKELY(target.HasSameNameAndSignature(
Alex Lighte64300b2015-12-15 15:02:47 -08006071 current_method.GetInterfaceMethodIfProxy(image_pointer_size)))) {
Alex Light9139e002015-10-09 15:59:48 -07006072 // Check if the i'th interface is a subtype of this one.
6073 if (iface->IsAssignableFrom(current_iface.Get())) {
6074 return true;
6075 }
6076 break;
6077 }
6078 }
6079 }
6080 return false;
6081}
6082
Alex Lighteb7c1442015-08-31 13:17:42 -07006083// Find the default method implementation for 'interface_method' in 'klass'. Stores it into
Alex Light9139e002015-10-09 15:59:48 -07006084// out_default_method and returns kDefaultFound on success. If no default method was found return
6085// kAbstractFound and store nullptr into out_default_method. If an error occurs (such as a
6086// default_method conflict) it will return kDefaultConflict.
6087ClassLinker::DefaultMethodSearchResult ClassLinker::FindDefaultMethodImplementation(
6088 Thread* self,
6089 ArtMethod* target_method,
6090 Handle<mirror::Class> klass,
6091 /*out*/ArtMethod** out_default_method) const {
Alex Lighteb7c1442015-08-31 13:17:42 -07006092 DCHECK(self != nullptr);
6093 DCHECK(target_method != nullptr);
6094 DCHECK(out_default_method != nullptr);
Alex Lighteb7c1442015-08-31 13:17:42 -07006095
6096 *out_default_method = nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006097
6098 // We organize the interface table so that, for interface I any subinterfaces J follow it in the
6099 // table. This lets us walk the table backwards when searching for default methods. The first one
6100 // we encounter is the best candidate since it is the most specific. Once we have found it we keep
6101 // track of it and then continue checking all other interfaces, since we need to throw an error if
6102 // we encounter conflicting default method implementations (one is not a subtype of the other).
6103 //
6104 // The order of unrelated interfaces does not matter and is not defined.
6105 size_t iftable_count = klass->GetIfTableCount();
6106 if (iftable_count == 0) {
Alex Light9139e002015-10-09 15:59:48 -07006107 // No interfaces. We have already reset out to null so just return kAbstractFound.
6108 return DefaultMethodSearchResult::kAbstractFound;
Alex Lighteb7c1442015-08-31 13:17:42 -07006109 }
6110
Alex Light9139e002015-10-09 15:59:48 -07006111 StackHandleScope<3> hs(self);
6112 MutableHandle<mirror::Class> chosen_iface(hs.NewHandle<mirror::Class>(nullptr));
Alex Lighteb7c1442015-08-31 13:17:42 -07006113 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable()));
Alex Light9139e002015-10-09 15:59:48 -07006114 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
Alex Lighteb7c1442015-08-31 13:17:42 -07006115 MethodNameAndSignatureComparator target_name_comparator(
6116 target_method->GetInterfaceMethodIfProxy(image_pointer_size_));
6117 // Iterates over the klass's iftable in reverse
Alex Light9139e002015-10-09 15:59:48 -07006118 for (size_t k = iftable_count; k != 0; ) {
6119 --k;
6120
Alex Lighteb7c1442015-08-31 13:17:42 -07006121 DCHECK_LT(k, iftable->Count());
Alex Light9139e002015-10-09 15:59:48 -07006122
6123 iface.Assign(iftable->GetInterface(k));
Alex Lighte64300b2015-12-15 15:02:47 -08006124 // Iterate through every declared method on this interface. The order does not matter.
6125 for (auto& method_iter : iface->GetDeclaredVirtualMethods(image_pointer_size_)) {
6126 ArtMethod* current_method = &method_iter;
Alex Lighteb7c1442015-08-31 13:17:42 -07006127 // Skip abstract methods and methods with different names.
6128 if (current_method->IsAbstract() ||
6129 !target_name_comparator.HasSameNameAndSignature(
6130 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
6131 continue;
Alex Lightd7c10c22016-03-31 10:03:07 -07006132 } else if (!current_method->IsPublic()) {
6133 // The verifier should have caught the non-public method for dex version 37. Just warn and
6134 // skip it since this is from before default-methods so we don't really need to care that it
6135 // has code.
David Sehr709b0702016-10-13 09:12:37 -07006136 LOG(WARNING) << "Interface method " << current_method->PrettyMethod()
6137 << " is not public! "
Alex Lightd7c10c22016-03-31 10:03:07 -07006138 << "This will be a fatal error in subsequent versions of android. "
6139 << "Continuing anyway.";
Alex Lighteb7c1442015-08-31 13:17:42 -07006140 }
Andreas Gampefa4333d2017-02-14 11:10:34 -08006141 if (UNLIKELY(chosen_iface != nullptr)) {
Alex Light9139e002015-10-09 15:59:48 -07006142 // We have multiple default impls of the same method. This is a potential default conflict.
6143 // We need to check if this possibly conflicting method is either a superclass of the chosen
6144 // default implementation or is overridden by a non-default interface method. In either case
6145 // there is no conflict.
6146 if (!iface->IsAssignableFrom(chosen_iface.Get()) &&
6147 !ContainsOverridingMethodOf(self,
6148 target_name_comparator,
6149 iftable,
6150 k,
6151 iface,
6152 image_pointer_size_)) {
Nicolas Geoffray7f3e0db2016-01-28 09:29:31 +00006153 VLOG(class_linker) << "Conflicting default method implementations found: "
David Sehr709b0702016-10-13 09:12:37 -07006154 << current_method->PrettyMethod() << " and "
6155 << ArtMethod::PrettyMethod(*out_default_method) << " in class "
6156 << klass->PrettyClass() << " conflict.";
Alex Light9139e002015-10-09 15:59:48 -07006157 *out_default_method = nullptr;
6158 return DefaultMethodSearchResult::kDefaultConflict;
Alex Lighteb7c1442015-08-31 13:17:42 -07006159 } else {
6160 break; // Continue checking at the next interface.
6161 }
6162 } else {
Alex Light9139e002015-10-09 15:59:48 -07006163 // chosen_iface == null
6164 if (!ContainsOverridingMethodOf(self,
6165 target_name_comparator,
6166 iftable,
6167 k,
6168 iface,
6169 image_pointer_size_)) {
6170 // Don't set this as the chosen interface if something else is overriding it (because that
6171 // other interface would be potentially chosen instead if it was default). If the other
6172 // interface was abstract then we wouldn't select this interface as chosen anyway since
6173 // the abstract method masks it.
6174 *out_default_method = current_method;
6175 chosen_iface.Assign(iface.Get());
6176 // We should now finish traversing the graph to find if we have default methods that
6177 // conflict.
6178 } else {
David Sehr709b0702016-10-13 09:12:37 -07006179 VLOG(class_linker) << "A default method '" << current_method->PrettyMethod()
6180 << "' was "
6181 << "skipped because it was overridden by an abstract method in a "
6182 << "subinterface on class '" << klass->PrettyClass() << "'";
Alex Light9139e002015-10-09 15:59:48 -07006183 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006184 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006185 break;
6186 }
6187 }
Alex Light9139e002015-10-09 15:59:48 -07006188 if (*out_default_method != nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07006189 VLOG(class_linker) << "Default method '" << (*out_default_method)->PrettyMethod()
6190 << "' selected "
6191 << "as the implementation for '" << target_method->PrettyMethod()
6192 << "' in '" << klass->PrettyClass() << "'";
Alex Light9139e002015-10-09 15:59:48 -07006193 return DefaultMethodSearchResult::kDefaultFound;
6194 } else {
6195 return DefaultMethodSearchResult::kAbstractFound;
6196 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006197}
6198
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006199ArtMethod* ClassLinker::AddMethodToConflictTable(ObjPtr<mirror::Class> klass,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006200 ArtMethod* conflict_method,
6201 ArtMethod* interface_method,
6202 ArtMethod* method,
6203 bool force_new_conflict_method) {
Andreas Gampe542451c2016-07-26 09:02:02 -07006204 ImtConflictTable* current_table = conflict_method->GetImtConflictTable(kRuntimePointerSize);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006205 Runtime* const runtime = Runtime::Current();
6206 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
6207 bool new_entry = conflict_method == runtime->GetImtConflictMethod() || force_new_conflict_method;
6208
6209 // Create a new entry if the existing one is the shared conflict method.
6210 ArtMethod* new_conflict_method = new_entry
6211 ? runtime->CreateImtConflictMethod(linear_alloc)
6212 : conflict_method;
6213
6214 // Allocate a new table. Note that we will leak this table at the next conflict,
6215 // but that's a tradeoff compared to making the table fixed size.
6216 void* data = linear_alloc->Alloc(
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006217 Thread::Current(), ImtConflictTable::ComputeSizeWithOneMoreEntry(current_table,
6218 image_pointer_size_));
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006219 if (data == nullptr) {
6220 LOG(ERROR) << "Failed to allocate conflict table";
6221 return conflict_method;
6222 }
6223 ImtConflictTable* new_table = new (data) ImtConflictTable(current_table,
6224 interface_method,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006225 method,
6226 image_pointer_size_);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006227
6228 // Do a fence to ensure threads see the data in the table before it is assigned
6229 // to the conflict method.
6230 // Note that there is a race in the presence of multiple threads and we may leak
6231 // memory from the LinearAlloc, but that's a tradeoff compared to using
6232 // atomic operations.
6233 QuasiAtomic::ThreadFenceRelease();
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006234 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006235 return new_conflict_method;
6236}
6237
Vladimir Marko921094a2017-01-12 18:37:06 +00006238bool ClassLinker::AllocateIfTableMethodArrays(Thread* self,
6239 Handle<mirror::Class> klass,
6240 Handle<mirror::IfTable> iftable) {
6241 DCHECK(!klass->IsInterface());
6242 const bool has_superclass = klass->HasSuperClass();
6243 const bool extend_super_iftable = has_superclass;
6244 const size_t ifcount = klass->GetIfTableCount();
6245 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
6246 for (size_t i = 0; i < ifcount; ++i) {
6247 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods();
6248 if (num_methods > 0) {
6249 const bool is_super = i < super_ifcount;
6250 // This is an interface implemented by a super-class. Therefore we can just copy the method
6251 // array from the superclass.
6252 const bool super_interface = is_super && extend_super_iftable;
6253 ObjPtr<mirror::PointerArray> method_array;
6254 if (super_interface) {
6255 ObjPtr<mirror::IfTable> if_table = klass->GetSuperClass()->GetIfTable();
6256 DCHECK(if_table != nullptr);
6257 DCHECK(if_table->GetMethodArray(i) != nullptr);
6258 // If we are working on a super interface, try extending the existing method array.
6259 method_array = down_cast<mirror::PointerArray*>(if_table->GetMethodArray(i)->Clone(self));
6260 } else {
6261 method_array = AllocPointerArray(self, num_methods);
6262 }
6263 if (UNLIKELY(method_array == nullptr)) {
6264 self->AssertPendingOOMException();
6265 return false;
6266 }
6267 iftable->SetMethodArray(i, method_array);
6268 }
6269 }
6270 return true;
6271}
6272
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006273void ClassLinker::SetIMTRef(ArtMethod* unimplemented_method,
6274 ArtMethod* imt_conflict_method,
6275 ArtMethod* current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006276 /*out*/bool* new_conflict,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006277 /*out*/ArtMethod** imt_ref) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006278 // Place method in imt if entry is empty, place conflict otherwise.
6279 if (*imt_ref == unimplemented_method) {
6280 *imt_ref = current_method;
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006281 } else if (!(*imt_ref)->IsRuntimeMethod()) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006282 // If we are not a conflict and we have the same signature and name as the imt
6283 // entry, it must be that we overwrote a superclass vtable entry.
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006284 // Note that we have checked IsRuntimeMethod, as there may be multiple different
6285 // conflict methods.
Alex Lighteb7c1442015-08-31 13:17:42 -07006286 MethodNameAndSignatureComparator imt_comparator(
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006287 (*imt_ref)->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Lighteb7c1442015-08-31 13:17:42 -07006288 if (imt_comparator.HasSameNameAndSignature(
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006289 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006290 *imt_ref = current_method;
6291 } else {
Alex Light9139e002015-10-09 15:59:48 -07006292 *imt_ref = imt_conflict_method;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006293 *new_conflict = true;
Alex Lighteb7c1442015-08-31 13:17:42 -07006294 }
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006295 } else {
6296 // Place the default conflict method. Note that there may be an existing conflict
6297 // method in the IMT, but it could be one tailored to the super class, with a
6298 // specific ImtConflictTable.
6299 *imt_ref = imt_conflict_method;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006300 *new_conflict = true;
Alex Lighteb7c1442015-08-31 13:17:42 -07006301 }
6302}
6303
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006304void ClassLinker::FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) {
David Sehr709b0702016-10-13 09:12:37 -07006305 DCHECK(klass->ShouldHaveImt()) << klass->PrettyClass();
6306 DCHECK(!klass->IsTemp()) << klass->PrettyClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006307 ArtMethod* imt_data[ImTable::kSize];
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006308 Runtime* const runtime = Runtime::Current();
6309 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
6310 ArtMethod* const conflict_method = runtime->GetImtConflictMethod();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006311 std::fill_n(imt_data, arraysize(imt_data), unimplemented_method);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006312 if (klass->GetIfTable() != nullptr) {
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006313 bool new_conflict = false;
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006314 FillIMTFromIfTable(klass->GetIfTable(),
6315 unimplemented_method,
6316 conflict_method,
6317 klass,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006318 /*create_conflict_tables*/true,
6319 /*ignore_copied_methods*/false,
6320 &new_conflict,
6321 &imt_data[0]);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006322 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006323 if (!klass->ShouldHaveImt()) {
6324 return;
6325 }
6326 // Compare the IMT with the super class including the conflict methods. If they are equivalent,
6327 // we can just use the same pointer.
6328 ImTable* imt = nullptr;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006329 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006330 if (super_class != nullptr && super_class->ShouldHaveImt()) {
6331 ImTable* super_imt = super_class->GetImt(image_pointer_size_);
6332 bool same = true;
6333 for (size_t i = 0; same && i < ImTable::kSize; ++i) {
6334 ArtMethod* method = imt_data[i];
6335 ArtMethod* super_method = super_imt->Get(i, image_pointer_size_);
6336 if (method != super_method) {
6337 bool is_conflict_table = method->IsRuntimeMethod() &&
6338 method != unimplemented_method &&
6339 method != conflict_method;
6340 // Verify conflict contents.
6341 bool super_conflict_table = super_method->IsRuntimeMethod() &&
6342 super_method != unimplemented_method &&
6343 super_method != conflict_method;
6344 if (!is_conflict_table || !super_conflict_table) {
6345 same = false;
6346 } else {
6347 ImtConflictTable* table1 = method->GetImtConflictTable(image_pointer_size_);
6348 ImtConflictTable* table2 = super_method->GetImtConflictTable(image_pointer_size_);
6349 same = same && table1->Equals(table2, image_pointer_size_);
6350 }
6351 }
6352 }
6353 if (same) {
6354 imt = super_imt;
6355 }
6356 }
6357 if (imt == nullptr) {
6358 imt = klass->GetImt(image_pointer_size_);
6359 DCHECK(imt != nullptr);
6360 imt->Populate(imt_data, image_pointer_size_);
6361 } else {
6362 klass->SetImt(imt, image_pointer_size_);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006363 }
6364}
6365
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006366ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count,
6367 LinearAlloc* linear_alloc,
Andreas Gampe542451c2016-07-26 09:02:02 -07006368 PointerSize image_pointer_size) {
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006369 void* data = linear_alloc->Alloc(Thread::Current(),
6370 ImtConflictTable::ComputeSize(count,
6371 image_pointer_size));
6372 return (data != nullptr) ? new (data) ImtConflictTable(count, image_pointer_size) : nullptr;
6373}
6374
6375ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc) {
6376 return CreateImtConflictTable(count, linear_alloc, image_pointer_size_);
6377}
6378
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006379void ClassLinker::FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006380 ArtMethod* unimplemented_method,
6381 ArtMethod* imt_conflict_method,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006382 ObjPtr<mirror::Class> klass,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006383 bool create_conflict_tables,
6384 bool ignore_copied_methods,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006385 /*out*/bool* new_conflict,
6386 /*out*/ArtMethod** imt) {
6387 uint32_t conflict_counts[ImTable::kSize] = {};
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006388 for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006389 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006390 const size_t num_virtuals = interface->NumVirtualMethods();
6391 const size_t method_array_count = if_table->GetMethodArrayCount(i);
6392 // Virtual methods can be larger than the if table methods if there are default methods.
6393 DCHECK_GE(num_virtuals, method_array_count);
6394 if (kIsDebugBuild) {
6395 if (klass->IsInterface()) {
6396 DCHECK_EQ(method_array_count, 0u);
6397 } else {
6398 DCHECK_EQ(interface->NumDeclaredVirtualMethods(), method_array_count);
6399 }
6400 }
6401 if (method_array_count == 0) {
6402 continue;
6403 }
6404 auto* method_array = if_table->GetMethodArray(i);
6405 for (size_t j = 0; j < method_array_count; ++j) {
6406 ArtMethod* implementation_method =
6407 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6408 if (ignore_copied_methods && implementation_method->IsCopied()) {
6409 continue;
6410 }
6411 DCHECK(implementation_method != nullptr);
6412 // Miranda methods cannot be used to implement an interface method, but they are safe to put
6413 // in the IMT since their entrypoint is the interface trampoline. If we put any copied methods
6414 // or interface methods in the IMT here they will not create extra conflicts since we compare
6415 // names and signatures in SetIMTRef.
6416 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
Andreas Gampe75a7db62016-09-26 12:04:26 -07006417 const uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006418
6419 // There is only any conflicts if all of the interface methods for an IMT slot don't have
6420 // the same implementation method, keep track of this to avoid creating a conflict table in
6421 // this case.
6422
6423 // Conflict table size for each IMT slot.
6424 ++conflict_counts[imt_index];
6425
6426 SetIMTRef(unimplemented_method,
6427 imt_conflict_method,
6428 implementation_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006429 /*out*/new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006430 /*out*/&imt[imt_index]);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006431 }
6432 }
6433
6434 if (create_conflict_tables) {
6435 // Create the conflict tables.
6436 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006437 for (size_t i = 0; i < ImTable::kSize; ++i) {
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006438 size_t conflicts = conflict_counts[i];
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006439 if (imt[i] == imt_conflict_method) {
6440 ImtConflictTable* new_table = CreateImtConflictTable(conflicts, linear_alloc);
6441 if (new_table != nullptr) {
6442 ArtMethod* new_conflict_method =
6443 Runtime::Current()->CreateImtConflictMethod(linear_alloc);
6444 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_);
6445 imt[i] = new_conflict_method;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006446 } else {
6447 LOG(ERROR) << "Failed to allocate conflict table";
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006448 imt[i] = imt_conflict_method;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006449 }
6450 } else {
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006451 DCHECK_NE(imt[i], imt_conflict_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006452 }
6453 }
6454
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006455 for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006456 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006457 const size_t method_array_count = if_table->GetMethodArrayCount(i);
6458 // Virtual methods can be larger than the if table methods if there are default methods.
6459 if (method_array_count == 0) {
6460 continue;
6461 }
6462 auto* method_array = if_table->GetMethodArray(i);
6463 for (size_t j = 0; j < method_array_count; ++j) {
6464 ArtMethod* implementation_method =
6465 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6466 if (ignore_copied_methods && implementation_method->IsCopied()) {
6467 continue;
6468 }
6469 DCHECK(implementation_method != nullptr);
6470 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
Andreas Gampe75a7db62016-09-26 12:04:26 -07006471 const uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006472 if (!imt[imt_index]->IsRuntimeMethod() ||
6473 imt[imt_index] == unimplemented_method ||
6474 imt[imt_index] == imt_conflict_method) {
6475 continue;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006476 }
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006477 ImtConflictTable* table = imt[imt_index]->GetImtConflictTable(image_pointer_size_);
6478 const size_t num_entries = table->NumEntries(image_pointer_size_);
6479 table->SetInterfaceMethod(num_entries, image_pointer_size_, interface_method);
6480 table->SetImplementationMethod(num_entries, image_pointer_size_, implementation_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006481 }
6482 }
6483 }
6484}
6485
Alex Lighteb7c1442015-08-31 13:17:42 -07006486// Simple helper function that checks that no subtypes of 'val' are contained within the 'classes'
6487// set.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006488static bool NotSubinterfaceOfAny(
6489 const std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr>& classes,
6490 ObjPtr<mirror::Class> val)
Alex Lighteb7c1442015-08-31 13:17:42 -07006491 REQUIRES(Roles::uninterruptible_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006492 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006493 DCHECK(val != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006494 for (ObjPtr<mirror::Class> c : classes) {
6495 if (val->IsAssignableFrom(c)) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006496 return false;
6497 }
6498 }
6499 return true;
6500}
6501
6502// Fills in and flattens the interface inheritance hierarchy.
6503//
6504// By the end of this function all interfaces in the transitive closure of to_process are added to
6505// the iftable and every interface precedes all of its sub-interfaces in this list.
6506//
6507// all I, J: Interface | I <: J implies J precedes I
6508//
6509// (note A <: B means that A is a subtype of B)
6510//
6511// This returns the total number of items in the iftable. The iftable might be resized down after
6512// this call.
6513//
6514// We order this backwards so that we do not need to reorder superclass interfaces when new
6515// interfaces are added in subclass's interface tables.
6516//
6517// Upon entry into this function iftable is a copy of the superclass's iftable with the first
6518// super_ifcount entries filled in with the transitive closure of the interfaces of the superclass.
6519// The other entries are uninitialized. We will fill in the remaining entries in this function. The
6520// iftable must be large enough to hold all interfaces without changing its size.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006521static size_t FillIfTable(ObjPtr<mirror::IfTable> iftable,
Alex Lighteb7c1442015-08-31 13:17:42 -07006522 size_t super_ifcount,
6523 std::vector<mirror::Class*> to_process)
6524 REQUIRES(Roles::uninterruptible_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006525 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006526 // This is the set of all class's already in the iftable. Used to make checking if a class has
6527 // already been added quicker.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006528 std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr> classes_in_iftable;
Alex Lighteb7c1442015-08-31 13:17:42 -07006529 // The first super_ifcount elements are from the superclass. We note that they are already added.
6530 for (size_t i = 0; i < super_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006531 ObjPtr<mirror::Class> iface = iftable->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07006532 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, iface)) << "Bad ordering.";
6533 classes_in_iftable.insert(iface);
6534 }
6535 size_t filled_ifcount = super_ifcount;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006536 for (ObjPtr<mirror::Class> interface : to_process) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006537 // Let us call the first filled_ifcount elements of iftable the current-iface-list.
6538 // At this point in the loop current-iface-list has the invariant that:
6539 // for every pair of interfaces I,J within it:
6540 // if index_of(I) < index_of(J) then I is not a subtype of J
6541
6542 // If we have already seen this element then all of its super-interfaces must already be in the
6543 // current-iface-list so we can skip adding it.
6544 if (!ContainsElement(classes_in_iftable, interface)) {
6545 // We haven't seen this interface so add all of its super-interfaces onto the
6546 // current-iface-list, skipping those already on it.
6547 int32_t ifcount = interface->GetIfTableCount();
6548 for (int32_t j = 0; j < ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006549 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006550 if (!ContainsElement(classes_in_iftable, super_interface)) {
6551 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, super_interface)) << "Bad ordering.";
6552 classes_in_iftable.insert(super_interface);
6553 iftable->SetInterface(filled_ifcount, super_interface);
6554 filled_ifcount++;
6555 }
6556 }
6557 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, interface)) << "Bad ordering";
6558 // Place this interface onto the current-iface-list after all of its super-interfaces.
6559 classes_in_iftable.insert(interface);
6560 iftable->SetInterface(filled_ifcount, interface);
6561 filled_ifcount++;
6562 } else if (kIsDebugBuild) {
6563 // Check all super-interfaces are already in the list.
6564 int32_t ifcount = interface->GetIfTableCount();
6565 for (int32_t j = 0; j < ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006566 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006567 DCHECK(ContainsElement(classes_in_iftable, super_interface))
David Sehr709b0702016-10-13 09:12:37 -07006568 << "Iftable does not contain " << mirror::Class::PrettyClass(super_interface)
6569 << ", a superinterface of " << interface->PrettyClass();
Alex Lighteb7c1442015-08-31 13:17:42 -07006570 }
6571 }
6572 }
6573 if (kIsDebugBuild) {
6574 // Check that the iftable is ordered correctly.
6575 for (size_t i = 0; i < filled_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006576 ObjPtr<mirror::Class> if_a = iftable->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07006577 for (size_t j = i + 1; j < filled_ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006578 ObjPtr<mirror::Class> if_b = iftable->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006579 // !(if_a <: if_b)
6580 CHECK(!if_b->IsAssignableFrom(if_a))
David Sehr709b0702016-10-13 09:12:37 -07006581 << "Bad interface order: " << mirror::Class::PrettyClass(if_a) << " (index " << i
6582 << ") extends "
6583 << if_b->PrettyClass() << " (index " << j << ") and so should be after it in the "
Alex Lighteb7c1442015-08-31 13:17:42 -07006584 << "interface list.";
6585 }
6586 }
6587 }
6588 return filled_ifcount;
6589}
6590
6591bool ClassLinker::SetupInterfaceLookupTable(Thread* self, Handle<mirror::Class> klass,
6592 Handle<mirror::ObjectArray<mirror::Class>> interfaces) {
6593 StackHandleScope<1> hs(self);
Mathieu Chartier6beced42016-11-15 15:51:31 -08006594 const bool has_superclass = klass->HasSuperClass();
6595 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
Andreas Gampefa4333d2017-02-14 11:10:34 -08006596 const bool have_interfaces = interfaces != nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006597 const size_t num_interfaces =
6598 have_interfaces ? interfaces->GetLength() : klass->NumDirectInterfaces();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006599 if (num_interfaces == 0) {
6600 if (super_ifcount == 0) {
Mathieu Chartier6beced42016-11-15 15:51:31 -08006601 if (LIKELY(has_superclass)) {
6602 klass->SetIfTable(klass->GetSuperClass()->GetIfTable());
6603 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006604 // Class implements no interfaces.
6605 DCHECK_EQ(klass->GetIfTableCount(), 0);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006606 return true;
6607 }
Ian Rogers9bc81912012-10-11 21:43:36 -07006608 // Class implements same interfaces as parent, are any of these not marker interfaces?
6609 bool has_non_marker_interface = false;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006610 ObjPtr<mirror::IfTable> super_iftable = klass->GetSuperClass()->GetIfTable();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006611 for (size_t i = 0; i < super_ifcount; ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07006612 if (super_iftable->GetMethodArrayCount(i) > 0) {
6613 has_non_marker_interface = true;
6614 break;
6615 }
6616 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006617 // Class just inherits marker interfaces from parent so recycle parent's iftable.
Ian Rogers9bc81912012-10-11 21:43:36 -07006618 if (!has_non_marker_interface) {
Ian Rogers9bc81912012-10-11 21:43:36 -07006619 klass->SetIfTable(super_iftable);
6620 return true;
6621 }
6622 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006623 size_t ifcount = super_ifcount + num_interfaces;
Alex Lighteb7c1442015-08-31 13:17:42 -07006624 // Check that every class being implemented is an interface.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006625 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006626 ObjPtr<mirror::Class> interface = have_interfaces
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006627 ? interfaces->GetWithoutChecks(i)
Vladimir Marko19a4d372016-12-08 14:41:46 +00006628 : mirror::Class::GetDirectInterface(self, klass.Get(), i);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006629 DCHECK(interface != nullptr);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006630 if (UNLIKELY(!interface->IsInterface())) {
6631 std::string temp;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006632 ThrowIncompatibleClassChangeError(klass.Get(),
6633 "Class %s implements non-interface class %s",
David Sehr709b0702016-10-13 09:12:37 -07006634 klass->PrettyDescriptor().c_str(),
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006635 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str());
6636 return false;
6637 }
6638 ifcount += interface->GetIfTableCount();
6639 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006640 // Create the interface function table.
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07006641 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006642 if (UNLIKELY(iftable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006643 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006644 return false;
6645 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006646 // Fill in table with superclass's iftable.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006647 if (super_ifcount != 0) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006648 ObjPtr<mirror::IfTable> super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07006649 for (size_t i = 0; i < super_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006650 ObjPtr<mirror::Class> super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07006651 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07006652 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006653 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006654
6655 // Note that AllowThreadSuspension is to thread suspension as pthread_testcancel is to pthread
6656 // cancellation. That is it will suspend if one has a pending suspend request but otherwise
6657 // doesn't really do anything.
Ian Rogers7b078e82014-09-10 14:44:24 -07006658 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07006659
6660 size_t new_ifcount;
6661 {
Mathieu Chartier268764d2016-09-13 12:09:38 -07006662 ScopedAssertNoThreadSuspension nts("Copying mirror::Class*'s for FillIfTable");
Alex Lighteb7c1442015-08-31 13:17:42 -07006663 std::vector<mirror::Class*> to_add;
6664 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006665 ObjPtr<mirror::Class> interface = have_interfaces ? interfaces->Get(i) :
Vladimir Marko19a4d372016-12-08 14:41:46 +00006666 mirror::Class::GetDirectInterface(self, klass.Get(), i);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006667 to_add.push_back(interface.Ptr());
Ian Rogersb52b01a2012-01-12 17:01:38 -08006668 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006669
6670 new_ifcount = FillIfTable(iftable.Get(), super_ifcount, std::move(to_add));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006671 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006672
Ian Rogers7b078e82014-09-10 14:44:24 -07006673 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07006674
Ian Rogersb52b01a2012-01-12 17:01:38 -08006675 // Shrink iftable in case duplicates were found
Alex Lighteb7c1442015-08-31 13:17:42 -07006676 if (new_ifcount < ifcount) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006677 DCHECK_NE(num_interfaces, 0U);
Mathieu Chartiere401d142015-04-22 13:56:20 -07006678 iftable.Assign(down_cast<mirror::IfTable*>(
Alex Lighteb7c1442015-08-31 13:17:42 -07006679 iftable->CopyOf(self, new_ifcount * mirror::IfTable::kMax)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006680 if (UNLIKELY(iftable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006681 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006682 return false;
6683 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006684 ifcount = new_ifcount;
Ian Rogersb52b01a2012-01-12 17:01:38 -08006685 } else {
Alex Lighteb7c1442015-08-31 13:17:42 -07006686 DCHECK_EQ(new_ifcount, ifcount);
Ian Rogersb52b01a2012-01-12 17:01:38 -08006687 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07006688 klass->SetIfTable(iftable.Get());
Alex Lighteb7c1442015-08-31 13:17:42 -07006689 return true;
6690}
6691
Alex Light1f3925d2016-09-07 12:04:20 -07006692// Finds the method with a name/signature that matches cmp in the given lists of methods. The list
6693// of methods must be unique.
6694static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp ATTRIBUTE_UNUSED) {
6695 return nullptr;
6696}
6697
6698template <typename ... Types>
Alex Light9139e002015-10-09 15:59:48 -07006699static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp,
Alex Light1f3925d2016-09-07 12:04:20 -07006700 const ScopedArenaVector<ArtMethod*>& list,
6701 const Types& ... rest)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006702 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light9139e002015-10-09 15:59:48 -07006703 for (ArtMethod* method : list) {
6704 if (cmp.HasSameNameAndSignature(method)) {
6705 return method;
6706 }
6707 }
Alex Light1f3925d2016-09-07 12:04:20 -07006708 return FindSameNameAndSignature(cmp, rest...);
Alex Light9139e002015-10-09 15:59:48 -07006709}
6710
Alex Light1f3925d2016-09-07 12:04:20 -07006711// Check that all vtable entries are present in this class's virtuals or are the same as a
6712// superclasses vtable entry.
6713static void CheckClassOwnsVTableEntries(Thread* self,
6714 Handle<mirror::Class> klass,
6715 PointerSize pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006716 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light1f3925d2016-09-07 12:04:20 -07006717 StackHandleScope<2> hs(self);
6718 Handle<mirror::PointerArray> check_vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006719 ObjPtr<mirror::Class> super_temp = (klass->HasSuperClass()) ? klass->GetSuperClass() : nullptr;
Alex Light1f3925d2016-09-07 12:04:20 -07006720 Handle<mirror::Class> superclass(hs.NewHandle(super_temp));
Andreas Gampefa4333d2017-02-14 11:10:34 -08006721 int32_t super_vtable_length = (superclass != nullptr) ? superclass->GetVTableLength() : 0;
Alex Lighte64300b2015-12-15 15:02:47 -08006722 for (int32_t i = 0; i < check_vtable->GetLength(); ++i) {
6723 ArtMethod* m = check_vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
6724 CHECK(m != nullptr);
6725
Alex Light1f3925d2016-09-07 12:04:20 -07006726 CHECK_EQ(m->GetMethodIndexDuringLinking(), i)
David Sehr709b0702016-10-13 09:12:37 -07006727 << m->PrettyMethod()
6728 << " has an unexpected method index for its spot in the vtable for class"
6729 << klass->PrettyClass();
Alex Lighte64300b2015-12-15 15:02:47 -08006730 ArraySlice<ArtMethod> virtuals = klass->GetVirtualMethodsSliceUnchecked(pointer_size);
6731 auto is_same_method = [m] (const ArtMethod& meth) {
6732 return &meth == m;
6733 };
Alex Light3f980532017-03-17 15:10:32 -07006734 if (!((super_vtable_length > i && superclass->GetVTableEntry(i, pointer_size) == m) ||
6735 std::find_if(virtuals.begin(), virtuals.end(), is_same_method) != virtuals.end())) {
6736 LOG(WARNING) << m->PrettyMethod() << " does not seem to be owned by current class "
6737 << klass->PrettyClass() << " or any of its superclasses!";
6738 }
Alex Lighte64300b2015-12-15 15:02:47 -08006739 }
6740}
6741
Alex Light1f3925d2016-09-07 12:04:20 -07006742// Check to make sure the vtable does not have duplicates. Duplicates could cause problems when a
6743// method is overridden in a subclass.
6744static void CheckVTableHasNoDuplicates(Thread* self,
6745 Handle<mirror::Class> klass,
6746 PointerSize pointer_size)
6747 REQUIRES_SHARED(Locks::mutator_lock_) {
6748 StackHandleScope<1> hs(self);
6749 Handle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
6750 int32_t num_entries = vtable->GetLength();
6751 for (int32_t i = 0; i < num_entries; i++) {
6752 ArtMethod* vtable_entry = vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
6753 // Don't bother if we cannot 'see' the vtable entry (i.e. it is a package-private member maybe).
6754 if (!klass->CanAccessMember(vtable_entry->GetDeclaringClass(),
6755 vtable_entry->GetAccessFlags())) {
6756 continue;
6757 }
6758 MethodNameAndSignatureComparator name_comparator(
6759 vtable_entry->GetInterfaceMethodIfProxy(pointer_size));
Alex Lightc7a420c2016-10-18 14:33:18 -07006760 for (int32_t j = i + 1; j < num_entries; j++) {
Alex Light1f3925d2016-09-07 12:04:20 -07006761 ArtMethod* other_entry = vtable->GetElementPtrSize<ArtMethod*>(j, pointer_size);
Alex Lightc7a420c2016-10-18 14:33:18 -07006762 if (!klass->CanAccessMember(other_entry->GetDeclaringClass(),
6763 other_entry->GetAccessFlags())) {
6764 continue;
6765 }
Alex Light3f980532017-03-17 15:10:32 -07006766 if (vtable_entry == other_entry ||
6767 name_comparator.HasSameNameAndSignature(
6768 other_entry->GetInterfaceMethodIfProxy(pointer_size))) {
6769 LOG(WARNING) << "vtable entries " << i << " and " << j << " are identical for "
6770 << klass->PrettyClass() << " in method " << vtable_entry->PrettyMethod()
6771 << " (0x" << std::hex << reinterpret_cast<uintptr_t>(vtable_entry) << ") and "
6772 << other_entry->PrettyMethod() << " (0x" << std::hex
6773 << reinterpret_cast<uintptr_t>(other_entry) << ")";
6774 }
Alex Light1f3925d2016-09-07 12:04:20 -07006775 }
6776 }
6777}
6778
6779static void SanityCheckVTable(Thread* self, Handle<mirror::Class> klass, PointerSize pointer_size)
6780 REQUIRES_SHARED(Locks::mutator_lock_) {
6781 CheckClassOwnsVTableEntries(self, klass, pointer_size);
6782 CheckVTableHasNoDuplicates(self, klass, pointer_size);
6783}
6784
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006785void ClassLinker::FillImtFromSuperClass(Handle<mirror::Class> klass,
6786 ArtMethod* unimplemented_method,
6787 ArtMethod* imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006788 bool* new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006789 ArtMethod** imt) {
Alex Light705ad492015-09-21 11:36:30 -07006790 DCHECK(klass->HasSuperClass());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006791 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006792 if (super_class->ShouldHaveImt()) {
6793 ImTable* super_imt = super_class->GetImt(image_pointer_size_);
6794 for (size_t i = 0; i < ImTable::kSize; ++i) {
6795 imt[i] = super_imt->Get(i, image_pointer_size_);
Alex Light705ad492015-09-21 11:36:30 -07006796 }
6797 } else {
6798 // No imt in the super class, need to reconstruct from the iftable.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006799 ObjPtr<mirror::IfTable> if_table = super_class->GetIfTable();
Mathieu Chartier6beced42016-11-15 15:51:31 -08006800 if (if_table->Count() != 0) {
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006801 // Ignore copied methods since we will handle these in LinkInterfaceMethods.
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006802 FillIMTFromIfTable(if_table,
6803 unimplemented_method,
6804 imt_conflict_method,
6805 klass.Get(),
6806 /*create_conflict_table*/false,
6807 /*ignore_copied_methods*/true,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006808 /*out*/new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006809 /*out*/imt);
Alex Light705ad492015-09-21 11:36:30 -07006810 }
6811 }
6812}
6813
Vladimir Marko921094a2017-01-12 18:37:06 +00006814class ClassLinker::LinkInterfaceMethodsHelper {
6815 public:
6816 LinkInterfaceMethodsHelper(ClassLinker* class_linker,
6817 Handle<mirror::Class> klass,
6818 Thread* self,
6819 Runtime* runtime)
6820 : class_linker_(class_linker),
6821 klass_(klass),
6822 method_alignment_(ArtMethod::Alignment(class_linker->GetImagePointerSize())),
6823 method_size_(ArtMethod::Size(class_linker->GetImagePointerSize())),
6824 self_(self),
6825 stack_(runtime->GetLinearAlloc()->GetArenaPool()),
6826 allocator_(&stack_),
6827 default_conflict_methods_(allocator_.Adapter()),
6828 overriding_default_conflict_methods_(allocator_.Adapter()),
6829 miranda_methods_(allocator_.Adapter()),
6830 default_methods_(allocator_.Adapter()),
6831 overriding_default_methods_(allocator_.Adapter()),
6832 move_table_(allocator_.Adapter()) {
6833 }
6834
6835 ArtMethod* FindMethod(ArtMethod* interface_method,
6836 MethodNameAndSignatureComparator& interface_name_comparator,
6837 ArtMethod* vtable_impl)
6838 REQUIRES_SHARED(Locks::mutator_lock_);
6839
6840 ArtMethod* GetOrCreateMirandaMethod(ArtMethod* interface_method,
6841 MethodNameAndSignatureComparator& interface_name_comparator)
6842 REQUIRES_SHARED(Locks::mutator_lock_);
6843
6844 bool HasNewVirtuals() const {
6845 return !(miranda_methods_.empty() &&
6846 default_methods_.empty() &&
6847 overriding_default_methods_.empty() &&
6848 overriding_default_conflict_methods_.empty() &&
6849 default_conflict_methods_.empty());
6850 }
6851
6852 void ReallocMethods() REQUIRES_SHARED(Locks::mutator_lock_);
6853
6854 ObjPtr<mirror::PointerArray> UpdateVtable(
6855 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
6856 ObjPtr<mirror::PointerArray> old_vtable) REQUIRES_SHARED(Locks::mutator_lock_);
6857
6858 void UpdateIfTable(Handle<mirror::IfTable> iftable) REQUIRES_SHARED(Locks::mutator_lock_);
6859
6860 void UpdateIMT(ArtMethod** out_imt);
6861
6862 void CheckNoStaleMethodsInDexCache() REQUIRES_SHARED(Locks::mutator_lock_) {
6863 if (kIsDebugBuild) {
6864 PointerSize pointer_size = class_linker_->GetImagePointerSize();
6865 // Check that there are no stale methods are in the dex cache array.
6866 auto* resolved_methods = klass_->GetDexCache()->GetResolvedMethods();
6867 for (size_t i = 0, count = klass_->GetDexCache()->NumResolvedMethods(); i < count; ++i) {
6868 auto* m = mirror::DexCache::GetElementPtrSize(resolved_methods, i, pointer_size);
6869 CHECK(move_table_.find(m) == move_table_.end() ||
6870 // The original versions of copied methods will still be present so allow those too.
6871 // Note that if the first check passes this might fail to GetDeclaringClass().
6872 std::find_if(m->GetDeclaringClass()->GetMethods(pointer_size).begin(),
6873 m->GetDeclaringClass()->GetMethods(pointer_size).end(),
6874 [m] (ArtMethod& meth) {
6875 return &meth == m;
6876 }) != m->GetDeclaringClass()->GetMethods(pointer_size).end())
6877 << "Obsolete method " << m->PrettyMethod() << " is in dex cache!";
6878 }
6879 }
6880 }
6881
6882 void ClobberOldMethods(LengthPrefixedArray<ArtMethod>* old_methods,
6883 LengthPrefixedArray<ArtMethod>* methods) {
6884 if (kIsDebugBuild) {
6885 CHECK(methods != nullptr);
6886 // Put some random garbage in old methods to help find stale pointers.
6887 if (methods != old_methods && old_methods != nullptr) {
6888 // Need to make sure the GC is not running since it could be scanning the methods we are
6889 // about to overwrite.
6890 ScopedThreadStateChange tsc(self_, kSuspended);
6891 gc::ScopedGCCriticalSection gcs(self_,
6892 gc::kGcCauseClassLinker,
6893 gc::kCollectorTypeClassLinker);
6894 const size_t old_size = LengthPrefixedArray<ArtMethod>::ComputeSize(old_methods->size(),
6895 method_size_,
6896 method_alignment_);
6897 memset(old_methods, 0xFEu, old_size);
6898 }
6899 }
6900 }
6901
6902 private:
6903 size_t NumberOfNewVirtuals() const {
6904 return miranda_methods_.size() +
6905 default_methods_.size() +
6906 overriding_default_conflict_methods_.size() +
6907 overriding_default_methods_.size() +
6908 default_conflict_methods_.size();
6909 }
6910
6911 bool FillTables() REQUIRES_SHARED(Locks::mutator_lock_) {
6912 return !klass_->IsInterface();
6913 }
6914
6915 void LogNewVirtuals() const REQUIRES_SHARED(Locks::mutator_lock_) {
6916 DCHECK(!klass_->IsInterface() || (default_methods_.empty() && miranda_methods_.empty()))
6917 << "Interfaces should only have default-conflict methods appended to them.";
6918 VLOG(class_linker) << mirror::Class::PrettyClass(klass_.Get()) << ": miranda_methods="
6919 << miranda_methods_.size()
6920 << " default_methods=" << default_methods_.size()
6921 << " overriding_default_methods=" << overriding_default_methods_.size()
6922 << " default_conflict_methods=" << default_conflict_methods_.size()
6923 << " overriding_default_conflict_methods="
6924 << overriding_default_conflict_methods_.size();
6925 }
6926
6927 ClassLinker* class_linker_;
6928 Handle<mirror::Class> klass_;
6929 size_t method_alignment_;
6930 size_t method_size_;
6931 Thread* const self_;
6932
6933 // These are allocated on the heap to begin, we then transfer to linear alloc when we re-create
6934 // the virtual methods array.
6935 // Need to use low 4GB arenas for compiler or else the pointers wont fit in 32 bit method array
6936 // during cross compilation.
6937 // Use the linear alloc pool since this one is in the low 4gb for the compiler.
6938 ArenaStack stack_;
6939 ScopedArenaAllocator allocator_;
6940
6941 ScopedArenaVector<ArtMethod*> default_conflict_methods_;
6942 ScopedArenaVector<ArtMethod*> overriding_default_conflict_methods_;
6943 ScopedArenaVector<ArtMethod*> miranda_methods_;
6944 ScopedArenaVector<ArtMethod*> default_methods_;
6945 ScopedArenaVector<ArtMethod*> overriding_default_methods_;
6946
6947 ScopedArenaUnorderedMap<ArtMethod*, ArtMethod*> move_table_;
6948};
6949
6950ArtMethod* ClassLinker::LinkInterfaceMethodsHelper::FindMethod(
6951 ArtMethod* interface_method,
6952 MethodNameAndSignatureComparator& interface_name_comparator,
6953 ArtMethod* vtable_impl) {
6954 ArtMethod* current_method = nullptr;
6955 switch (class_linker_->FindDefaultMethodImplementation(self_,
6956 interface_method,
6957 klass_,
6958 /*out*/&current_method)) {
6959 case DefaultMethodSearchResult::kDefaultConflict: {
6960 // Default method conflict.
6961 DCHECK(current_method == nullptr);
6962 ArtMethod* default_conflict_method = nullptr;
6963 if (vtable_impl != nullptr && vtable_impl->IsDefaultConflicting()) {
6964 // We can reuse the method from the superclass, don't bother adding it to virtuals.
6965 default_conflict_method = vtable_impl;
6966 } else {
6967 // See if we already have a conflict method for this method.
6968 ArtMethod* preexisting_conflict = FindSameNameAndSignature(
6969 interface_name_comparator,
6970 default_conflict_methods_,
6971 overriding_default_conflict_methods_);
6972 if (LIKELY(preexisting_conflict != nullptr)) {
6973 // We already have another conflict we can reuse.
6974 default_conflict_method = preexisting_conflict;
6975 } else {
6976 // Note that we do this even if we are an interface since we need to create this and
6977 // cannot reuse another classes.
6978 // Create a new conflict method for this to use.
6979 default_conflict_method = reinterpret_cast<ArtMethod*>(allocator_.Alloc(method_size_));
6980 new(default_conflict_method) ArtMethod(interface_method,
6981 class_linker_->GetImagePointerSize());
6982 if (vtable_impl == nullptr) {
6983 // Save the conflict method. We need to add it to the vtable.
6984 default_conflict_methods_.push_back(default_conflict_method);
6985 } else {
6986 // Save the conflict method but it is already in the vtable.
6987 overriding_default_conflict_methods_.push_back(default_conflict_method);
6988 }
6989 }
6990 }
6991 current_method = default_conflict_method;
6992 break;
6993 } // case kDefaultConflict
6994 case DefaultMethodSearchResult::kDefaultFound: {
6995 DCHECK(current_method != nullptr);
6996 // Found a default method.
6997 if (vtable_impl != nullptr &&
6998 current_method->GetDeclaringClass() == vtable_impl->GetDeclaringClass()) {
6999 // We found a default method but it was the same one we already have from our
7000 // superclass. Don't bother adding it to our vtable again.
7001 current_method = vtable_impl;
7002 } else if (LIKELY(FillTables())) {
7003 // Interfaces don't need to copy default methods since they don't have vtables.
7004 // Only record this default method if it is new to save space.
7005 // TODO It might be worthwhile to copy default methods on interfaces anyway since it
7006 // would make lookup for interface super much faster. (We would only need to scan
7007 // the iftable to find if there is a NSME or AME.)
7008 ArtMethod* old = FindSameNameAndSignature(interface_name_comparator,
7009 default_methods_,
7010 overriding_default_methods_);
7011 if (old == nullptr) {
7012 // We found a default method implementation and there were no conflicts.
7013 if (vtable_impl == nullptr) {
7014 // Save the default method. We need to add it to the vtable.
7015 default_methods_.push_back(current_method);
7016 } else {
7017 // Save the default method but it is already in the vtable.
7018 overriding_default_methods_.push_back(current_method);
7019 }
7020 } else {
7021 CHECK(old == current_method) << "Multiple default implementations selected!";
7022 }
7023 }
7024 break;
7025 } // case kDefaultFound
7026 case DefaultMethodSearchResult::kAbstractFound: {
7027 DCHECK(current_method == nullptr);
7028 // Abstract method masks all defaults.
7029 if (vtable_impl != nullptr &&
7030 vtable_impl->IsAbstract() &&
7031 !vtable_impl->IsDefaultConflicting()) {
7032 // We need to make this an abstract method but the version in the vtable already is so
7033 // don't do anything.
7034 current_method = vtable_impl;
7035 }
7036 break;
7037 } // case kAbstractFound
7038 }
7039 return current_method;
7040}
7041
7042ArtMethod* ClassLinker::LinkInterfaceMethodsHelper::GetOrCreateMirandaMethod(
7043 ArtMethod* interface_method,
7044 MethodNameAndSignatureComparator& interface_name_comparator) {
7045 // Find out if there is already a miranda method we can use.
7046 ArtMethod* miranda_method = FindSameNameAndSignature(interface_name_comparator,
7047 miranda_methods_);
7048 if (miranda_method == nullptr) {
7049 DCHECK(interface_method->IsAbstract()) << interface_method->PrettyMethod();
7050 miranda_method = reinterpret_cast<ArtMethod*>(allocator_.Alloc(method_size_));
7051 CHECK(miranda_method != nullptr);
7052 // Point the interface table at a phantom slot.
7053 new(miranda_method) ArtMethod(interface_method, class_linker_->GetImagePointerSize());
7054 miranda_methods_.push_back(miranda_method);
7055 }
7056 return miranda_method;
7057}
7058
7059void ClassLinker::LinkInterfaceMethodsHelper::ReallocMethods() {
7060 LogNewVirtuals();
7061
7062 const size_t old_method_count = klass_->NumMethods();
7063 const size_t new_method_count = old_method_count + NumberOfNewVirtuals();
7064 DCHECK_NE(old_method_count, new_method_count);
7065
7066 // Attempt to realloc to save RAM if possible.
7067 LengthPrefixedArray<ArtMethod>* old_methods = klass_->GetMethodsPtr();
7068 // The Realloced virtual methods aren't visible from the class roots, so there is no issue
7069 // where GCs could attempt to mark stale pointers due to memcpy. And since we overwrite the
7070 // realloced memory with out->CopyFrom, we are guaranteed to have objects in the to space since
7071 // CopyFrom has internal read barriers.
7072 //
7073 // TODO We should maybe move some of this into mirror::Class or at least into another method.
7074 const size_t old_size = LengthPrefixedArray<ArtMethod>::ComputeSize(old_method_count,
7075 method_size_,
7076 method_alignment_);
7077 const size_t new_size = LengthPrefixedArray<ArtMethod>::ComputeSize(new_method_count,
7078 method_size_,
7079 method_alignment_);
7080 const size_t old_methods_ptr_size = (old_methods != nullptr) ? old_size : 0;
7081 auto* methods = reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
7082 Runtime::Current()->GetLinearAlloc()->Realloc(
7083 self_, old_methods, old_methods_ptr_size, new_size));
7084 CHECK(methods != nullptr); // Native allocation failure aborts.
7085
7086 PointerSize pointer_size = class_linker_->GetImagePointerSize();
7087 if (methods != old_methods) {
7088 // Maps from heap allocated miranda method to linear alloc miranda method.
7089 StrideIterator<ArtMethod> out = methods->begin(method_size_, method_alignment_);
7090 // Copy over the old methods.
7091 for (auto& m : klass_->GetMethods(pointer_size)) {
7092 move_table_.emplace(&m, &*out);
7093 // The CopyFrom is only necessary to not miss read barriers since Realloc won't do read
7094 // barriers when it copies.
7095 out->CopyFrom(&m, pointer_size);
7096 ++out;
7097 }
7098 }
7099 StrideIterator<ArtMethod> out(methods->begin(method_size_, method_alignment_) + old_method_count);
7100 // Copy over miranda methods before copying vtable since CopyOf may cause thread suspension and
7101 // we want the roots of the miranda methods to get visited.
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007102 for (size_t i = 0; i < miranda_methods_.size(); ++i) {
7103 ArtMethod* mir_method = miranda_methods_[i];
Vladimir Marko921094a2017-01-12 18:37:06 +00007104 ArtMethod& new_method = *out;
7105 new_method.CopyFrom(mir_method, pointer_size);
7106 new_method.SetAccessFlags(new_method.GetAccessFlags() | kAccMiranda | kAccCopied);
7107 DCHECK_NE(new_method.GetAccessFlags() & kAccAbstract, 0u)
7108 << "Miranda method should be abstract!";
7109 move_table_.emplace(mir_method, &new_method);
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007110 // Update the entry in the method array, as the array will be used for future lookups,
7111 // where thread suspension is allowed.
7112 // As such, the array should not contain locally allocated ArtMethod, otherwise the GC
7113 // would not see them.
7114 miranda_methods_[i] = &new_method;
Vladimir Marko921094a2017-01-12 18:37:06 +00007115 ++out;
7116 }
7117 // We need to copy the default methods into our own method table since the runtime requires that
7118 // every method on a class's vtable be in that respective class's virtual method table.
7119 // NOTE This means that two classes might have the same implementation of a method from the same
7120 // interface but will have different ArtMethod*s for them. This also means we cannot compare a
7121 // default method found on a class with one found on the declaring interface directly and must
7122 // look at the declaring class to determine if they are the same.
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007123 for (ScopedArenaVector<ArtMethod*>* methods_vec : {&default_methods_,
7124 &overriding_default_methods_}) {
7125 for (size_t i = 0; i < methods_vec->size(); ++i) {
7126 ArtMethod* def_method = (*methods_vec)[i];
Vladimir Marko921094a2017-01-12 18:37:06 +00007127 ArtMethod& new_method = *out;
7128 new_method.CopyFrom(def_method, pointer_size);
7129 // Clear the kAccSkipAccessChecks flag if it is present. Since this class hasn't been
7130 // verified yet it shouldn't have methods that are skipping access checks.
7131 // TODO This is rather arbitrary. We should maybe support classes where only some of its
7132 // methods are skip_access_checks.
7133 constexpr uint32_t kSetFlags = kAccDefault | kAccCopied;
7134 constexpr uint32_t kMaskFlags = ~kAccSkipAccessChecks;
7135 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags);
7136 move_table_.emplace(def_method, &new_method);
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007137 // Update the entry in the method array, as the array will be used for future lookups,
7138 // where thread suspension is allowed.
7139 // As such, the array should not contain locally allocated ArtMethod, otherwise the GC
7140 // would not see them.
7141 (*methods_vec)[i] = &new_method;
Vladimir Marko921094a2017-01-12 18:37:06 +00007142 ++out;
7143 }
7144 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007145 for (ScopedArenaVector<ArtMethod*>* methods_vec : {&default_conflict_methods_,
7146 &overriding_default_conflict_methods_}) {
7147 for (size_t i = 0; i < methods_vec->size(); ++i) {
7148 ArtMethod* conf_method = (*methods_vec)[i];
Vladimir Marko921094a2017-01-12 18:37:06 +00007149 ArtMethod& new_method = *out;
7150 new_method.CopyFrom(conf_method, pointer_size);
7151 // This is a type of default method (there are default method impls, just a conflict) so
7152 // mark this as a default, non-abstract method, since thats what it is. Also clear the
7153 // kAccSkipAccessChecks bit since this class hasn't been verified yet it shouldn't have
7154 // methods that are skipping access checks.
7155 constexpr uint32_t kSetFlags = kAccDefault | kAccDefaultConflict | kAccCopied;
7156 constexpr uint32_t kMaskFlags = ~(kAccAbstract | kAccSkipAccessChecks);
7157 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags);
7158 DCHECK(new_method.IsDefaultConflicting());
7159 // The actual method might or might not be marked abstract since we just copied it from a
7160 // (possibly default) interface method. We need to set it entry point to be the bridge so
7161 // that the compiler will not invoke the implementation of whatever method we copied from.
7162 EnsureThrowsInvocationError(class_linker_, &new_method);
7163 move_table_.emplace(conf_method, &new_method);
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007164 // Update the entry in the method array, as the array will be used for future lookups,
7165 // where thread suspension is allowed.
7166 // As such, the array should not contain locally allocated ArtMethod, otherwise the GC
7167 // would not see them.
7168 (*methods_vec)[i] = &new_method;
Vladimir Marko921094a2017-01-12 18:37:06 +00007169 ++out;
7170 }
7171 }
7172 methods->SetSize(new_method_count);
7173 class_linker_->UpdateClassMethods(klass_.Get(), methods);
7174}
7175
7176ObjPtr<mirror::PointerArray> ClassLinker::LinkInterfaceMethodsHelper::UpdateVtable(
7177 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
7178 ObjPtr<mirror::PointerArray> old_vtable) {
7179 // Update the vtable to the new method structures. We can skip this for interfaces since they
7180 // do not have vtables.
7181 const size_t old_vtable_count = old_vtable->GetLength();
7182 const size_t new_vtable_count = old_vtable_count +
7183 miranda_methods_.size() +
7184 default_methods_.size() +
7185 default_conflict_methods_.size();
7186
7187 ObjPtr<mirror::PointerArray> vtable =
7188 down_cast<mirror::PointerArray*>(old_vtable->CopyOf(self_, new_vtable_count));
7189 if (UNLIKELY(vtable == nullptr)) {
7190 self_->AssertPendingOOMException();
7191 return nullptr;
7192 }
7193
7194 size_t vtable_pos = old_vtable_count;
7195 PointerSize pointer_size = class_linker_->GetImagePointerSize();
7196 // Update all the newly copied method's indexes so they denote their placement in the vtable.
7197 for (const ScopedArenaVector<ArtMethod*>& methods_vec : {default_methods_,
7198 default_conflict_methods_,
7199 miranda_methods_}) {
7200 // These are the functions that are not already in the vtable!
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007201 for (ArtMethod* new_vtable_method : methods_vec) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007202 // Leave the declaring class alone the method's dex_code_item_offset_ and dex_method_index_
7203 // fields are references into the dex file the method was defined in. Since the ArtMethod
7204 // does not store that information it uses declaring_class_->dex_cache_.
7205 new_vtable_method->SetMethodIndex(0xFFFF & vtable_pos);
7206 vtable->SetElementPtrSize(vtable_pos, new_vtable_method, pointer_size);
7207 ++vtable_pos;
7208 }
7209 }
7210 DCHECK_EQ(vtable_pos, new_vtable_count);
7211
7212 // Update old vtable methods. We use the default_translations map to figure out what each
7213 // vtable entry should be updated to, if they need to be at all.
7214 for (size_t i = 0; i < old_vtable_count; ++i) {
7215 ArtMethod* translated_method = vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
7216 // Try and find what we need to change this method to.
7217 auto translation_it = default_translations.find(i);
Vladimir Marko921094a2017-01-12 18:37:06 +00007218 if (translation_it != default_translations.end()) {
7219 if (translation_it->second.IsInConflict()) {
7220 // Find which conflict method we are to use for this method.
7221 MethodNameAndSignatureComparator old_method_comparator(
7222 translated_method->GetInterfaceMethodIfProxy(pointer_size));
7223 // We only need to look through overriding_default_conflict_methods since this is an
7224 // overridden method we are fixing up here.
7225 ArtMethod* new_conflict_method = FindSameNameAndSignature(
7226 old_method_comparator, overriding_default_conflict_methods_);
7227 CHECK(new_conflict_method != nullptr) << "Expected a conflict method!";
7228 translated_method = new_conflict_method;
7229 } else if (translation_it->second.IsAbstract()) {
7230 // Find which miranda method we are to use for this method.
7231 MethodNameAndSignatureComparator old_method_comparator(
7232 translated_method->GetInterfaceMethodIfProxy(pointer_size));
7233 ArtMethod* miranda_method = FindSameNameAndSignature(old_method_comparator,
7234 miranda_methods_);
7235 DCHECK(miranda_method != nullptr);
7236 translated_method = miranda_method;
7237 } else {
7238 // Normal default method (changed from an older default or abstract interface method).
7239 DCHECK(translation_it->second.IsTranslation());
7240 translated_method = translation_it->second.GetTranslation();
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007241 auto it = move_table_.find(translated_method);
7242 DCHECK(it != move_table_.end());
7243 translated_method = it->second;
Vladimir Marko921094a2017-01-12 18:37:06 +00007244 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007245 } else {
7246 auto it = move_table_.find(translated_method);
7247 translated_method = (it != move_table_.end()) ? it->second : nullptr;
Vladimir Marko921094a2017-01-12 18:37:06 +00007248 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007249
7250 if (translated_method != nullptr) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007251 // Make sure the new_methods index is set.
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007252 if (translated_method->GetMethodIndexDuringLinking() != i) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007253 if (kIsDebugBuild) {
7254 auto* methods = klass_->GetMethodsPtr();
7255 CHECK_LE(reinterpret_cast<uintptr_t>(&*methods->begin(method_size_, method_alignment_)),
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007256 reinterpret_cast<uintptr_t>(translated_method));
7257 CHECK_LT(reinterpret_cast<uintptr_t>(translated_method),
Vladimir Marko921094a2017-01-12 18:37:06 +00007258 reinterpret_cast<uintptr_t>(&*methods->end(method_size_, method_alignment_)));
7259 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007260 translated_method->SetMethodIndex(0xFFFF & i);
Vladimir Marko921094a2017-01-12 18:37:06 +00007261 }
Nicolas Geoffray0376a5c2017-01-12 15:15:45 +00007262 vtable->SetElementPtrSize(i, translated_method, pointer_size);
Vladimir Marko921094a2017-01-12 18:37:06 +00007263 }
7264 }
7265 klass_->SetVTable(vtable.Ptr());
7266 return vtable;
7267}
7268
7269void ClassLinker::LinkInterfaceMethodsHelper::UpdateIfTable(Handle<mirror::IfTable> iftable) {
7270 PointerSize pointer_size = class_linker_->GetImagePointerSize();
7271 const size_t ifcount = klass_->GetIfTableCount();
7272 // Go fix up all the stale iftable pointers.
7273 for (size_t i = 0; i < ifcount; ++i) {
7274 for (size_t j = 0, count = iftable->GetMethodArrayCount(i); j < count; ++j) {
7275 auto* method_array = iftable->GetMethodArray(i);
7276 auto* m = method_array->GetElementPtrSize<ArtMethod*>(j, pointer_size);
7277 DCHECK(m != nullptr) << klass_->PrettyClass();
7278 auto it = move_table_.find(m);
7279 if (it != move_table_.end()) {
7280 auto* new_m = it->second;
7281 DCHECK(new_m != nullptr) << klass_->PrettyClass();
7282 method_array->SetElementPtrSize(j, new_m, pointer_size);
7283 }
7284 }
7285 }
7286}
7287
7288void ClassLinker::LinkInterfaceMethodsHelper::UpdateIMT(ArtMethod** out_imt) {
7289 // Fix up IMT next.
7290 for (size_t i = 0; i < ImTable::kSize; ++i) {
7291 auto it = move_table_.find(out_imt[i]);
7292 if (it != move_table_.end()) {
7293 out_imt[i] = it->second;
7294 }
7295 }
7296}
7297
Alex Light705ad492015-09-21 11:36:30 -07007298// TODO This method needs to be split up into several smaller methods.
Alex Lighteb7c1442015-08-31 13:17:42 -07007299bool ClassLinker::LinkInterfaceMethods(
7300 Thread* self,
7301 Handle<mirror::Class> klass,
Alex Light9139e002015-10-09 15:59:48 -07007302 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007303 bool* out_new_conflict,
Alex Lighteb7c1442015-08-31 13:17:42 -07007304 ArtMethod** out_imt) {
7305 StackHandleScope<3> hs(self);
7306 Runtime* const runtime = Runtime::Current();
Alex Light705ad492015-09-21 11:36:30 -07007307
7308 const bool is_interface = klass->IsInterface();
Alex Lighteb7c1442015-08-31 13:17:42 -07007309 const bool has_superclass = klass->HasSuperClass();
Alex Light705ad492015-09-21 11:36:30 -07007310 const bool fill_tables = !is_interface;
Alex Lighteb7c1442015-08-31 13:17:42 -07007311 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
Alex Lighteb7c1442015-08-31 13:17:42 -07007312 const size_t ifcount = klass->GetIfTableCount();
7313
Vladimir Marko921094a2017-01-12 18:37:06 +00007314 Handle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable()));
Mathieu Chartiere401d142015-04-22 13:56:20 -07007315
7316 MutableHandle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
7317 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
Alex Light9139e002015-10-09 15:59:48 -07007318 ArtMethod* const imt_conflict_method = runtime->GetImtConflictMethod();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07007319 // Copy the IMT from the super class if possible.
Alex Light705ad492015-09-21 11:36:30 -07007320 const bool extend_super_iftable = has_superclass;
7321 if (has_superclass && fill_tables) {
7322 FillImtFromSuperClass(klass,
Alex Light705ad492015-09-21 11:36:30 -07007323 unimplemented_method,
7324 imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007325 out_new_conflict,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07007326 out_imt);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07007327 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07007328 // Allocate method arrays before since we don't want miss visiting miranda method roots due to
7329 // thread suspension.
Alex Light705ad492015-09-21 11:36:30 -07007330 if (fill_tables) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007331 if (!AllocateIfTableMethodArrays(self, klass, iftable)) {
7332 return false;
Mathieu Chartiere401d142015-04-22 13:56:20 -07007333 }
7334 }
7335
Vladimir Marko921094a2017-01-12 18:37:06 +00007336 LinkInterfaceMethodsHelper helper(this, klass, self, runtime);
7337
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007338 auto* old_cause = self->StartAssertNoThreadSuspension(
Mathieu Chartiere401d142015-04-22 13:56:20 -07007339 "Copying ArtMethods for LinkInterfaceMethods");
Alex Light9139e002015-10-09 15:59:48 -07007340 // Going in reverse to ensure that we will hit abstract methods that override defaults before the
7341 // defaults. This means we don't need to do any trickery when creating the Miranda methods, since
7342 // they will already be null. This has the additional benefit that the declarer of a miranda
7343 // method will actually declare an abstract method.
7344 for (size_t i = ifcount; i != 0; ) {
7345 --i;
7346
7347 DCHECK_GE(i, 0u);
7348 DCHECK_LT(i, ifcount);
7349
Alex Light705ad492015-09-21 11:36:30 -07007350 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods();
Mathieu Chartiere401d142015-04-22 13:56:20 -07007351 if (num_methods > 0) {
7352 StackHandleScope<2> hs2(self);
7353 const bool is_super = i < super_ifcount;
7354 const bool super_interface = is_super && extend_super_iftable;
Alex Light705ad492015-09-21 11:36:30 -07007355 // We don't actually create or fill these tables for interfaces, we just copy some methods for
7356 // conflict methods. Just set this as nullptr in those cases.
7357 Handle<mirror::PointerArray> method_array(fill_tables
7358 ? hs2.NewHandle(iftable->GetMethodArray(i))
7359 : hs2.NewHandle<mirror::PointerArray>(nullptr));
Mathieu Chartiere401d142015-04-22 13:56:20 -07007360
Alex Lighte64300b2015-12-15 15:02:47 -08007361 ArraySlice<ArtMethod> input_virtual_methods;
Mathieu Chartier9865bde2015-12-21 09:58:16 -08007362 ScopedNullHandle<mirror::PointerArray> null_handle;
7363 Handle<mirror::PointerArray> input_vtable_array(null_handle);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007364 int32_t input_array_length = 0;
Alex Lighte64300b2015-12-15 15:02:47 -08007365
Alex Light9139e002015-10-09 15:59:48 -07007366 // TODO Cleanup Needed: In the presence of default methods this optimization is rather dirty
7367 // and confusing. Default methods should always look through all the superclasses
7368 // because they are the last choice of an implementation. We get around this by looking
7369 // at the super-classes iftable methods (copied into method_array previously) when we are
7370 // looking for the implementation of a super-interface method but that is rather dirty.
Alex Lighte64300b2015-12-15 15:02:47 -08007371 bool using_virtuals;
Alex Light705ad492015-09-21 11:36:30 -07007372 if (super_interface || is_interface) {
Alex Lighte64300b2015-12-15 15:02:47 -08007373 // If we are overwriting a super class interface, try to only virtual methods instead of the
Mathieu Chartiere401d142015-04-22 13:56:20 -07007374 // whole vtable.
Alex Lighte64300b2015-12-15 15:02:47 -08007375 using_virtuals = true;
7376 input_virtual_methods = klass->GetDeclaredMethodsSlice(image_pointer_size_);
7377 input_array_length = input_virtual_methods.size();
Mathieu Chartiere401d142015-04-22 13:56:20 -07007378 } else {
Alex Lighte64300b2015-12-15 15:02:47 -08007379 // For a new interface, however, we need the whole vtable in case a new
7380 // interface method is implemented in the whole superclass.
7381 using_virtuals = false;
Andreas Gampefa4333d2017-02-14 11:10:34 -08007382 DCHECK(vtable != nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007383 input_vtable_array = vtable;
7384 input_array_length = input_vtable_array->GetLength();
7385 }
Alex Lighte64300b2015-12-15 15:02:47 -08007386
Alex Lighteb7c1442015-08-31 13:17:42 -07007387 // For each method in interface
Ian Rogers62d6c772013-02-27 08:32:07 -08007388 for (size_t j = 0; j < num_methods; ++j) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007389 auto* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07007390 MethodNameAndSignatureComparator interface_name_comparator(
Mathieu Chartiere401d142015-04-22 13:56:20 -07007391 interface_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Andreas Gampe75a7db62016-09-26 12:04:26 -07007392 uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Alex Lighteb7c1442015-08-31 13:17:42 -07007393 ArtMethod** imt_ptr = &out_imt[imt_index];
Ian Rogers9bc81912012-10-11 21:43:36 -07007394 // For each method listed in the interface's method list, find the
7395 // matching method in our class's method list. We want to favor the
7396 // subclass over the superclass, which just requires walking
7397 // back from the end of the vtable. (This only matters if the
7398 // superclass defines a private method and this class redefines
7399 // it -- otherwise it would use the same vtable slot. In .dex files
7400 // those don't end up in the virtual method table, so it shouldn't
7401 // matter which direction we go. We walk it backward anyway.)
Alex Lighteb7c1442015-08-31 13:17:42 -07007402 //
7403 // To find defaults we need to do the same but also go over interfaces.
7404 bool found_impl = false;
Alex Light9139e002015-10-09 15:59:48 -07007405 ArtMethod* vtable_impl = nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07007406 for (int32_t k = input_array_length - 1; k >= 0; --k) {
Alex Lighte64300b2015-12-15 15:02:47 -08007407 ArtMethod* vtable_method = using_virtuals ?
7408 &input_virtual_methods[k] :
Mathieu Chartiere401d142015-04-22 13:56:20 -07007409 input_vtable_array->GetElementPtrSize<ArtMethod*>(k, image_pointer_size_);
7410 ArtMethod* vtable_method_for_name_comparison =
7411 vtable_method->GetInterfaceMethodIfProxy(image_pointer_size_);
Ian Rogers03b6eaf2014-10-28 09:34:57 -07007412 if (interface_name_comparator.HasSameNameAndSignature(
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07007413 vtable_method_for_name_comparison)) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07007414 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Mathieu Chartier4d122c12015-06-17 14:14:36 -07007415 // Must do EndAssertNoThreadSuspension before throw since the throw can cause
7416 // allocations.
7417 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007418 ThrowIllegalAccessError(klass.Get(),
Brian Carlstromf3632832014-05-20 15:36:53 -07007419 "Method '%s' implementing interface method '%s' is not public",
David Sehr709b0702016-10-13 09:12:37 -07007420 vtable_method->PrettyMethod().c_str(),
7421 interface_method->PrettyMethod().c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07007422 return false;
Alex Light9139e002015-10-09 15:59:48 -07007423 } else if (UNLIKELY(vtable_method->IsOverridableByDefaultMethod())) {
Alex Lighteb7c1442015-08-31 13:17:42 -07007424 // We might have a newer, better, default method for this, so we just skip it. If we
7425 // are still using this we will select it again when scanning for default methods. To
7426 // obviate the need to copy the method again we will make a note that we already found
7427 // a default here.
7428 // TODO This should be much cleaner.
Alex Light9139e002015-10-09 15:59:48 -07007429 vtable_impl = vtable_method;
Alex Lighteb7c1442015-08-31 13:17:42 -07007430 break;
7431 } else {
7432 found_impl = true;
Alex Light705ad492015-09-21 11:36:30 -07007433 if (LIKELY(fill_tables)) {
7434 method_array->SetElementPtrSize(j, vtable_method, image_pointer_size_);
7435 // Place method in imt if entry is empty, place conflict otherwise.
7436 SetIMTRef(unimplemented_method,
7437 imt_conflict_method,
Alex Light705ad492015-09-21 11:36:30 -07007438 vtable_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007439 /*out*/out_new_conflict,
Alex Light705ad492015-09-21 11:36:30 -07007440 /*out*/imt_ptr);
7441 }
Ian Rogers9bc81912012-10-11 21:43:36 -07007442 break;
7443 }
7444 }
Alex Light9139e002015-10-09 15:59:48 -07007445 }
7446 // Continue on to the next method if we are done.
7447 if (LIKELY(found_impl)) {
7448 continue;
7449 } else if (LIKELY(super_interface)) {
7450 // Don't look for a default implementation when the super-method is implemented directly
7451 // by the class.
7452 //
7453 // See if we can use the superclasses method and skip searching everything else.
7454 // Note: !found_impl && super_interface
7455 CHECK(extend_super_iftable);
7456 // If this is a super_interface method it is possible we shouldn't override it because a
7457 // superclass could have implemented it directly. We get the method the superclass used
7458 // to implement this to know if we can override it with a default method. Doing this is
7459 // safe since we know that the super_iftable is filled in so we can simply pull it from
7460 // there. We don't bother if this is not a super-classes interface since in that case we
7461 // have scanned the entire vtable anyway and would have found it.
7462 // TODO This is rather dirty but it is faster than searching through the entire vtable
7463 // every time.
7464 ArtMethod* supers_method =
7465 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
7466 DCHECK(supers_method != nullptr);
7467 DCHECK(interface_name_comparator.HasSameNameAndSignature(supers_method));
Alex Light705ad492015-09-21 11:36:30 -07007468 if (LIKELY(!supers_method->IsOverridableByDefaultMethod())) {
Alex Light9139e002015-10-09 15:59:48 -07007469 // The method is not overridable by a default method (i.e. it is directly implemented
7470 // in some class). Therefore move onto the next interface method.
7471 continue;
Alex Lightd6c2bfa2016-05-02 18:51:34 -07007472 } else {
7473 // If the super-classes method is override-able by a default method we need to keep
7474 // track of it since though it is override-able it is not guaranteed to be 'overridden'.
7475 // 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 -07007476 // to the vtable twice, causing corruption (vtable entries having inconsistent and
7477 // illegal states, incorrect vtable size, and incorrect or inconsistent iftable entries)
7478 // in this class and any subclasses.
Alex Lightd6c2bfa2016-05-02 18:51:34 -07007479 DCHECK(vtable_impl == nullptr || vtable_impl == supers_method)
David Sehr709b0702016-10-13 09:12:37 -07007480 << "vtable_impl was " << ArtMethod::PrettyMethod(vtable_impl)
7481 << " and not 'nullptr' or "
7482 << supers_method->PrettyMethod()
7483 << " as expected. IFTable appears to be corrupt!";
Alex Lightd6c2bfa2016-05-02 18:51:34 -07007484 vtable_impl = supers_method;
Alex Light9139e002015-10-09 15:59:48 -07007485 }
7486 }
7487 // If we haven't found it yet we should search through the interfaces for default methods.
Vladimir Marko921094a2017-01-12 18:37:06 +00007488 ArtMethod* current_method = helper.FindMethod(interface_method,
7489 interface_name_comparator,
7490 vtable_impl);
Alex Light705ad492015-09-21 11:36:30 -07007491 if (LIKELY(fill_tables)) {
Alex Light12771082016-01-26 16:07:41 -08007492 if (current_method == nullptr && !super_interface) {
Alex Light705ad492015-09-21 11:36:30 -07007493 // We could not find an implementation for this method and since it is a brand new
7494 // interface we searched the entire vtable (and all default methods) for an
7495 // implementation but couldn't find one. We therefore need to make a miranda method.
Vladimir Marko921094a2017-01-12 18:37:06 +00007496 current_method = helper.GetOrCreateMirandaMethod(interface_method,
7497 interface_name_comparator);
Alex Light12771082016-01-26 16:07:41 -08007498 }
7499
7500 if (current_method != nullptr) {
7501 // We found a default method implementation. Record it in the iftable and IMT.
7502 method_array->SetElementPtrSize(j, current_method, image_pointer_size_);
7503 SetIMTRef(unimplemented_method,
7504 imt_conflict_method,
Alex Light12771082016-01-26 16:07:41 -08007505 current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007506 /*out*/out_new_conflict,
Alex Light12771082016-01-26 16:07:41 -08007507 /*out*/imt_ptr);
Alex Light9139e002015-10-09 15:59:48 -07007508 }
7509 }
Alex Light705ad492015-09-21 11:36:30 -07007510 } // For each method in interface end.
7511 } // if (num_methods > 0)
7512 } // For each interface.
Alex Light705ad492015-09-21 11:36:30 -07007513 // TODO don't extend virtuals of interface unless necessary (when is it?).
Vladimir Marko921094a2017-01-12 18:37:06 +00007514 if (helper.HasNewVirtuals()) {
7515 LengthPrefixedArray<ArtMethod>* old_methods = kIsDebugBuild ? klass->GetMethodsPtr() : nullptr;
7516 helper.ReallocMethods(); // No return value to check. Native allocation failure aborts.
7517 LengthPrefixedArray<ArtMethod>* methods = kIsDebugBuild ? klass->GetMethodsPtr() : nullptr;
7518
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007519 // 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 -07007520 // suspension assert.
7521 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007522
Alex Light705ad492015-09-21 11:36:30 -07007523 if (fill_tables) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007524 vtable.Assign(helper.UpdateVtable(default_translations, vtable.Get()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08007525 if (UNLIKELY(vtable == nullptr)) {
Vladimir Marko921094a2017-01-12 18:37:06 +00007526 // The helper has already called self->AssertPendingOOMException();
Alex Light705ad492015-09-21 11:36:30 -07007527 return false;
7528 }
Vladimir Marko921094a2017-01-12 18:37:06 +00007529 helper.UpdateIfTable(iftable);
7530 helper.UpdateIMT(out_imt);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007531 }
Alex Light705ad492015-09-21 11:36:30 -07007532
Vladimir Marko921094a2017-01-12 18:37:06 +00007533 helper.CheckNoStaleMethodsInDexCache();
7534 helper.ClobberOldMethods(old_methods, methods);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007535 } else {
7536 self->EndAssertNoThreadSuspension(old_cause);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007537 }
Alex Light705ad492015-09-21 11:36:30 -07007538 if (kIsDebugBuild && !is_interface) {
Alex Light1f3925d2016-09-07 12:04:20 -07007539 SanityCheckVTable(self, klass, image_pointer_size_);
Elliott Hughes4681c802011-09-25 18:04:37 -07007540 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007541 return true;
7542}
7543
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007544bool ClassLinker::LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007545 CHECK(klass != nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007546 return LinkFields(self, klass, false, nullptr);
Brian Carlstrom4873d462011-08-21 15:23:39 -07007547}
7548
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007549bool ClassLinker::LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007550 CHECK(klass != nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007551 return LinkFields(self, klass, true, class_size);
Brian Carlstrom4873d462011-08-21 15:23:39 -07007552}
7553
Brian Carlstromdbc05252011-09-09 01:59:59 -07007554struct LinkFieldsComparator {
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07007555 explicit LinkFieldsComparator() REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07007556 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07007557 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Mathieu Chartierc7853442015-03-27 14:35:38 -07007558 bool operator()(ArtField* field1, ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08007559 NO_THREAD_SAFETY_ANALYSIS {
Fred Shih37f05ef2014-07-16 18:38:08 -07007560 // 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 -07007561 Primitive::Type type1 = field1->GetTypeAsPrimitiveType();
7562 Primitive::Type type2 = field2->GetTypeAsPrimitiveType();
Ian Rogersef7d42f2014-01-06 12:55:46 -08007563 if (type1 != type2) {
Vladimir Markod5777482014-11-12 17:02:02 +00007564 if (type1 == Primitive::kPrimNot) {
7565 // Reference always goes first.
7566 return true;
Ian Rogersef7d42f2014-01-06 12:55:46 -08007567 }
Vladimir Markod5777482014-11-12 17:02:02 +00007568 if (type2 == Primitive::kPrimNot) {
7569 // Reference always goes first.
7570 return false;
7571 }
7572 size_t size1 = Primitive::ComponentSize(type1);
7573 size_t size2 = Primitive::ComponentSize(type2);
7574 if (size1 != size2) {
7575 // Larger primitive types go first.
7576 return size1 > size2;
7577 }
7578 // Primitive types differ but sizes match. Arbitrarily order by primitive type.
7579 return type1 < type2;
Brian Carlstromdbc05252011-09-09 01:59:59 -07007580 }
Vladimir Marko7a7c1db2014-11-17 15:13:34 +00007581 // Same basic group? Then sort by dex field index. This is guaranteed to be sorted
7582 // by name and for equal names by type id index.
7583 // NOTE: This works also for proxies. Their static fields are assigned appropriate indexes.
7584 return field1->GetDexFieldIndex() < field2->GetDexFieldIndex();
Brian Carlstromdbc05252011-09-09 01:59:59 -07007585 }
7586};
7587
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007588bool ClassLinker::LinkFields(Thread* self,
7589 Handle<mirror::Class> klass,
7590 bool is_static,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007591 size_t* class_size) {
Ian Rogers7b078e82014-09-10 14:44:24 -07007592 self->AllowThreadSuspension();
Mathieu Chartierc7853442015-03-27 14:35:38 -07007593 const size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007594 LengthPrefixedArray<ArtField>* const fields = is_static ? klass->GetSFieldsPtr() :
7595 klass->GetIFieldsPtr();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007596
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007597 // Initialize field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07007598 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007599 if (is_static) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007600 field_offset = klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007601 } else {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007602 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007603 if (super_class != nullptr) {
Brian Carlstromf3632832014-05-20 15:36:53 -07007604 CHECK(super_class->IsResolved())
David Sehr709b0702016-10-13 09:12:37 -07007605 << klass->PrettyClass() << " " << super_class->PrettyClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007606 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007607 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007608 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007609
David Sehr709b0702016-10-13 09:12:37 -07007610 CHECK_EQ(num_fields == 0, fields == nullptr) << klass->PrettyClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007611
Brian Carlstromdbc05252011-09-09 01:59:59 -07007612 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07007613 // minimizes disruption of C++ version such as Class and Method.
Alex Lighte64300b2015-12-15 15:02:47 -08007614 //
7615 // The overall sort order order is:
7616 // 1) All object reference fields, sorted alphabetically.
7617 // 2) All java long (64-bit) integer fields, sorted alphabetically.
7618 // 3) All java double (64-bit) floating point fields, sorted alphabetically.
7619 // 4) All java int (32-bit) integer fields, sorted alphabetically.
7620 // 5) All java float (32-bit) floating point fields, sorted alphabetically.
7621 // 6) All java char (16-bit) integer fields, sorted alphabetically.
7622 // 7) All java short (16-bit) integer fields, sorted alphabetically.
7623 // 8) All java boolean (8-bit) integer fields, sorted alphabetically.
7624 // 9) All java byte (8-bit) integer fields, sorted alphabetically.
7625 //
7626 // Once the fields are sorted in this order we will attempt to fill any gaps that might be present
7627 // in the memory layout of the structure. See ShuffleForward for how this is done.
Mathieu Chartierc7853442015-03-27 14:35:38 -07007628 std::deque<ArtField*> grouped_and_sorted_fields;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07007629 const char* old_no_suspend_cause = self->StartAssertNoThreadSuspension(
Fred Shih37f05ef2014-07-16 18:38:08 -07007630 "Naked ArtField references in deque");
Brian Carlstromdbc05252011-09-09 01:59:59 -07007631 for (size_t i = 0; i < num_fields; i++) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007632 grouped_and_sorted_fields.push_back(&fields->At(i));
Brian Carlstromdbc05252011-09-09 01:59:59 -07007633 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07007634 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
7635 LinkFieldsComparator());
Brian Carlstromdbc05252011-09-09 01:59:59 -07007636
Fred Shih381e4ca2014-08-25 17:24:27 -07007637 // References should be at the front.
Brian Carlstromdbc05252011-09-09 01:59:59 -07007638 size_t current_field = 0;
7639 size_t num_reference_fields = 0;
Fred Shih381e4ca2014-08-25 17:24:27 -07007640 FieldGaps gaps;
7641
Brian Carlstromdbc05252011-09-09 01:59:59 -07007642 for (; current_field < num_fields; current_field++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07007643 ArtField* field = grouped_and_sorted_fields.front();
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07007644 Primitive::Type type = field->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07007645 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07007646 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07007647 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007648 }
Vladimir Marko76649e82014-11-10 18:32:59 +00007649 if (UNLIKELY(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(
7650 field_offset.Uint32Value()))) {
Fred Shih381e4ca2014-08-25 17:24:27 -07007651 MemberOffset old_offset = field_offset;
7652 field_offset = MemberOffset(RoundUp(field_offset.Uint32Value(), 4));
7653 AddFieldGap(old_offset.Uint32Value(), field_offset.Uint32Value(), &gaps);
7654 }
Roland Levillain14d90572015-07-16 10:52:26 +01007655 DCHECK_ALIGNED(field_offset.Uint32Value(), sizeof(mirror::HeapReference<mirror::Object>));
Brian Carlstromdbc05252011-09-09 01:59:59 -07007656 grouped_and_sorted_fields.pop_front();
7657 num_reference_fields++;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007658 field->SetOffset(field_offset);
Vladimir Marko76649e82014-11-10 18:32:59 +00007659 field_offset = MemberOffset(field_offset.Uint32Value() +
7660 sizeof(mirror::HeapReference<mirror::Object>));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007661 }
Fred Shih381e4ca2014-08-25 17:24:27 -07007662 // Gaps are stored as a max heap which means that we must shuffle from largest to smallest
7663 // otherwise we could end up with suboptimal gap fills.
Vladimir Marko76649e82014-11-10 18:32:59 +00007664 ShuffleForward<8>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7665 ShuffleForward<4>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7666 ShuffleForward<2>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7667 ShuffleForward<1>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
Fred Shih37f05ef2014-07-16 18:38:08 -07007668 CHECK(grouped_and_sorted_fields.empty()) << "Missed " << grouped_and_sorted_fields.size() <<
7669 " fields.";
Ian Rogers7b078e82014-09-10 14:44:24 -07007670 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007671
Elliott Hughesadb460d2011-10-05 17:02:34 -07007672 // 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 -07007673 if (!is_static && klass->DescriptorEquals("Ljava/lang/ref/Reference;")) {
Elliott Hughesadb460d2011-10-05 17:02:34 -07007674 // We know there are no non-reference fields in the Reference classes, and we know
7675 // that 'referent' is alphabetically last, so this is easy...
David Sehr709b0702016-10-13 09:12:37 -07007676 CHECK_EQ(num_reference_fields, num_fields) << klass->PrettyClass();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007677 CHECK_STREQ(fields->At(num_fields - 1).GetName(), "referent")
David Sehr709b0702016-10-13 09:12:37 -07007678 << klass->PrettyClass();
Elliott Hughesadb460d2011-10-05 17:02:34 -07007679 --num_reference_fields;
7680 }
7681
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007682 size_t size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007683 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007684 if (is_static) {
7685 klass->SetNumReferenceStaticFields(num_reference_fields);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007686 *class_size = size;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007687 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007688 klass->SetNumReferenceInstanceFields(num_reference_fields);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007689 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007690 if (num_reference_fields == 0 || super_class == nullptr) {
7691 // object has one reference field, klass, but we ignore it since we always visit the class.
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007692 // super_class is null iff the class is java.lang.Object.
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007693 if (super_class == nullptr ||
7694 (super_class->GetClassFlags() & mirror::kClassFlagNoReferenceFields) != 0) {
7695 klass->SetClassFlags(klass->GetClassFlags() | mirror::kClassFlagNoReferenceFields);
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007696 }
7697 }
7698 if (kIsDebugBuild) {
7699 DCHECK_EQ(super_class == nullptr, klass->DescriptorEquals("Ljava/lang/Object;"));
7700 size_t total_reference_instance_fields = 0;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007701 ObjPtr<mirror::Class> cur_super = klass.Get();
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007702 while (cur_super != nullptr) {
7703 total_reference_instance_fields += cur_super->NumReferenceInstanceFieldsDuringLinking();
7704 cur_super = cur_super->GetSuperClass();
7705 }
7706 if (super_class == nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07007707 CHECK_EQ(total_reference_instance_fields, 1u) << klass->PrettyDescriptor();
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007708 } else {
7709 // Check that there is at least num_reference_fields other than Object.class.
7710 CHECK_GE(total_reference_instance_fields, 1u + num_reference_fields)
David Sehr709b0702016-10-13 09:12:37 -07007711 << klass->PrettyClass();
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007712 }
7713 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07007714 if (!klass->IsVariableSize()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007715 std::string temp;
7716 DCHECK_GE(size, sizeof(mirror::Object)) << klass->GetDescriptor(&temp);
7717 size_t previous_size = klass->GetObjectSize();
7718 if (previous_size != 0) {
7719 // Make sure that we didn't originally have an incorrect size.
7720 CHECK_EQ(previous_size, size) << klass->GetDescriptor(&temp);
Mathieu Chartier79b4f382013-10-23 15:21:37 -07007721 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07007722 klass->SetObjectSize(size);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007723 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007724 }
Vladimir Marko76649e82014-11-10 18:32:59 +00007725
7726 if (kIsDebugBuild) {
7727 // Make sure that the fields array is ordered by name but all reference
7728 // offsets are at the beginning as far as alignment allows.
7729 MemberOffset start_ref_offset = is_static
Mathieu Chartiere401d142015-04-22 13:56:20 -07007730 ? klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_)
Vladimir Marko76649e82014-11-10 18:32:59 +00007731 : klass->GetFirstReferenceInstanceFieldOffset();
7732 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() +
7733 num_reference_fields *
7734 sizeof(mirror::HeapReference<mirror::Object>));
7735 MemberOffset current_ref_offset = start_ref_offset;
7736 for (size_t i = 0; i < num_fields; i++) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007737 ArtField* field = &fields->At(i);
Mathieu Chartierc7853442015-03-27 14:35:38 -07007738 VLOG(class_linker) << "LinkFields: " << (is_static ? "static" : "instance")
David Sehr709b0702016-10-13 09:12:37 -07007739 << " class=" << klass->PrettyClass() << " field=" << field->PrettyField()
7740 << " offset=" << field->GetOffsetDuringLinking();
Vladimir Marko76649e82014-11-10 18:32:59 +00007741 if (i != 0) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007742 ArtField* const prev_field = &fields->At(i - 1);
Vladimir Marko7a7c1db2014-11-17 15:13:34 +00007743 // NOTE: The field names can be the same. This is not possible in the Java language
7744 // but it's valid Java/dex bytecode and for example proguard can generate such bytecode.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007745 DCHECK_LE(strcmp(prev_field->GetName(), field->GetName()), 0);
Vladimir Marko76649e82014-11-10 18:32:59 +00007746 }
7747 Primitive::Type type = field->GetTypeAsPrimitiveType();
7748 bool is_primitive = type != Primitive::kPrimNot;
7749 if (klass->DescriptorEquals("Ljava/lang/ref/Reference;") &&
7750 strcmp("referent", field->GetName()) == 0) {
7751 is_primitive = true; // We lied above, so we have to expect a lie here.
7752 }
7753 MemberOffset offset = field->GetOffsetDuringLinking();
7754 if (is_primitive) {
7755 if (offset.Uint32Value() < end_ref_offset.Uint32Value()) {
7756 // Shuffled before references.
7757 size_t type_size = Primitive::ComponentSize(type);
7758 CHECK_LT(type_size, sizeof(mirror::HeapReference<mirror::Object>));
7759 CHECK_LT(offset.Uint32Value(), start_ref_offset.Uint32Value());
7760 CHECK_LE(offset.Uint32Value() + type_size, start_ref_offset.Uint32Value());
7761 CHECK(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(offset.Uint32Value()));
7762 }
7763 } else {
7764 CHECK_EQ(current_ref_offset.Uint32Value(), offset.Uint32Value());
7765 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() +
7766 sizeof(mirror::HeapReference<mirror::Object>));
7767 }
7768 }
7769 CHECK_EQ(current_ref_offset.Uint32Value(), end_ref_offset.Uint32Value());
7770 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007771 return true;
7772}
7773
Vladimir Marko76649e82014-11-10 18:32:59 +00007774// Set the bitmap of reference instance field offsets.
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007775void ClassLinker::CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007776 uint32_t reference_offsets = 0;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007777 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007778 // Leave the reference offsets as 0 for mirror::Object (the class field is handled specially).
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007779 if (super_class != nullptr) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007780 reference_offsets = super_class->GetReferenceInstanceOffsets();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007781 // Compute reference offsets unless our superclass overflowed.
7782 if (reference_offsets != mirror::Class::kClassWalkSuper) {
7783 size_t num_reference_fields = klass->NumReferenceInstanceFieldsDuringLinking();
Vladimir Marko76649e82014-11-10 18:32:59 +00007784 if (num_reference_fields != 0u) {
7785 // All of the fields that contain object references are guaranteed be grouped in memory
7786 // starting at an appropriately aligned address after super class object data.
7787 uint32_t start_offset = RoundUp(super_class->GetObjectSize(),
7788 sizeof(mirror::HeapReference<mirror::Object>));
7789 uint32_t start_bit = (start_offset - mirror::kObjectHeaderSize) /
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007790 sizeof(mirror::HeapReference<mirror::Object>);
Vladimir Marko76649e82014-11-10 18:32:59 +00007791 if (start_bit + num_reference_fields > 32) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007792 reference_offsets = mirror::Class::kClassWalkSuper;
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007793 } else {
Vladimir Marko76649e82014-11-10 18:32:59 +00007794 reference_offsets |= (0xffffffffu << start_bit) &
7795 (0xffffffffu >> (32 - (start_bit + num_reference_fields)));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007796 }
7797 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07007798 }
7799 }
Mingyao Yangfaff0f02014-09-10 12:03:22 -07007800 klass->SetReferenceInstanceOffsets(reference_offsets);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007801}
7802
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007803mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
Andreas Gampe8a0128a2016-11-28 07:38:35 -08007804 dex::StringIndex string_idx,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007805 Handle<mirror::DexCache> dex_cache) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007806 DCHECK(dex_cache != nullptr);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007807 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007808 ObjPtr<mirror::String> resolved = dex_cache->GetResolvedString(string_idx);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007809 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007810 return resolved.Ptr();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007811 }
Ian Rogersdfb325e2013-10-30 01:00:44 -07007812 uint32_t utf16_length;
7813 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007814 ObjPtr<mirror::String> string = intern_table_->InternStrong(utf16_length, utf8_data);
Vladimir Marko8d6768d2017-03-14 10:13:21 +00007815 if (string != nullptr) {
7816 dex_cache->SetResolvedString(string_idx, string);
7817 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007818 return string.Ptr();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007819}
7820
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007821mirror::String* ClassLinker::LookupString(const DexFile& dex_file,
Andreas Gampe8a0128a2016-11-28 07:38:35 -08007822 dex::StringIndex string_idx,
Vladimir Markof25cc732017-03-16 16:18:15 +00007823 ObjPtr<mirror::DexCache> dex_cache) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007824 DCHECK(dex_cache != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007825 ObjPtr<mirror::String> resolved = dex_cache->GetResolvedString(string_idx);
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007826 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007827 return resolved.Ptr();
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007828 }
7829 uint32_t utf16_length;
7830 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Andreas Gampe8a0128a2016-11-28 07:38:35 -08007831 ObjPtr<mirror::String> string =
7832 intern_table_->LookupStrong(Thread::Current(), utf16_length, utf8_data);
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007833 if (string != nullptr) {
7834 dex_cache->SetResolvedString(string_idx, string);
7835 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007836 return string.Ptr();
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007837}
7838
Mathieu Chartierb8901302016-09-30 10:27:43 -07007839ObjPtr<mirror::Class> ClassLinker::LookupResolvedType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007840 dex::TypeIndex type_idx,
Mathieu Chartierb8901302016-09-30 10:27:43 -07007841 ObjPtr<mirror::DexCache> dex_cache,
7842 ObjPtr<mirror::ClassLoader> class_loader) {
7843 ObjPtr<mirror::Class> type = dex_cache->GetResolvedType(type_idx);
7844 if (type == nullptr) {
7845 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
7846 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
7847 if (descriptor[1] == '\0') {
7848 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
7849 // for primitive classes that aren't backed by dex files.
7850 type = FindPrimitiveClass(descriptor[0]);
7851 } else {
7852 Thread* const self = Thread::Current();
7853 DCHECK(self != nullptr);
7854 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
7855 // Find the class in the loaded classes table.
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07007856 type = LookupClass(self, descriptor, hash, class_loader.Ptr());
Mathieu Chartierb8901302016-09-30 10:27:43 -07007857 }
Vladimir Marko8d6768d2017-03-14 10:13:21 +00007858 if (type != nullptr) {
7859 if (type->IsResolved()) {
7860 dex_cache->SetResolvedType(type_idx, type);
7861 } else {
7862 type = nullptr;
7863 }
7864 }
Mathieu Chartierb8901302016-09-30 10:27:43 -07007865 }
Vladimir Marko8d6768d2017-03-14 10:13:21 +00007866 DCHECK(type == nullptr || type->IsResolved());
7867 return type;
Mathieu Chartierb8901302016-09-30 10:27:43 -07007868}
7869
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007870mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007871 dex::TypeIndex type_idx,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007872 ObjPtr<mirror::Class> referrer) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007873 StackHandleScope<2> hs(Thread::Current());
7874 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
7875 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
Mathieu Chartier590fee92013-09-13 13:46:47 -07007876 return ResolveType(dex_file, type_idx, dex_cache, class_loader);
7877}
7878
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007879mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007880 dex::TypeIndex type_idx,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007881 Handle<mirror::DexCache> dex_cache,
7882 Handle<mirror::ClassLoader> class_loader) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007883 DCHECK(dex_cache != nullptr);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007884 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007885 ObjPtr<mirror::Class> resolved = dex_cache->GetResolvedType(type_idx);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007886 if (resolved == nullptr) {
Vladimir Marko8d6768d2017-03-14 10:13:21 +00007887 // TODO: Avoid this lookup as it duplicates work done in FindClass(). It is here
7888 // as a workaround for FastNative JNI to avoid AssertNoPendingException() when
7889 // trying to resolve annotations while an exception may be pending. Bug: 34659969
7890 resolved = LookupResolvedType(dex_file, type_idx, dex_cache.Get(), class_loader.Get());
7891 }
7892 if (resolved == nullptr) {
Ian Rogers98379392014-02-24 16:53:16 -08007893 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07007894 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Ian Rogers98379392014-02-24 16:53:16 -08007895 resolved = FindClass(self, descriptor, class_loader);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007896 if (resolved != nullptr) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05007897 // TODO: we used to throw here if resolved's class loader was not the
7898 // boot class loader. This was to permit different classes with the
7899 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007900 dex_cache->SetResolvedType(type_idx, resolved);
7901 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08007902 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08007903 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08007904 // Convert a ClassNotFoundException to a NoClassDefFoundError.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007905 StackHandleScope<1> hs(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00007906 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
Ian Rogers62d6c772013-02-27 08:32:07 -08007907 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007908 DCHECK(resolved == nullptr); // No Handle needed to preserve resolved.
Ian Rogers98379392014-02-24 16:53:16 -08007909 self->ClearException();
jeffhao8cd6dda2012-02-22 10:15:34 -08007910 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00007911 self->GetException()->SetCause(cause.Get());
jeffhao8cd6dda2012-02-22 10:15:34 -08007912 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007913 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007914 }
Vladimir Marko72ab6842017-01-20 19:32:50 +00007915 DCHECK((resolved == nullptr) || resolved->IsResolved())
David Sehr709b0702016-10-13 09:12:37 -07007916 << resolved->PrettyDescriptor() << " " << resolved->GetStatus();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007917 return resolved.Ptr();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007918}
7919
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007920template <ClassLinker::ResolveMode kResolveMode>
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007921ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
7922 uint32_t method_idx,
Mathieu Chartiere401d142015-04-22 13:56:20 -07007923 Handle<mirror::DexCache> dex_cache,
7924 Handle<mirror::ClassLoader> class_loader,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007925 ArtMethod* referrer,
7926 InvokeType type) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08007927 DCHECK(dex_cache != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07007928 // Check for hit in the dex cache.
Mathieu Chartiere401d142015-04-22 13:56:20 -07007929 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007930 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07007931 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007932 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex();
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007933 if (kResolveMode == ClassLinker::kForceICCECheck) {
7934 if (resolved->CheckIncompatibleClassChange(type)) {
7935 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer);
7936 return nullptr;
7937 }
7938 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007939 return resolved;
7940 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007941 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007942 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007943 ObjPtr<mirror::Class> klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007944 if (klass == nullptr) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07007945 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007946 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007947 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007948 // Scan using method_idx, this saves string compares but will only hit for matching dex
7949 // caches/files.
7950 switch (type) {
7951 case kDirect: // Fall-through.
7952 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007953 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7954 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07007955 break;
7956 case kInterface:
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007957 // We have to check whether the method id really belongs to an interface (dex static bytecode
7958 // constraint A15). Otherwise you must not invoke-interface on it.
7959 //
7960 // This is not symmetric to A12-A14 (direct, static, virtual), as using FindInterfaceMethod
7961 // assumes that the given type is an interface, and will check the interface table if the
7962 // method isn't declared in the class. So it may find an interface method (usually by name
7963 // in the handling below, but we do the constraint check early). In that case,
7964 // CheckIncompatibleClassChange will succeed (as it is called on an interface method)
7965 // unexpectedly.
7966 // Example:
7967 // interface I {
7968 // foo()
7969 // }
7970 // class A implements I {
7971 // ...
7972 // }
7973 // class B extends A {
7974 // ...
7975 // }
7976 // invoke-interface B.foo
7977 // -> FindInterfaceMethod finds I.foo (interface method), not A.foo (miranda method)
7978 if (UNLIKELY(!klass->IsInterface())) {
7979 ThrowIncompatibleClassChangeError(klass,
7980 "Found class %s, but interface was expected",
David Sehr709b0702016-10-13 09:12:37 -07007981 klass->PrettyDescriptor().c_str());
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007982 return nullptr;
7983 } else {
7984 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7985 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
7986 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007987 break;
Alex Light705ad492015-09-21 11:36:30 -07007988 case kSuper:
7989 if (klass->IsInterface()) {
7990 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7991 } else {
7992 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7993 }
7994 break;
Ian Rogers08f753d2012-08-24 14:35:25 -07007995 case kVirtual:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007996 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07007997 break;
7998 default:
7999 LOG(FATAL) << "Unreachable - invocation type: " << type;
Ian Rogers2c4257b2014-10-24 14:20:06 -07008000 UNREACHABLE();
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008001 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008002 if (resolved == nullptr) {
Ian Rogers08f753d2012-08-24 14:35:25 -07008003 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008004 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07008005 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07008006 switch (type) {
8007 case kDirect: // Fall-through.
8008 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008009 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_);
8010 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07008011 break;
8012 case kInterface:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008013 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008014 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07008015 break;
Alex Light705ad492015-09-21 11:36:30 -07008016 case kSuper:
8017 if (klass->IsInterface()) {
8018 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
8019 } else {
8020 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
8021 }
8022 break;
Ian Rogers08f753d2012-08-24 14:35:25 -07008023 case kVirtual:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008024 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07008025 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008026 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008027 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008028 // If we found a method, check for incompatible class changes.
8029 if (LIKELY(resolved != nullptr && !resolved->CheckIncompatibleClassChange(type))) {
Ian Rogers08f753d2012-08-24 14:35:25 -07008030 // Be a good citizen and update the dex cache to speed subsequent calls.
Mathieu Chartiere401d142015-04-22 13:56:20 -07008031 dex_cache->SetResolvedMethod(method_idx, resolved, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07008032 return resolved;
8033 } else {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008034 // If we had a method, it's an incompatible-class-change error.
8035 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008036 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008037 } else {
8038 // We failed to find the method which means either an access error, an incompatible class
8039 // change, or no such method. First try to find the method among direct and virtual methods.
8040 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
8041 const Signature signature = dex_file.GetMethodSignature(method_id);
8042 switch (type) {
8043 case kDirect:
8044 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008045 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008046 // Note: kDirect and kStatic are also mutually exclusive, but in that case we would
8047 // have had a resolved method before, which triggers the "true" branch above.
8048 break;
8049 case kInterface:
8050 case kVirtual:
8051 case kSuper:
Mathieu Chartiere401d142015-04-22 13:56:20 -07008052 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008053 break;
8054 }
8055
8056 // If we found something, check that it can be accessed by the referrer.
Ian Rogerse0a02da2014-12-02 14:10:53 -08008057 bool exception_generated = false;
Mathieu Chartiere401d142015-04-22 13:56:20 -07008058 if (resolved != nullptr && referrer != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008059 ObjPtr<mirror::Class> methods_class = resolved->GetDeclaringClass();
8060 ObjPtr<mirror::Class> referring_class = referrer->GetDeclaringClass();
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008061 if (!referring_class->CanAccess(methods_class)) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008062 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class,
8063 methods_class,
8064 resolved,
Mathieu Chartiere401d142015-04-22 13:56:20 -07008065 type);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008066 exception_generated = true;
Mathieu Chartiere401d142015-04-22 13:56:20 -07008067 } else if (!referring_class->CanAccessMember(methods_class, resolved->GetAccessFlags())) {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008068 ThrowIllegalAccessErrorMethod(referring_class, resolved);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008069 exception_generated = true;
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008070 }
8071 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008072 if (!exception_generated) {
8073 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check
8074 // interface methods and throw if we find the method there. If we find nothing, throw a
8075 // NoSuchMethodError.
8076 switch (type) {
8077 case kDirect:
8078 case kStatic:
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008079 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008080 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008081 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008082 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008083 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008084 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008085 } else {
8086 ThrowNoSuchMethodError(type, klass, name, signature);
8087 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008088 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008089 break;
8090 case kInterface:
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008091 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008092 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008093 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008094 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008095 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008096 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008097 } else {
8098 ThrowNoSuchMethodError(type, klass, name, signature);
8099 }
8100 }
8101 break;
8102 case kSuper:
8103 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008104 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008105 } else {
8106 ThrowNoSuchMethodError(type, klass, name, signature);
8107 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008108 break;
8109 case kVirtual:
8110 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008111 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008112 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008113 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008114 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07008115 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08008116 } else {
8117 ThrowNoSuchMethodError(type, klass, name, signature);
8118 }
8119 }
8120 break;
8121 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008122 }
Ian Rogers08f753d2012-08-24 14:35:25 -07008123 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08008124 Thread::Current()->AssertPendingException();
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07008125 return nullptr;
Ian Rogers08f753d2012-08-24 14:35:25 -07008126 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07008127}
8128
Jeff Hao13e748b2015-08-25 20:44:19 +00008129ArtMethod* ClassLinker::ResolveMethodWithoutInvokeType(const DexFile& dex_file,
8130 uint32_t method_idx,
8131 Handle<mirror::DexCache> dex_cache,
8132 Handle<mirror::ClassLoader> class_loader) {
8133 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008134 Thread::PoisonObjectPointersIfDebug();
Jeff Hao13e748b2015-08-25 20:44:19 +00008135 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
8136 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex();
8137 return resolved;
8138 }
8139 // Fail, get the declaring class.
8140 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008141 ObjPtr<mirror::Class> klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Jeff Hao13e748b2015-08-25 20:44:19 +00008142 if (klass == nullptr) {
8143 Thread::Current()->AssertPendingException();
8144 return nullptr;
8145 }
8146 if (klass->IsInterface()) {
David Sehr709b0702016-10-13 09:12:37 -07008147 LOG(FATAL) << "ResolveAmbiguousMethod: unexpected method in interface: "
8148 << klass->PrettyClass();
Jeff Hao13e748b2015-08-25 20:44:19 +00008149 return nullptr;
8150 }
8151
8152 // Search both direct and virtual methods
8153 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8154 if (resolved == nullptr) {
8155 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
8156 }
8157
8158 return resolved;
8159}
8160
Vladimir Markof44d36c2017-03-14 14:18:46 +00008161ArtField* ClassLinker::LookupResolvedField(uint32_t field_idx,
8162 ObjPtr<mirror::DexCache> dex_cache,
8163 ObjPtr<mirror::ClassLoader> class_loader,
8164 bool is_static) {
8165 const DexFile& dex_file = *dex_cache->GetDexFile();
8166 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
8167 ObjPtr<mirror::Class> klass = dex_cache->GetResolvedType(field_id.class_idx_);
8168 if (klass == nullptr) {
8169 klass = LookupResolvedType(dex_file, field_id.class_idx_, dex_cache, class_loader);
8170 }
8171 if (klass == nullptr) {
8172 // The class has not been resolved yet, so the field is also unresolved.
8173 return nullptr;
8174 }
8175 DCHECK(klass->IsResolved());
8176 Thread* self = is_static ? Thread::Current() : nullptr;
8177
8178 // First try to find a field declared directly by `klass` by the field index.
8179 ArtField* resolved_field = is_static
8180 ? mirror::Class::FindStaticField(self, klass, dex_cache, field_idx)
8181 : klass->FindInstanceField(dex_cache, field_idx);
8182
8183 if (resolved_field == nullptr) {
8184 // If not found in `klass` by field index, search the class hierarchy using the name and type.
8185 const char* name = dex_file.GetFieldName(field_id);
8186 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
8187 resolved_field = is_static
8188 ? mirror::Class::FindStaticField(self, klass, name, type)
8189 : klass->FindInstanceField(name, type);
8190 }
8191
8192 if (resolved_field != nullptr) {
8193 dex_cache->SetResolvedField(field_idx, resolved_field, image_pointer_size_);
8194 }
8195 return resolved_field;
8196}
8197
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008198ArtField* ClassLinker::ResolveField(const DexFile& dex_file,
8199 uint32_t field_idx,
Mathieu Chartierc7853442015-03-27 14:35:38 -07008200 Handle<mirror::DexCache> dex_cache,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008201 Handle<mirror::ClassLoader> class_loader,
8202 bool is_static) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08008203 DCHECK(dex_cache != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008204 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008205 Thread::PoisonObjectPointersIfDebug();
Andreas Gampe58a5af82014-07-31 16:23:49 -07008206 if (resolved != nullptr) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008207 return resolved;
8208 }
8209 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07008210 Thread* const self = Thread::Current();
Vladimir Marko19a4d372016-12-08 14:41:46 +00008211 ObjPtr<mirror::Class> klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
8212 if (klass == nullptr) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08008213 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe58a5af82014-07-31 16:23:49 -07008214 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008215 }
8216
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008217 if (is_static) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00008218 resolved = mirror::Class::FindStaticField(self, klass, dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008219 } else {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07008220 resolved = klass->FindInstanceField(dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07008221 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008222
Andreas Gampe58a5af82014-07-31 16:23:49 -07008223 if (resolved == nullptr) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008224 const char* name = dex_file.GetFieldName(field_id);
8225 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
8226 if (is_static) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07008227 resolved = mirror::Class::FindStaticField(self, klass, name, type);
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008228 } else {
8229 resolved = klass->FindInstanceField(name, type);
8230 }
Andreas Gampe58a5af82014-07-31 16:23:49 -07008231 if (resolved == nullptr) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00008232 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass, type, name);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008233 return nullptr;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08008234 }
Ian Rogersb067ac22011-12-13 18:05:09 -08008235 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07008236 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_);
Ian Rogersb067ac22011-12-13 18:05:09 -08008237 return resolved;
8238}
8239
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008240ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
8241 uint32_t field_idx,
Mathieu Chartierc7853442015-03-27 14:35:38 -07008242 Handle<mirror::DexCache> dex_cache,
8243 Handle<mirror::ClassLoader> class_loader) {
Andreas Gampefa4333d2017-02-14 11:10:34 -08008244 DCHECK(dex_cache != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008245 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07008246 Thread::PoisonObjectPointersIfDebug();
Andreas Gampe58a5af82014-07-31 16:23:49 -07008247 if (resolved != nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08008248 return resolved;
8249 }
8250 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07008251 Thread* self = Thread::Current();
Vladimir Marko19a4d372016-12-08 14:41:46 +00008252 ObjPtr<mirror::Class> klass(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader));
8253 if (klass == nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08008254 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008255 return nullptr;
Ian Rogersb067ac22011-12-13 18:05:09 -08008256 }
8257
Vladimir Markof44d36c2017-03-14 14:18:46 +00008258 StringPiece name(dex_file.GetFieldName(field_id));
8259 StringPiece type(dex_file.GetFieldTypeDescriptor(field_id));
Mathieu Chartierf8322842014-05-16 10:59:25 -07008260 resolved = mirror::Class::FindField(self, klass, name, type);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008261 if (resolved != nullptr) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07008262 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_);
Ian Rogersb067ac22011-12-13 18:05:09 -08008263 } else {
Vladimir Marko19a4d372016-12-08 14:41:46 +00008264 ThrowNoSuchFieldError("", klass, type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07008265 }
8266 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07008267}
8268
Narayan Kamath25352fc2016-08-03 12:46:58 +01008269mirror::MethodType* ClassLinker::ResolveMethodType(const DexFile& dex_file,
8270 uint32_t proto_idx,
8271 Handle<mirror::DexCache> dex_cache,
8272 Handle<mirror::ClassLoader> class_loader) {
8273 DCHECK(Runtime::Current()->IsMethodHandlesEnabled());
Andreas Gampefa4333d2017-02-14 11:10:34 -08008274 DCHECK(dex_cache != nullptr);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008275
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008276 ObjPtr<mirror::MethodType> resolved = dex_cache->GetResolvedMethodType(proto_idx);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008277 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008278 return resolved.Ptr();
Narayan Kamath25352fc2016-08-03 12:46:58 +01008279 }
8280
8281 Thread* const self = Thread::Current();
8282 StackHandleScope<4> hs(self);
8283
8284 // First resolve the return type.
8285 const DexFile::ProtoId& proto_id = dex_file.GetProtoId(proto_idx);
8286 Handle<mirror::Class> return_type(hs.NewHandle(
8287 ResolveType(dex_file, proto_id.return_type_idx_, dex_cache, class_loader)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008288 if (return_type == nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01008289 DCHECK(self->IsExceptionPending());
8290 return nullptr;
8291 }
8292
8293 // Then resolve the argument types.
8294 //
8295 // TODO: Is there a better way to figure out the number of method arguments
8296 // other than by looking at the shorty ?
8297 const size_t num_method_args = strlen(dex_file.StringDataByIdx(proto_id.shorty_idx_)) - 1;
8298
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008299 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008300 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008301 Handle<mirror::ObjectArray<mirror::Class>> method_params(hs.NewHandle(
8302 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, num_method_args)));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008303 if (method_params == nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01008304 DCHECK(self->IsExceptionPending());
8305 return nullptr;
8306 }
8307
8308 DexFileParameterIterator it(dex_file, proto_id);
8309 int32_t i = 0;
8310 MutableHandle<mirror::Class> param_class = hs.NewHandle<mirror::Class>(nullptr);
8311 for (; it.HasNext(); it.Next()) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08008312 const dex::TypeIndex type_idx = it.GetTypeIdx();
Narayan Kamath25352fc2016-08-03 12:46:58 +01008313 param_class.Assign(ResolveType(dex_file, type_idx, dex_cache, class_loader));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008314 if (param_class == nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01008315 DCHECK(self->IsExceptionPending());
8316 return nullptr;
8317 }
8318
8319 method_params->Set(i++, param_class.Get());
8320 }
8321
8322 DCHECK(!it.HasNext());
8323
8324 Handle<mirror::MethodType> type = hs.NewHandle(
8325 mirror::MethodType::Create(self, return_type, method_params));
8326 dex_cache->SetResolvedMethodType(proto_idx, type.Get());
8327
8328 return type.Get();
8329}
8330
Orion Hodsonc069a302017-01-18 09:23:12 +00008331mirror::MethodHandle* ClassLinker::ResolveMethodHandle(uint32_t method_handle_idx,
8332 ArtMethod* referrer)
8333 REQUIRES_SHARED(Locks::mutator_lock_) {
8334 Thread* const self = Thread::Current();
8335 const DexFile* const dex_file = referrer->GetDexFile();
8336 const DexFile::MethodHandleItem& mh = dex_file->GetMethodHandle(method_handle_idx);
8337
8338 union {
8339 ArtField* field;
8340 ArtMethod* method;
8341 uintptr_t field_or_method;
8342 } target;
8343 uint32_t num_params;
8344 mirror::MethodHandle::Kind kind;
8345 DexFile::MethodHandleType handle_type =
8346 static_cast<DexFile::MethodHandleType>(mh.method_handle_type_);
8347 switch (handle_type) {
8348 case DexFile::MethodHandleType::kStaticPut: {
8349 kind = mirror::MethodHandle::Kind::kStaticPut;
8350 target.field = ResolveField(mh.field_or_method_idx_, referrer, true /* is_static */);
8351 num_params = 1;
8352 break;
8353 }
8354 case DexFile::MethodHandleType::kStaticGet: {
8355 kind = mirror::MethodHandle::Kind::kStaticGet;
8356 target.field = ResolveField(mh.field_or_method_idx_, referrer, true /* is_static */);
8357 num_params = 0;
8358 break;
8359 }
8360 case DexFile::MethodHandleType::kInstancePut: {
8361 kind = mirror::MethodHandle::Kind::kInstancePut;
8362 target.field = ResolveField(mh.field_or_method_idx_, referrer, false /* is_static */);
8363 num_params = 2;
8364 break;
8365 }
8366 case DexFile::MethodHandleType::kInstanceGet: {
8367 kind = mirror::MethodHandle::Kind::kInstanceGet;
8368 target.field = ResolveField(mh.field_or_method_idx_, referrer, false /* is_static */);
8369 num_params = 1;
8370 break;
8371 }
8372 case DexFile::MethodHandleType::kInvokeStatic: {
8373 kind = mirror::MethodHandle::Kind::kInvokeStatic;
8374 target.method = ResolveMethod<kNoICCECheckForCache>(self,
8375 mh.field_or_method_idx_,
8376 referrer,
8377 InvokeType::kStatic);
8378 uint32_t shorty_length;
8379 target.method->GetShorty(&shorty_length);
8380 num_params = shorty_length - 1; // Remove 1 for return value.
8381 break;
8382 }
8383 case DexFile::MethodHandleType::kInvokeInstance: {
8384 kind = mirror::MethodHandle::Kind::kInvokeVirtual;
8385 target.method = ResolveMethod<kNoICCECheckForCache>(self,
8386 mh.field_or_method_idx_,
8387 referrer,
8388 InvokeType::kVirtual);
8389 uint32_t shorty_length;
8390 target.method->GetShorty(&shorty_length);
8391 num_params = shorty_length - 1; // Remove 1 for return value.
8392 break;
8393 }
8394 case DexFile::MethodHandleType::kInvokeConstructor: {
8395 UNIMPLEMENTED(FATAL) << "Invoke constructor is implemented as a transform.";
8396 num_params = 0;
8397 }
8398 }
8399
8400 StackHandleScope<5> hs(self);
8401 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
8402 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
8403 Handle<mirror::ObjectArray<mirror::Class>> method_params(hs.NewHandle(
8404 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, num_params)));
8405 if (method_params.Get() == nullptr) {
8406 DCHECK(self->IsExceptionPending());
8407 return nullptr;
8408 }
8409
8410 Handle<mirror::Class> return_type;
8411 switch (handle_type) {
8412 case DexFile::MethodHandleType::kStaticPut: {
8413 method_params->Set(0, target.field->GetType<true>());
8414 return_type = hs.NewHandle(FindPrimitiveClass('V'));
8415 break;
8416 }
8417 case DexFile::MethodHandleType::kStaticGet: {
8418 return_type = hs.NewHandle(target.field->GetType<true>());
8419 break;
8420 }
8421 case DexFile::MethodHandleType::kInstancePut: {
8422 method_params->Set(0, target.field->GetDeclaringClass());
8423 method_params->Set(1, target.field->GetType<true>());
8424 return_type = hs.NewHandle(FindPrimitiveClass('V'));
8425 break;
8426 }
8427 case DexFile::MethodHandleType::kInstanceGet: {
8428 method_params->Set(0, target.field->GetDeclaringClass());
8429 return_type = hs.NewHandle(target.field->GetType<true>());
8430 break;
8431 }
8432 case DexFile::MethodHandleType::kInvokeStatic:
8433 case DexFile::MethodHandleType::kInvokeInstance: {
8434 // TODO(oth): This will not work for varargs methods as this
8435 // requires instantiating a Transformer. This resolution step
8436 // would be best done in managed code rather than in the run
8437 // time (b/35235705)
8438 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
8439 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
8440 DexFileParameterIterator it(*dex_file, target.method->GetPrototype());
8441 for (int32_t i = 0; it.HasNext(); i++, it.Next()) {
8442 const dex::TypeIndex type_idx = it.GetTypeIdx();
8443 mirror::Class* klass = ResolveType(*dex_file, type_idx, dex_cache, class_loader);
8444 if (nullptr == klass) {
8445 DCHECK(self->IsExceptionPending());
8446 return nullptr;
8447 }
8448 method_params->Set(i, klass);
8449 }
8450 return_type = hs.NewHandle(target.method->GetReturnType(true));
8451 break;
8452 }
8453 case DexFile::MethodHandleType::kInvokeConstructor: {
8454 // TODO(oth): b/35235705
8455 UNIMPLEMENTED(FATAL) << "Invoke constructor is implemented as a transform.";
8456 }
8457 }
8458
8459 if (return_type.IsNull()) {
8460 DCHECK(self->IsExceptionPending());
8461 return nullptr;
8462 }
8463
8464 Handle<mirror::MethodType>
8465 mt(hs.NewHandle(mirror::MethodType::Create(self, return_type, method_params)));
8466 if (mt.IsNull()) {
8467 DCHECK(self->IsExceptionPending());
8468 return nullptr;
8469 }
8470 return mirror::MethodHandleImpl::Create(self, target.field_or_method, kind, mt);
8471}
8472
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008473bool ClassLinker::IsQuickResolutionStub(const void* entry_point) const {
8474 return (entry_point == GetQuickResolutionStub()) ||
8475 (quick_resolution_trampoline_ == entry_point);
8476}
8477
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008478bool ClassLinker::IsQuickToInterpreterBridge(const void* entry_point) const {
8479 return (entry_point == GetQuickToInterpreterBridge()) ||
8480 (quick_to_interpreter_bridge_trampoline_ == entry_point);
8481}
8482
8483bool ClassLinker::IsQuickGenericJniStub(const void* entry_point) const {
8484 return (entry_point == GetQuickGenericJniStub()) ||
8485 (quick_generic_jni_trampoline_ == entry_point);
8486}
8487
8488const void* ClassLinker::GetRuntimeQuickGenericJniStub() const {
8489 return GetQuickGenericJniStub();
8490}
8491
Andreas Gampecc1b5352016-12-01 16:58:38 -08008492void ClassLinker::SetEntryPointsToCompiledCode(ArtMethod* method, const void* code) const {
8493 CHECK(code != nullptr);
8494 const uint8_t* base = reinterpret_cast<const uint8_t*>(code); // Base of data points at code.
8495 base -= sizeof(void*); // Move backward so that code_offset != 0.
8496 const uint32_t code_offset = sizeof(void*);
8497 OatFile::OatMethod oat_method(base, code_offset);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008498 oat_method.LinkMethod(method);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008499}
8500
Mathieu Chartiere401d142015-04-22 13:56:20 -07008501void ClassLinker::SetEntryPointsToInterpreter(ArtMethod* method) const {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008502 if (!method->IsNative()) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008503 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
8504 } else {
Andreas Gampecc1b5352016-12-01 16:58:38 -08008505 SetEntryPointsToCompiledCode(method, GetQuickGenericJniStub());
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008506 }
8507}
8508
Ian Rogers7dfb28c2013-08-22 08:18:36 -07008509void ClassLinker::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07008510 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier6b069532015-08-05 15:08:12 -07008511 ReaderMutexLock mu(soa.Self(), *Locks::classlinker_classes_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008512 os << "Zygote loaded classes=" << NumZygoteClasses() << " post zygote classes="
8513 << NumNonZygoteClasses() << "\n";
8514}
8515
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008516class CountClassesVisitor : public ClassLoaderVisitor {
8517 public:
8518 CountClassesVisitor() : num_zygote_classes(0), num_non_zygote_classes(0) {}
8519
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008520 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07008521 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008522 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier6b069532015-08-05 15:08:12 -07008523 if (class_table != nullptr) {
Vladimir Markoc5798bf2016-12-09 10:20:54 +00008524 num_zygote_classes += class_table->NumZygoteClasses(class_loader);
8525 num_non_zygote_classes += class_table->NumNonZygoteClasses(class_loader);
Mathieu Chartier6b069532015-08-05 15:08:12 -07008526 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008527 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008528
8529 size_t num_zygote_classes;
8530 size_t num_non_zygote_classes;
8531};
8532
8533size_t ClassLinker::NumZygoteClasses() const {
8534 CountClassesVisitor visitor;
8535 VisitClassLoaders(&visitor);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00008536 return visitor.num_zygote_classes + boot_class_table_.NumZygoteClasses(nullptr);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008537}
8538
8539size_t ClassLinker::NumNonZygoteClasses() const {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008540 CountClassesVisitor visitor;
8541 VisitClassLoaders(&visitor);
Vladimir Markoc5798bf2016-12-09 10:20:54 +00008542 return visitor.num_non_zygote_classes + boot_class_table_.NumNonZygoteClasses(nullptr);
Elliott Hughescac6cc72011-11-03 20:31:21 -07008543}
8544
Ian Rogers7dfb28c2013-08-22 08:18:36 -07008545size_t ClassLinker::NumLoadedClasses() {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07008546 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Mathieu Chartierc2e20622014-11-03 11:41:47 -08008547 // Only return non zygote classes since these are the ones which apps which care about.
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008548 return NumNonZygoteClasses();
Elliott Hughese27955c2011-08-26 15:21:24 -07008549}
8550
Brian Carlstrom47d237a2011-10-18 15:08:33 -07008551pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07008552 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07008553}
8554
8555pid_t ClassLinker::GetDexLockOwner() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08008556 return Locks::dex_lock_->GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07008557}
8558
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008559void ClassLinker::SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008560 DCHECK(!init_done_);
8561
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008562 DCHECK(klass != nullptr);
8563 DCHECK(klass->GetClassLoader() == nullptr);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008564
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07008565 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008566 DCHECK(class_roots != nullptr);
8567 DCHECK(class_roots->Get(class_root) == nullptr);
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07008568 class_roots->Set<false>(class_root, klass);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008569}
8570
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008571const char* ClassLinker::GetClassRootDescriptor(ClassRoot class_root) {
8572 static const char* class_roots_descriptors[] = {
8573 "Ljava/lang/Class;",
8574 "Ljava/lang/Object;",
8575 "[Ljava/lang/Class;",
8576 "[Ljava/lang/Object;",
8577 "Ljava/lang/String;",
8578 "Ljava/lang/DexCache;",
8579 "Ljava/lang/ref/Reference;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008580 "Ljava/lang/reflect/Constructor;",
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008581 "Ljava/lang/reflect/Field;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008582 "Ljava/lang/reflect/Method;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008583 "Ljava/lang/reflect/Proxy;",
8584 "[Ljava/lang/String;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008585 "[Ljava/lang/reflect/Constructor;",
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008586 "[Ljava/lang/reflect/Field;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008587 "[Ljava/lang/reflect/Method;",
Orion Hodsonc069a302017-01-18 09:23:12 +00008588 "Ljava/lang/invoke/CallSite;",
Narayan Kamathafa48272016-08-03 12:46:58 +01008589 "Ljava/lang/invoke/MethodHandleImpl;",
Orion Hodsonc069a302017-01-18 09:23:12 +00008590 "Ljava/lang/invoke/MethodHandles$Lookup;",
Narayan Kamathafa48272016-08-03 12:46:58 +01008591 "Ljava/lang/invoke/MethodType;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008592 "Ljava/lang/ClassLoader;",
8593 "Ljava/lang/Throwable;",
8594 "Ljava/lang/ClassNotFoundException;",
8595 "Ljava/lang/StackTraceElement;",
Narayan Kamath000e1882016-10-24 17:14:25 +01008596 "Ldalvik/system/EmulatedStackFrame;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008597 "Z",
8598 "B",
8599 "C",
8600 "D",
8601 "F",
8602 "I",
8603 "J",
8604 "S",
8605 "V",
8606 "[Z",
8607 "[B",
8608 "[C",
8609 "[D",
8610 "[F",
8611 "[I",
8612 "[J",
8613 "[S",
8614 "[Ljava/lang/StackTraceElement;",
Alex Lightd6251582016-10-31 11:12:30 -07008615 "Ldalvik/system/ClassExt;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008616 };
Andreas Gampe575e78c2014-11-03 23:41:03 -08008617 static_assert(arraysize(class_roots_descriptors) == size_t(kClassRootsMax),
8618 "Mismatch between class descriptors and class-root enum");
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008619
8620 const char* descriptor = class_roots_descriptors[class_root];
8621 CHECK(descriptor != nullptr);
8622 return descriptor;
8623}
8624
Jeff Hao5872d7c2016-04-27 11:07:41 -07008625jobject ClassLinker::CreatePathClassLoader(Thread* self,
8626 const std::vector<const DexFile*>& dex_files) {
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008627 // SOAAlreadyRunnable is protected, and we need something to add a global reference.
8628 // We could move the jobject to the callers, but all call-sites do this...
8629 ScopedObjectAccessUnchecked soa(self);
8630
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008631 // For now, create a libcore-level DexFile for each ART DexFile. This "explodes" multidex.
Vladimir Marko19a4d372016-12-08 14:41:46 +00008632 StackHandleScope<6> hs(self);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008633
Mathieu Chartierc7853442015-03-27 14:35:38 -07008634 ArtField* dex_elements_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008635 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008636
Mathieu Chartier3398c782016-09-30 10:27:43 -07008637 Handle<mirror::Class> dex_elements_class(hs.NewHandle(dex_elements_field->GetType<true>()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008638 DCHECK(dex_elements_class != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008639 DCHECK(dex_elements_class->IsArrayClass());
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008640 Handle<mirror::ObjectArray<mirror::Object>> h_dex_elements(hs.NewHandle(
Mathieu Chartier3398c782016-09-30 10:27:43 -07008641 mirror::ObjectArray<mirror::Object>::Alloc(self,
8642 dex_elements_class.Get(),
8643 dex_files.size())));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008644 Handle<mirror::Class> h_dex_element_class =
8645 hs.NewHandle(dex_elements_class->GetComponentType());
8646
Mathieu Chartierc7853442015-03-27 14:35:38 -07008647 ArtField* element_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008648 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008649 DCHECK_EQ(h_dex_element_class.Get(), element_file_field->GetDeclaringClass());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008650
Andreas Gampe08883de2016-11-08 13:20:52 -08008651 ArtField* cookie_field = jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008652 DCHECK_EQ(cookie_field->GetDeclaringClass(), element_file_field->GetType<false>());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008653
Andreas Gampe08883de2016-11-08 13:20:52 -08008654 ArtField* file_name_field = jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_fileName);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008655 DCHECK_EQ(file_name_field->GetDeclaringClass(), element_file_field->GetType<false>());
8656
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008657 // Fill the elements array.
8658 int32_t index = 0;
8659 for (const DexFile* dex_file : dex_files) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008660 StackHandleScope<4> hs2(self);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008661
Mathieu Chartier966878d2016-01-14 14:33:29 -08008662 // CreatePathClassLoader is only used by gtests. Index 0 of h_long_array is supposed to be the
8663 // oat file but we can leave it null.
Mathieu Chartiere58991b2015-10-13 07:59:34 -07008664 Handle<mirror::LongArray> h_long_array = hs2.NewHandle(mirror::LongArray::Alloc(
8665 self,
8666 kDexFileIndexStart + 1));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008667 DCHECK(h_long_array != nullptr);
Mathieu Chartiere58991b2015-10-13 07:59:34 -07008668 h_long_array->Set(kDexFileIndexStart, reinterpret_cast<intptr_t>(dex_file));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008669
8670 Handle<mirror::Object> h_dex_file = hs2.NewHandle(
Mathieu Chartierc7853442015-03-27 14:35:38 -07008671 cookie_field->GetDeclaringClass()->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008672 DCHECK(h_dex_file != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008673 cookie_field->SetObject<false>(h_dex_file.Get(), h_long_array.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008674
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008675 Handle<mirror::String> h_file_name = hs2.NewHandle(
8676 mirror::String::AllocFromModifiedUtf8(self, dex_file->GetLocation().c_str()));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008677 DCHECK(h_file_name != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008678 file_name_field->SetObject<false>(h_dex_file.Get(), h_file_name.Get());
8679
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008680 Handle<mirror::Object> h_element = hs2.NewHandle(h_dex_element_class->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008681 DCHECK(h_element != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008682 element_file_field->SetObject<false>(h_element.Get(), h_dex_file.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008683
8684 h_dex_elements->Set(index, h_element.Get());
8685 index++;
8686 }
8687 DCHECK_EQ(index, h_dex_elements->GetLength());
8688
8689 // Create DexPathList.
8690 Handle<mirror::Object> h_dex_path_list = hs.NewHandle(
Mathieu Chartierc7853442015-03-27 14:35:38 -07008691 dex_elements_field->GetDeclaringClass()->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008692 DCHECK(h_dex_path_list != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008693 // Set elements.
Mathieu Chartierc7853442015-03-27 14:35:38 -07008694 dex_elements_field->SetObject<false>(h_dex_path_list.Get(), h_dex_elements.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008695
8696 // Create PathClassLoader.
8697 Handle<mirror::Class> h_path_class_class = hs.NewHandle(
Mathieu Chartier0795f232016-09-27 18:43:30 -07008698 soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008699 Handle<mirror::Object> h_path_class_loader = hs.NewHandle(
8700 h_path_class_class->AllocObject(self));
Andreas Gampefa4333d2017-02-14 11:10:34 -08008701 DCHECK(h_path_class_loader != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008702 // Set DexPathList.
Mathieu Chartierc7853442015-03-27 14:35:38 -07008703 ArtField* path_list_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008704 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008705 DCHECK(path_list_field != nullptr);
8706 path_list_field->SetObject<false>(h_path_class_loader.Get(), h_dex_path_list.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008707
8708 // Make a pretend boot-classpath.
8709 // TODO: Should we scan the image?
Mathieu Chartierc7853442015-03-27 14:35:38 -07008710 ArtField* const parent_field =
Vladimir Marko19a4d372016-12-08 14:41:46 +00008711 mirror::Class::FindField(self,
8712 h_path_class_loader->GetClass(),
8713 "parent",
Mathieu Chartierc7853442015-03-27 14:35:38 -07008714 "Ljava/lang/ClassLoader;");
Roland Levillainf39c9eb2015-05-26 15:02:07 +01008715 DCHECK(parent_field != nullptr);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07008716 ObjPtr<mirror::Object> boot_cl =
Mathieu Chartier0795f232016-09-27 18:43:30 -07008717 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader)->AllocObject(self);
Mathieu Chartier966878d2016-01-14 14:33:29 -08008718 parent_field->SetObject<false>(h_path_class_loader.Get(), boot_cl);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008719
8720 // Make it a global ref and return.
8721 ScopedLocalRef<jobject> local_ref(
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07008722 soa.Env(), soa.Env()->AddLocalReference<jobject>(h_path_class_loader.Get()));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008723 return soa.Env()->NewGlobalRef(local_ref.get());
8724}
8725
Andreas Gampe8ac75952015-06-02 21:01:45 -07008726void ClassLinker::DropFindArrayClassCache() {
8727 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
8728 find_array_class_cache_next_victim_ = 0;
8729}
8730
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07008731void ClassLinker::ClearClassTableStrongRoots() const {
8732 Thread* const self = Thread::Current();
8733 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
8734 for (const ClassLoaderData& data : class_loaders_) {
8735 if (data.class_table != nullptr) {
8736 data.class_table->ClearStrongRoots();
8737 }
8738 }
8739}
8740
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008741void ClassLinker::VisitClassLoaders(ClassLoaderVisitor* visitor) const {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008742 Thread* const self = Thread::Current();
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008743 for (const ClassLoaderData& data : class_loaders_) {
Mathieu Chartier4843bd52015-10-01 17:08:44 -07008744 // Need to use DecodeJObject so that we get null for cleared JNI weak globals.
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008745 ObjPtr<mirror::ClassLoader> class_loader = ObjPtr<mirror::ClassLoader>::DownCast(
8746 self->DecodeJObject(data.weak_root));
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008747 if (class_loader != nullptr) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008748 visitor->Visit(class_loader.Ptr());
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008749 }
8750 }
8751}
8752
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008753void ClassLinker::InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file,
8754 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier00310e02015-10-17 12:46:42 -07008755 DCHECK(dex_file != nullptr);
Mathieu Chartier00310e02015-10-17 12:46:42 -07008756 Thread* const self = Thread::Current();
8757 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008758 ClassTable* const table = ClassTableForClassLoader(class_loader.Ptr());
Mathieu Chartier00310e02015-10-17 12:46:42 -07008759 DCHECK(table != nullptr);
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07008760 if (table->InsertStrongRoot(dex_file) && class_loader != nullptr) {
Mathieu Chartier00310e02015-10-17 12:46:42 -07008761 // It was not already inserted, perform the write barrier to let the GC know the class loader's
8762 // class table was modified.
8763 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
8764 }
8765}
8766
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008767void ClassLinker::CleanupClassLoaders() {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008768 Thread* const self = Thread::Current();
Mathieu Chartier65975772016-08-05 10:46:36 -07008769 std::vector<ClassLoaderData> to_delete;
8770 // Do the delete outside the lock to avoid lock violation in jit code cache.
8771 {
8772 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
8773 for (auto it = class_loaders_.begin(); it != class_loaders_.end(); ) {
8774 const ClassLoaderData& data = *it;
8775 // Need to use DecodeJObject so that we get null for cleared JNI weak globals.
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008776 ObjPtr<mirror::ClassLoader> class_loader =
8777 ObjPtr<mirror::ClassLoader>::DownCast(self->DecodeJObject(data.weak_root));
Mathieu Chartier65975772016-08-05 10:46:36 -07008778 if (class_loader != nullptr) {
8779 ++it;
8780 } else {
8781 VLOG(class_linker) << "Freeing class loader";
8782 to_delete.push_back(data);
8783 it = class_loaders_.erase(it);
8784 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008785 }
8786 }
Mathieu Chartier65975772016-08-05 10:46:36 -07008787 for (ClassLoaderData& data : to_delete) {
8788 DeleteClassLoader(self, data);
8789 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008790}
8791
Vladimir Marko21300532017-01-24 18:06:55 +00008792class GetResolvedClassesVisitor : public ClassVisitor {
8793 public:
8794 GetResolvedClassesVisitor(std::set<DexCacheResolvedClasses>* result, bool ignore_boot_classes)
8795 : result_(result),
8796 ignore_boot_classes_(ignore_boot_classes),
8797 last_resolved_classes_(result->end()),
8798 last_dex_file_(nullptr),
8799 vlog_is_on_(VLOG_IS_ON(class_linker)),
8800 extra_stats_(),
8801 last_extra_stats_(extra_stats_.end()) { }
8802
8803 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
8804 if (!klass->IsProxyClass() &&
8805 !klass->IsArrayClass() &&
8806 klass->IsResolved() &&
8807 !klass->IsErroneousResolved() &&
8808 (!ignore_boot_classes_ || klass->GetClassLoader() != nullptr)) {
8809 const DexFile& dex_file = klass->GetDexFile();
8810 if (&dex_file != last_dex_file_) {
8811 last_dex_file_ = &dex_file;
8812 DexCacheResolvedClasses resolved_classes(dex_file.GetLocation(),
8813 dex_file.GetBaseLocation(),
8814 dex_file.GetLocationChecksum());
8815 last_resolved_classes_ = result_->find(resolved_classes);
8816 if (last_resolved_classes_ == result_->end()) {
8817 last_resolved_classes_ = result_->insert(resolved_classes).first;
8818 }
8819 }
8820 bool added = last_resolved_classes_->AddClass(klass->GetDexTypeIndex());
8821 if (UNLIKELY(vlog_is_on_) && added) {
8822 const DexCacheResolvedClasses* resolved_classes = std::addressof(*last_resolved_classes_);
8823 if (last_extra_stats_ == extra_stats_.end() ||
8824 last_extra_stats_->first != resolved_classes) {
8825 last_extra_stats_ = extra_stats_.find(resolved_classes);
8826 if (last_extra_stats_ == extra_stats_.end()) {
8827 last_extra_stats_ =
8828 extra_stats_.emplace(resolved_classes, ExtraStats(dex_file.NumClassDefs())).first;
8829 }
8830 }
8831 }
8832 }
8833 return true;
8834 }
8835
8836 void PrintStatistics() const {
8837 if (vlog_is_on_) {
8838 for (const DexCacheResolvedClasses& resolved_classes : *result_) {
8839 auto it = extra_stats_.find(std::addressof(resolved_classes));
8840 DCHECK(it != extra_stats_.end());
8841 const ExtraStats& extra_stats = it->second;
8842 LOG(INFO) << "Dex location " << resolved_classes.GetDexLocation()
8843 << " has " << resolved_classes.GetClasses().size() << " / "
8844 << extra_stats.number_of_class_defs_ << " resolved classes";
8845 }
8846 }
8847 }
8848
8849 private:
8850 struct ExtraStats {
8851 explicit ExtraStats(uint32_t number_of_class_defs)
8852 : number_of_class_defs_(number_of_class_defs) {}
8853 uint32_t number_of_class_defs_;
8854 };
8855
8856 std::set<DexCacheResolvedClasses>* result_;
8857 bool ignore_boot_classes_;
8858 std::set<DexCacheResolvedClasses>::iterator last_resolved_classes_;
8859 const DexFile* last_dex_file_;
8860
8861 // Statistics.
8862 bool vlog_is_on_;
8863 std::map<const DexCacheResolvedClasses*, ExtraStats> extra_stats_;
8864 std::map<const DexCacheResolvedClasses*, ExtraStats>::iterator last_extra_stats_;
8865};
8866
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008867std::set<DexCacheResolvedClasses> ClassLinker::GetResolvedClasses(bool ignore_boot_classes) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08008868 ScopedTrace trace(__PRETTY_FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008869 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier268764d2016-09-13 12:09:38 -07008870 ScopedAssertNoThreadSuspension ants(__FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008871 std::set<DexCacheResolvedClasses> ret;
8872 VLOG(class_linker) << "Collecting resolved classes";
8873 const uint64_t start_time = NanoTime();
Vladimir Marko21300532017-01-24 18:06:55 +00008874 GetResolvedClassesVisitor visitor(&ret, ignore_boot_classes);
8875 VisitClasses(&visitor);
8876 if (VLOG_IS_ON(class_linker)) {
8877 visitor.PrintStatistics();
8878 LOG(INFO) << "Collecting class profile took " << PrettyDuration(NanoTime() - start_time);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008879 }
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008880 return ret;
8881}
8882
Mathieu Chartier046854b2017-03-01 17:16:22 -08008883std::unordered_set<std::string> ClassLinker::GetClassDescriptorsForResolvedClasses(
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008884 const std::set<DexCacheResolvedClasses>& classes) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08008885 ScopedTrace trace(__PRETTY_FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008886 std::unordered_set<std::string> ret;
8887 Thread* const self = Thread::Current();
8888 std::unordered_map<std::string, const DexFile*> location_to_dex_file;
8889 ScopedObjectAccess soa(self);
Mathieu Chartier268764d2016-09-13 12:09:38 -07008890 ScopedAssertNoThreadSuspension ants(__FUNCTION__);
Andreas Gampecc1b5352016-12-01 16:58:38 -08008891 ReaderMutexLock mu(self, *Locks::dex_lock_);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008892 for (const ClassLinker::DexCacheData& data : GetDexCachesData()) {
8893 if (!self->IsJWeakCleared(data.weak_root)) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008894 ObjPtr<mirror::DexCache> dex_cache = soa.Decode<mirror::DexCache>(data.weak_root);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008895 if (dex_cache != nullptr) {
8896 const DexFile* dex_file = dex_cache->GetDexFile();
8897 // There could be duplicates if two dex files with the same location are mapped.
Mathieu Chartier046854b2017-03-01 17:16:22 -08008898 location_to_dex_file.emplace(dex_file->GetLocation(), dex_file);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008899 }
8900 }
8901 }
8902 for (const DexCacheResolvedClasses& info : classes) {
Mathieu Chartier046854b2017-03-01 17:16:22 -08008903 const std::string& location = info.GetDexLocation();
8904 auto found = location_to_dex_file.find(location);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008905 if (found != location_to_dex_file.end()) {
8906 const DexFile* dex_file = found->second;
8907 VLOG(profiler) << "Found opened dex file for " << dex_file->GetLocation() << " with "
8908 << info.GetClasses().size() << " classes";
8909 DCHECK_EQ(dex_file->GetLocationChecksum(), info.GetLocationChecksum());
Andreas Gampea5b09a62016-11-17 15:21:22 -08008910 for (dex::TypeIndex type_idx : info.GetClasses()) {
Jeff Hao54b58552016-11-16 15:15:04 -08008911 const DexFile::TypeId& type_id = dex_file->GetTypeId(type_idx);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008912 const char* descriptor = dex_file->GetTypeDescriptor(type_id);
8913 ret.insert(descriptor);
8914 }
8915 } else {
Mathieu Chartier046854b2017-03-01 17:16:22 -08008916 VLOG(class_linker) << "Failed to find opened dex file for location " << location;
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008917 }
8918 }
8919 return ret;
8920}
8921
Mathieu Chartier65975772016-08-05 10:46:36 -07008922class ClassLinker::FindVirtualMethodHolderVisitor : public ClassVisitor {
8923 public:
8924 FindVirtualMethodHolderVisitor(const ArtMethod* method, PointerSize pointer_size)
8925 : method_(method),
8926 pointer_size_(pointer_size) {}
8927
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008928 bool operator()(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier65975772016-08-05 10:46:36 -07008929 if (klass->GetVirtualMethodsSliceUnchecked(pointer_size_).Contains(method_)) {
8930 holder_ = klass;
8931 }
8932 // Return false to stop searching if holder_ is not null.
8933 return holder_ == nullptr;
8934 }
8935
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008936 ObjPtr<mirror::Class> holder_ = nullptr;
Mathieu Chartier65975772016-08-05 10:46:36 -07008937 const ArtMethod* const method_;
8938 const PointerSize pointer_size_;
8939};
8940
8941mirror::Class* ClassLinker::GetHoldingClassOfCopiedMethod(ArtMethod* method) {
8942 ScopedTrace trace(__FUNCTION__); // Since this function is slow, have a trace to notify people.
8943 CHECK(method->IsCopied());
8944 FindVirtualMethodHolderVisitor visitor(method, image_pointer_size_);
8945 VisitClasses(&visitor);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008946 return visitor.holder_.Ptr();
Mathieu Chartier65975772016-08-05 10:46:36 -07008947}
8948
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08008949// Instantiate ResolveMethod.
8950template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kForceICCECheck>(
8951 const DexFile& dex_file,
8952 uint32_t method_idx,
8953 Handle<mirror::DexCache> dex_cache,
8954 Handle<mirror::ClassLoader> class_loader,
8955 ArtMethod* referrer,
8956 InvokeType type);
8957template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kNoICCECheckForCache>(
8958 const DexFile& dex_file,
8959 uint32_t method_idx,
8960 Handle<mirror::DexCache> dex_cache,
8961 Handle<mirror::ClassLoader> class_loader,
8962 ArtMethod* referrer,
8963 InvokeType type);
8964
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07008965} // namespace art