blob: 0fdf4e11a6aa9e2eead066e077571a42efb9b0f7 [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>
Ian Rogers700a4022014-05-19 16:49:03 -070022#include <memory>
Fred Shih381e4ca2014-08-25 17:24:27 -070023#include <queue>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070024#include <string>
Alex Lighteb7c1442015-08-31 13:17:42 -070025#include <tuple>
Andreas Gampea696c0a2014-12-10 20:51:45 -080026#include <unistd.h>
Alex Lighteb7c1442015-08-31 13:17:42 -070027#include <unordered_map>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070028#include <utility>
Elliott Hughes90a33692011-08-30 13:27:07 -070029#include <vector>
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070030
Mathieu Chartierc7853442015-03-27 14:35:38 -070031#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070032#include "art_method-inl.h"
33#include "base/arena_allocator.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080034#include "base/casts.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080035#include "base/logging.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070036#include "base/scoped_arena_containers.h"
Narayan Kamathd1c606f2014-06-09 16:50:19 +010037#include "base/scoped_flock.h"
Elliott Hughes1aa246d2012-12-13 09:29:36 -080038#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080039#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010040#include "base/time_utils.h"
Elliott Hughes76160052012-12-12 16:31:20 -080041#include "base/unix_file/fd_file.h"
Andreas Gampeb9aec2c2015-04-23 22:23:47 -070042#include "base/value_object.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043#include "class_linker-inl.h"
Mathieu Chartiere4275c02015-08-06 15:34:15 -070044#include "class_table-inl.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000045#include "compiler_callbacks.h"
Elliott Hughes4740cdf2011-12-07 14:07:12 -080046#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070047#include "dex_file-inl.h"
Mathieu Chartiere58991b2015-10-13 07:59:34 -070048#include "entrypoints/entrypoint_utils.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070049#include "entrypoints/runtime_asm_entrypoints.h"
Alex Light705ad492015-09-21 11:36:30 -070050#include "experimental_flags.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070051#include "gc_root-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070052#include "gc/accounting/card_table-inl.h"
Mathieu Chartier03c1dd92016-03-07 16:13:54 -080053#include "gc/accounting/heap_bitmap-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070054#include "gc/heap.h"
Mathieu Chartier1b1e31f2016-05-19 10:13:04 -070055#include "gc/scoped_gc_critical_section.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070056#include "gc/space/image_space.h"
Mathieu Chartiere58991b2015-10-13 07:59:34 -070057#include "handle_scope-inl.h"
Mathieu Chartier4a26f172016-01-26 14:26:18 -080058#include "image-inl.h"
Andreas Gampe75a7db62016-09-26 12:04:26 -070059#include "imt_conflict_table.h"
60#include "imtable-inl.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070061#include "intern_table.h"
Ian Rogers64b6d142012-10-29 16:34:15 -070062#include "interpreter/interpreter.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080063#include "jit/jit.h"
64#include "jit/jit_code_cache.h"
Mathieu Chartierc5dd3192015-12-09 16:38:30 -080065#include "jit/offline_profiling_info.h"
Andreas Gampe08883de2016-11-08 13:20:52 -080066#include "jni_internal.h"
Ian Rogers0571d352011-11-03 19:51:38 -070067#include "leb128.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070068#include "linear_alloc.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080069#include "mirror/class.h"
70#include "mirror/class-inl.h"
Alex Lightd6251582016-10-31 11:12:30 -070071#include "mirror/class_ext.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080072#include "mirror/class_loader.h"
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -070073#include "mirror/dex_cache.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070074#include "mirror/dex_cache-inl.h"
Narayan Kamath000e1882016-10-24 17:14:25 +010075#include "mirror/emulated_stack_frame.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -070076#include "mirror/field.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080077#include "mirror/iftable-inl.h"
Mathieu Chartierfc58af42015-04-16 18:00:39 -070078#include "mirror/method.h"
Narayan Kamathafa48272016-08-03 12:46:58 +010079#include "mirror/method_type.h"
80#include "mirror/method_handle_impl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080081#include "mirror/object-inl.h"
82#include "mirror/object_array-inl.h"
83#include "mirror/proxy.h"
Fred Shih4ee7a662014-07-11 09:59:27 -070084#include "mirror/reference-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080085#include "mirror/stack_trace_element.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070086#include "mirror/string-inl.h"
Mathieu Chartiere58991b2015-10-13 07:59:34 -070087#include "native/dalvik_system_DexFile.h"
88#include "oat.h"
89#include "oat_file.h"
90#include "oat_file-inl.h"
91#include "oat_file_assistant.h"
92#include "oat_file_manager.h"
93#include "object_lock.h"
Brian Carlstrom5b332c82012-02-01 15:02:31 -080094#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070095#include "runtime.h"
Elliott Hughes4d0207c2011-10-03 19:14:34 -070096#include "ScopedLocalRef.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070097#include "scoped_thread_state_change-inl.h"
Ian Rogers7b078e82014-09-10 14:44:24 -070098#include "thread-inl.h"
Mathieu Chartier7778b882015-10-05 16:41:10 -070099#include "trace.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700100#include "utils.h"
Vladimir Marko05792b92015-08-03 11:56:49 +0100101#include "utils/dex_cache_arrays_layout-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800102#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -0700103#include "well_known_classes.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700104
105namespace art {
106
Mathieu Chartierc7853442015-03-27 14:35:38 -0700107static constexpr bool kSanityCheckObjects = kIsDebugBuild;
Mathieu Chartier8790c7f2016-03-31 15:05:45 -0700108static constexpr bool kVerifyArtMethodDeclaringClasses = kIsDebugBuild;
Mathieu Chartierc7853442015-03-27 14:35:38 -0700109
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700110static void ThrowNoClassDefFoundError(const char* fmt, ...)
111 __attribute__((__format__(__printf__, 1, 2)))
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700112 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes0512f022012-03-15 22:10:52 -0700113static void ThrowNoClassDefFoundError(const char* fmt, ...) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700114 va_list args;
115 va_start(args, fmt);
Ian Rogers62d6c772013-02-27 08:32:07 -0800116 Thread* self = Thread::Current();
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000117 self->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
Ian Rogerscab01012012-01-10 17:35:46 -0800118 va_end(args);
119}
120
Andreas Gampe99babb62015-11-02 16:20:00 -0800121static bool HasInitWithString(Thread* self, ClassLinker* class_linker, const char* descriptor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700122 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700123 ArtMethod* method = self->GetCurrentMethod(nullptr);
Andreas Gampebfdcdc12015-04-22 18:10:36 -0700124 StackHandleScope<1> hs(self);
125 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(method != nullptr ?
Mathieu Chartier90443472015-07-16 20:32:27 -0700126 method->GetDeclaringClass()->GetClassLoader() : nullptr));
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700127 ObjPtr<mirror::Class> exception_class = class_linker->FindClass(self, descriptor, class_loader);
Andreas Gampebfdcdc12015-04-22 18:10:36 -0700128
129 if (exception_class == nullptr) {
130 // No exc class ~ no <init>-with-string.
131 CHECK(self->IsExceptionPending());
132 self->ClearException();
133 return false;
134 }
135
Mathieu Chartiere401d142015-04-22 13:56:20 -0700136 ArtMethod* exception_init_method = exception_class->FindDeclaredDirectMethod(
Andreas Gampe99babb62015-11-02 16:20:00 -0800137 "<init>", "(Ljava/lang/String;)V", class_linker->GetImagePointerSize());
Andreas Gampebfdcdc12015-04-22 18:10:36 -0700138 return exception_init_method != nullptr;
139}
140
Alex Lightd6251582016-10-31 11:12:30 -0700141static mirror::Object* GetVerifyError(ObjPtr<mirror::Class> c)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700142 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lightd6251582016-10-31 11:12:30 -0700143 ObjPtr<mirror::ClassExt> ext(c->GetExtData());
144 if (ext == nullptr) {
145 return nullptr;
146 } else {
147 return ext->GetVerifyError();
148 }
149}
150
151// Helper for ThrowEarlierClassFailure. Throws the stored error.
152static void HandleEarlierVerifyError(Thread* self,
153 ClassLinker* class_linker,
154 ObjPtr<mirror::Class> c)
155 REQUIRES_SHARED(Locks::mutator_lock_) {
156 ObjPtr<mirror::Object> obj = GetVerifyError(c);
Andreas Gampe99babb62015-11-02 16:20:00 -0800157 DCHECK(obj != nullptr);
158 self->AssertNoPendingException();
159 if (obj->IsClass()) {
160 // Previous error has been stored as class. Create a new exception of that type.
161
162 // It's possible the exception doesn't have a <init>(String).
163 std::string temp;
164 const char* descriptor = obj->AsClass()->GetDescriptor(&temp);
165
166 if (HasInitWithString(self, class_linker, descriptor)) {
David Sehr709b0702016-10-13 09:12:37 -0700167 self->ThrowNewException(descriptor, c->PrettyDescriptor().c_str());
Andreas Gampe99babb62015-11-02 16:20:00 -0800168 } else {
169 self->ThrowNewException(descriptor, nullptr);
170 }
171 } else {
172 // Previous error has been stored as an instance. Just rethrow.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700173 ObjPtr<mirror::Class> throwable_class =
Andreas Gampe99babb62015-11-02 16:20:00 -0800174 self->DecodeJObject(WellKnownClasses::java_lang_Throwable)->AsClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700175 ObjPtr<mirror::Class> error_class = obj->GetClass();
Andreas Gampe99babb62015-11-02 16:20:00 -0800176 CHECK(throwable_class->IsAssignableFrom(error_class));
177 self->SetException(obj->AsThrowable());
178 }
179 self->AssertPendingException();
180}
181
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700182void ClassLinker::ThrowEarlierClassFailure(ObjPtr<mirror::Class> c, bool wrap_in_no_class_def) {
Elliott Hughes5c599942012-06-13 16:45:05 -0700183 // The class failed to initialize on a previous attempt, so we want to throw
184 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
185 // failed in verification, in which case v2 5.4.1 says we need to re-throw
186 // the previous error.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800187 Runtime* const runtime = Runtime::Current();
188 if (!runtime->IsAotCompiler()) { // Give info if this occurs at runtime.
Andreas Gampe3d6b4702015-09-21 08:35:52 -0700189 std::string extra;
Alex Lightd6251582016-10-31 11:12:30 -0700190 if (GetVerifyError(c) != nullptr) {
191 ObjPtr<mirror::Object> verify_error = GetVerifyError(c);
Andreas Gampe369c8512016-01-28 15:31:39 -0800192 if (verify_error->IsClass()) {
David Sehr709b0702016-10-13 09:12:37 -0700193 extra = mirror::Class::PrettyDescriptor(verify_error->AsClass());
Andreas Gampe369c8512016-01-28 15:31:39 -0800194 } else {
195 extra = verify_error->AsThrowable()->Dump();
196 }
Andreas Gampe3d6b4702015-09-21 08:35:52 -0700197 }
David Sehr709b0702016-10-13 09:12:37 -0700198 LOG(INFO) << "Rejecting re-init on previously-failed class " << c->PrettyClass()
199 << ": " << extra;
Ian Rogers87e552d2012-08-31 15:54:48 -0700200 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700201
David Sehr709b0702016-10-13 09:12:37 -0700202 CHECK(c->IsErroneous()) << c->PrettyClass() << " " << c->GetStatus();
Ian Rogers62d6c772013-02-27 08:32:07 -0800203 Thread* self = Thread::Current();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800204 if (runtime->IsAotCompiler()) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700205 // At compile time, accurate errors and NCDFE are disabled to speed compilation.
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700206 ObjPtr<mirror::Throwable> pre_allocated = runtime->GetPreAllocatedNoClassDefFoundError();
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000207 self->SetException(pre_allocated);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700208 } else {
Alex Lightd6251582016-10-31 11:12:30 -0700209 if (GetVerifyError(c) != nullptr) {
Andreas Gampecb086952015-11-02 16:20:00 -0800210 // Rethrow stored error.
Andreas Gampe99babb62015-11-02 16:20:00 -0800211 HandleEarlierVerifyError(self, this, c);
Andreas Gampecb086952015-11-02 16:20:00 -0800212 }
Alex Lightd6251582016-10-31 11:12:30 -0700213 // TODO This might be wrong if we hit an OOME while allocating the ClassExt. In that case we
214 // might have meant to go down the earlier if statement with the original error but it got
215 // swallowed by the OOM so we end up here.
216 if (GetVerifyError(c) == nullptr || wrap_in_no_class_def) {
Andreas Gampecb086952015-11-02 16:20:00 -0800217 // If there isn't a recorded earlier error, or this is a repeat throw from initialization,
218 // the top-level exception must be a NoClassDefFoundError. The potentially already pending
219 // exception will be a cause.
220 self->ThrowNewWrappedException("Ljava/lang/NoClassDefFoundError;",
David Sehr709b0702016-10-13 09:12:37 -0700221 c->PrettyDescriptor().c_str());
Ian Rogers7b078e82014-09-10 14:44:24 -0700222 }
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700223 }
224}
225
Brian Carlstromb23eab12014-10-08 17:55:21 -0700226static void VlogClassInitializationFailure(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700227 REQUIRES_SHARED(Locks::mutator_lock_) {
Brian Carlstromb23eab12014-10-08 17:55:21 -0700228 if (VLOG_IS_ON(class_linker)) {
229 std::string temp;
230 LOG(INFO) << "Failed to initialize class " << klass->GetDescriptor(&temp) << " from "
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000231 << klass->GetLocation() << "\n" << Thread::Current()->GetException()->Dump();
Brian Carlstromb23eab12014-10-08 17:55:21 -0700232 }
233}
234
235static void WrapExceptionInInitializer(Handle<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700236 REQUIRES_SHARED(Locks::mutator_lock_) {
Elliott Hughesa4f94742012-05-29 16:28:38 -0700237 Thread* self = Thread::Current();
238 JNIEnv* env = self->GetJniEnv();
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700239
240 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700241 CHECK(cause.get() != nullptr);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700242
Andreas Gampe22f71d22016-11-21 10:10:08 -0800243 // Boot classpath classes should not fail initialization.
244 if (!Runtime::Current()->IsAotCompiler()) {
245 std::string tmp;
246 CHECK(klass->GetClassLoader() != nullptr) << klass->GetDescriptor(&tmp);
247 }
248
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700249 env->ExceptionClear();
Elliott Hughesa4f94742012-05-29 16:28:38 -0700250 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error);
251 env->Throw(cause.get());
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700252
Elliott Hughesa4f94742012-05-29 16:28:38 -0700253 // We only wrap non-Error exceptions; an Error can just be used as-is.
254 if (!is_error) {
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000255 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", nullptr);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700256 }
Brian Carlstromb23eab12014-10-08 17:55:21 -0700257 VlogClassInitializationFailure(klass);
Elliott Hughes4d0207c2011-10-03 19:14:34 -0700258}
259
Fred Shih381e4ca2014-08-25 17:24:27 -0700260// Gap between two fields in object layout.
261struct FieldGap {
262 uint32_t start_offset; // The offset from the start of the object.
263 uint32_t size; // The gap size of 1, 2, or 4 bytes.
264};
265struct FieldGapsComparator {
266 explicit FieldGapsComparator() {
267 }
268 bool operator() (const FieldGap& lhs, const FieldGap& rhs)
269 NO_THREAD_SAFETY_ANALYSIS {
Andreas Gampef52857f2015-02-18 15:38:57 -0800270 // Sort by gap size, largest first. Secondary sort by starting offset.
Richard Uhlerfab67882015-07-13 17:00:35 -0700271 // Note that the priority queue returns the largest element, so operator()
272 // should return true if lhs is less than rhs.
273 return lhs.size < rhs.size || (lhs.size == rhs.size && lhs.start_offset > rhs.start_offset);
Fred Shih381e4ca2014-08-25 17:24:27 -0700274 }
275};
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700276typedef std::priority_queue<FieldGap, std::vector<FieldGap>, FieldGapsComparator> FieldGaps;
Fred Shih381e4ca2014-08-25 17:24:27 -0700277
278// Adds largest aligned gaps to queue of gaps.
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800279static void AddFieldGap(uint32_t gap_start, uint32_t gap_end, FieldGaps* gaps) {
Fred Shih381e4ca2014-08-25 17:24:27 -0700280 DCHECK(gaps != nullptr);
281
282 uint32_t current_offset = gap_start;
283 while (current_offset != gap_end) {
284 size_t remaining = gap_end - current_offset;
285 if (remaining >= sizeof(uint32_t) && IsAligned<4>(current_offset)) {
286 gaps->push(FieldGap {current_offset, sizeof(uint32_t)});
287 current_offset += sizeof(uint32_t);
288 } else if (remaining >= sizeof(uint16_t) && IsAligned<2>(current_offset)) {
289 gaps->push(FieldGap {current_offset, sizeof(uint16_t)});
290 current_offset += sizeof(uint16_t);
291 } else {
292 gaps->push(FieldGap {current_offset, sizeof(uint8_t)});
293 current_offset += sizeof(uint8_t);
294 }
295 DCHECK_LE(current_offset, gap_end) << "Overran gap";
296 }
297}
298// Shuffle fields forward, making use of gaps whenever possible.
299template<int n>
Vladimir Marko76649e82014-11-10 18:32:59 +0000300static void ShuffleForward(size_t* current_field_idx,
Fred Shih381e4ca2014-08-25 17:24:27 -0700301 MemberOffset* field_offset,
Mathieu Chartierc7853442015-03-27 14:35:38 -0700302 std::deque<ArtField*>* grouped_and_sorted_fields,
Fred Shih381e4ca2014-08-25 17:24:27 -0700303 FieldGaps* gaps)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700304 REQUIRES_SHARED(Locks::mutator_lock_) {
Fred Shih381e4ca2014-08-25 17:24:27 -0700305 DCHECK(current_field_idx != nullptr);
306 DCHECK(grouped_and_sorted_fields != nullptr);
Fred Shih381e4ca2014-08-25 17:24:27 -0700307 DCHECK(gaps != nullptr);
308 DCHECK(field_offset != nullptr);
309
310 DCHECK(IsPowerOfTwo(n));
311 while (!grouped_and_sorted_fields->empty()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700312 ArtField* field = grouped_and_sorted_fields->front();
Fred Shih381e4ca2014-08-25 17:24:27 -0700313 Primitive::Type type = field->GetTypeAsPrimitiveType();
314 if (Primitive::ComponentSize(type) < n) {
315 break;
316 }
317 if (!IsAligned<n>(field_offset->Uint32Value())) {
318 MemberOffset old_offset = *field_offset;
319 *field_offset = MemberOffset(RoundUp(field_offset->Uint32Value(), n));
320 AddFieldGap(old_offset.Uint32Value(), field_offset->Uint32Value(), gaps);
321 }
David Sehr709b0702016-10-13 09:12:37 -0700322 CHECK(type != Primitive::kPrimNot) << field->PrettyField(); // should be primitive types
Fred Shih381e4ca2014-08-25 17:24:27 -0700323 grouped_and_sorted_fields->pop_front();
Fred Shih381e4ca2014-08-25 17:24:27 -0700324 if (!gaps->empty() && gaps->top().size >= n) {
325 FieldGap gap = gaps->top();
326 gaps->pop();
Roland Levillain14d90572015-07-16 10:52:26 +0100327 DCHECK_ALIGNED(gap.start_offset, n);
Fred Shih381e4ca2014-08-25 17:24:27 -0700328 field->SetOffset(MemberOffset(gap.start_offset));
329 if (gap.size > n) {
330 AddFieldGap(gap.start_offset + n, gap.start_offset + gap.size, gaps);
331 }
332 } else {
Roland Levillain14d90572015-07-16 10:52:26 +0100333 DCHECK_ALIGNED(field_offset->Uint32Value(), n);
Fred Shih381e4ca2014-08-25 17:24:27 -0700334 field->SetOffset(*field_offset);
335 *field_offset = MemberOffset(field_offset->Uint32Value() + n);
336 }
337 ++(*current_field_idx);
338 }
339}
340
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800341ClassLinker::ClassLinker(InternTable* intern_table)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700342 // dex_lock_ is recursive as it may be used in stack dumping.
Mathieu Chartier6c60d842016-09-15 10:24:43 -0700343 : dex_lock_("ClassLinker dex lock", kDexLock),
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700344 failed_dex_cache_class_lookups_(0),
Ian Rogers98379392014-02-24 16:53:16 -0800345 class_roots_(nullptr),
346 array_iftable_(nullptr),
347 find_array_class_cache_next_victim_(0),
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700348 init_done_(false),
Mathieu Chartier893263b2014-03-04 11:07:42 -0800349 log_new_class_table_roots_(false),
Jeff Hao0aba0ba2013-06-03 14:49:28 -0700350 intern_table_(intern_table),
Ian Rogers98379392014-02-24 16:53:16 -0800351 quick_resolution_trampoline_(nullptr),
Andreas Gampe2da88232014-02-27 12:26:20 -0800352 quick_imt_conflict_trampoline_(nullptr),
Vladimir Marko8a630572014-04-09 18:45:35 +0100353 quick_generic_jni_trampoline_(nullptr),
Mathieu Chartier2d721012014-11-10 11:08:06 -0800354 quick_to_interpreter_bridge_trampoline_(nullptr),
Andreas Gampe542451c2016-07-26 09:02:02 -0700355 image_pointer_size_(kRuntimePointerSize) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700356 CHECK(intern_table_ != nullptr);
Andreas Gampe8ac75952015-06-02 21:01:45 -0700357 static_assert(kFindArrayCacheSize == arraysize(find_array_class_cache_),
358 "Array cache size wrong.");
359 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700360}
Brian Carlstroma663ea52011-08-19 23:33:41 -0700361
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800362void ClassLinker::CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700363 ObjPtr<mirror::Class> c2 = FindSystemClass(self, descriptor);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800364 if (c2 == nullptr) {
365 LOG(FATAL) << "Could not find class " << descriptor;
366 UNREACHABLE();
367 }
368 if (c1.Get() != c2) {
369 std::ostringstream os1, os2;
370 c1->DumpClass(os1, mirror::Class::kDumpClassFullDetail);
371 c2->DumpClass(os2, mirror::Class::kDumpClassFullDetail);
372 LOG(FATAL) << "InitWithoutImage: Class mismatch for " << descriptor
373 << ". This is most likely the result of a broken build. Make sure that "
374 << "libcore and art projects match.\n\n"
375 << os1.str() << "\n\n" << os2.str();
376 UNREACHABLE();
377 }
378}
379
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800380bool ClassLinker::InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path,
381 std::string* error_msg) {
Brian Carlstroma004aa92012-02-08 18:05:09 -0800382 VLOG(startup) << "ClassLinker::Init";
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700383
Mathieu Chartiere401d142015-04-22 13:56:20 -0700384 Thread* const self = Thread::Current();
385 Runtime* const runtime = Runtime::Current();
386 gc::Heap* const heap = runtime->GetHeap();
387
Jeff Haodcdc85b2015-12-04 14:06:18 -0800388 CHECK(!heap->HasBootImageSpace()) << "Runtime has image. We should use it.";
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700389 CHECK(!init_done_);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700390
Mathieu Chartiere401d142015-04-22 13:56:20 -0700391 // Use the pointer size from the runtime since we are probably creating the image.
392 image_pointer_size_ = InstructionSetPointerSize(runtime->GetInstructionSet());
393
Elliott Hughes30646832011-10-13 16:59:46 -0700394 // java_lang_Class comes first, it's needed for AllocClass
Mathieu Chartier590fee92013-09-13 13:46:47 -0700395 // 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 -0800396 heap->IncrementDisableMovingGC(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700397 StackHandleScope<64> hs(self); // 64 is picked arbitrarily.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700398 auto class_class_size = mirror::Class::ClassClassSize(image_pointer_size_);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700399 Handle<mirror::Class> java_lang_Class(hs.NewHandle(down_cast<mirror::Class*>(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700400 heap->AllocNonMovableObject<true>(self, nullptr, class_class_size, VoidFunctor()))));
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700401 CHECK(java_lang_Class.Get() != nullptr);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700402 mirror::Class::SetClassClass(java_lang_Class.Get());
403 java_lang_Class->SetClass(java_lang_Class.Get());
Hiroshi Yamauchi12b58b22016-11-01 11:55:29 -0700404 if (kUseBakerReadBarrier) {
405 java_lang_Class->AssertReadBarrierState();
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800406 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700407 java_lang_Class->SetClassSize(class_class_size);
Hiroshi Yamauchif0edfc32014-09-25 11:46:46 -0700408 java_lang_Class->SetPrimitiveType(Primitive::kPrimNot);
Mathieu Chartier1d27b342014-01-28 12:51:09 -0800409 heap->DecrementDisableMovingGC(self);
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700410 // AllocClass(ObjPtr<mirror::Class>) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -0700411
Elliott Hughes418d20f2011-09-22 14:00:39 -0700412 // Class[] is used for reflection support.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700413 auto class_array_class_size = mirror::ObjectArray<mirror::Class>::ClassSize(image_pointer_size_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700414 Handle<mirror::Class> class_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700415 AllocClass(self, java_lang_Class.Get(), class_array_class_size)));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700416 class_array_class->SetComponentType(java_lang_Class.Get());
Elliott Hughes418d20f2011-09-22 14:00:39 -0700417
Ian Rogers23435d02012-09-24 11:23:12 -0700418 // java_lang_Object comes next so that object_array_class can be created.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700419 Handle<mirror::Class> java_lang_Object(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700420 AllocClass(self, java_lang_Class.Get(), mirror::Object::ClassSize(image_pointer_size_))));
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700421 CHECK(java_lang_Object.Get() != nullptr);
Ian Rogers23435d02012-09-24 11:23:12 -0700422 // backfill Object as the super class of Class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700423 java_lang_Class->SetSuperClass(java_lang_Object.Get());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700424 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusLoaded, self);
Brian Carlstroma0808032011-07-18 00:39:23 -0700425
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700426 java_lang_Object->SetObjectSize(sizeof(mirror::Object));
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800427 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been
428 // cleared without triggering the read barrier and unintentionally mark the sentinel alive.
429 runtime->SetSentinel(heap->AllocNonMovableObject<true>(self,
430 java_lang_Object.Get(),
431 java_lang_Object->GetObjectSize(),
432 VoidFunctor()));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700433
Ian Rogers23435d02012-09-24 11:23:12 -0700434 // Object[] next to hold class roots.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700435 Handle<mirror::Class> object_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700436 AllocClass(self, java_lang_Class.Get(),
437 mirror::ObjectArray<mirror::Object>::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700438 object_array_class->SetComponentType(java_lang_Object.Get());
Brian Carlstroma0808032011-07-18 00:39:23 -0700439
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700440 // Setup the char (primitive) class to be used for char[].
441 Handle<mirror::Class> char_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700442 AllocClass(self, java_lang_Class.Get(),
443 mirror::Class::PrimitiveClassSize(image_pointer_size_))));
Hiroshi Yamauchif0edfc32014-09-25 11:46:46 -0700444 // The primitive char class won't be initialized by
445 // InitializePrimitiveClass until line 459, but strings (and
446 // internal char arrays) will be allocated before that and the
447 // component size, which is computed from the primitive type, needs
448 // to be set here.
449 char_class->SetPrimitiveType(Primitive::kPrimChar);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700450
Ian Rogers23435d02012-09-24 11:23:12 -0700451 // Setup the char[] class to be used for String.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700452 Handle<mirror::Class> char_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700453 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700454 char_array_class->SetComponentType(char_class.Get());
455 mirror::CharArray::SetArrayClass(char_array_class.Get());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700456
Ian Rogers23435d02012-09-24 11:23:12 -0700457 // Setup String.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700458 Handle<mirror::Class> java_lang_String(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700459 AllocClass(self, java_lang_Class.Get(), mirror::String::ClassSize(image_pointer_size_))));
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700460 java_lang_String->SetStringClass();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700461 mirror::String::SetClass(java_lang_String.Get());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700462 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusResolved, self);
Jesse Wilson14150742011-07-29 19:04:44 -0400463
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700464 // Setup java.lang.ref.Reference.
Fred Shih4ee7a662014-07-11 09:59:27 -0700465 Handle<mirror::Class> java_lang_ref_Reference(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700466 AllocClass(self, java_lang_Class.Get(), mirror::Reference::ClassSize(image_pointer_size_))));
Fred Shih4ee7a662014-07-11 09:59:27 -0700467 mirror::Reference::SetClass(java_lang_ref_Reference.Get());
468 java_lang_ref_Reference->SetObjectSize(mirror::Reference::InstanceSize());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700469 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusResolved, self);
Fred Shih4ee7a662014-07-11 09:59:27 -0700470
Ian Rogers23435d02012-09-24 11:23:12 -0700471 // Create storage for root classes, save away our work so far (requires descriptors).
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700472 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700473 mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.Get(),
474 kClassRootsMax));
475 CHECK(!class_roots_.IsNull());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700476 SetClassRoot(kJavaLangClass, java_lang_Class.Get());
477 SetClassRoot(kJavaLangObject, java_lang_Object.Get());
478 SetClassRoot(kClassArrayClass, class_array_class.Get());
479 SetClassRoot(kObjectArrayClass, object_array_class.Get());
480 SetClassRoot(kCharArrayClass, char_array_class.Get());
481 SetClassRoot(kJavaLangString, java_lang_String.Get());
Fred Shih4ee7a662014-07-11 09:59:27 -0700482 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700483
Mathieu Chartier6beced42016-11-15 15:51:31 -0800484 // Fill in the empty iftable. Needs to be done after the kObjectArrayClass root is set.
485 java_lang_Object->SetIfTable(AllocIfTable(self, 0));
486
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700487 // Setup the primitive type classes.
Ian Rogers50b35e22012-10-04 10:09:15 -0700488 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
489 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
490 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
491 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
492 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
493 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
494 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
495 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700496
Ian Rogers23435d02012-09-24 11:23:12 -0700497 // Create array interface entries to populate once we can load system classes.
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700498 array_iftable_ = GcRoot<mirror::IfTable>(AllocIfTable(self, 2));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700499
Ian Rogers23435d02012-09-24 11:23:12 -0700500 // Create int array type for AllocDexCache (done in AppendToBootClassPath).
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700501 Handle<mirror::Class> int_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700502 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700503 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700504 mirror::IntArray::SetArrayClass(int_array_class.Get());
505 SetClassRoot(kIntArrayClass, int_array_class.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700506
Mathieu Chartierc7853442015-03-27 14:35:38 -0700507 // Create long array type for AllocDexCache (done in AppendToBootClassPath).
508 Handle<mirror::Class> long_array_class(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700509 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
Mathieu Chartierc7853442015-03-27 14:35:38 -0700510 long_array_class->SetComponentType(GetClassRoot(kPrimitiveLong));
511 mirror::LongArray::SetArrayClass(long_array_class.Get());
512 SetClassRoot(kLongArrayClass, long_array_class.Get());
513
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700514 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -0700515
Ian Rogers52813c92012-10-11 11:50:38 -0700516 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700517 Handle<mirror::Class> java_lang_DexCache(hs.NewHandle(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700518 AllocClass(self, java_lang_Class.Get(), mirror::DexCache::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700519 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.Get());
Vladimir Marko05792b92015-08-03 11:56:49 +0100520 java_lang_DexCache->SetDexCacheClass();
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700521 java_lang_DexCache->SetObjectSize(mirror::DexCache::InstanceSize());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700522 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusResolved, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700523
Alex Lightd6251582016-10-31 11:12:30 -0700524
525 // Setup dalvik.system.ClassExt
526 Handle<mirror::Class> dalvik_system_ClassExt(hs.NewHandle(
527 AllocClass(self, java_lang_Class.Get(), mirror::ClassExt::ClassSize(image_pointer_size_))));
528 SetClassRoot(kDalvikSystemClassExt, dalvik_system_ClassExt.Get());
529 mirror::ClassExt::SetClass(dalvik_system_ClassExt.Get());
530 mirror::Class::SetStatus(dalvik_system_ClassExt, mirror::Class::kStatusResolved, self);
531
Mathieu Chartier66f19252012-09-18 08:57:04 -0700532 // Set up array classes for string, field, method
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700533 Handle<mirror::Class> object_array_string(hs.NewHandle(
534 AllocClass(self, java_lang_Class.Get(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700535 mirror::ObjectArray<mirror::String>::ClassSize(image_pointer_size_))));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700536 object_array_string->SetComponentType(java_lang_String.Get());
537 SetClassRoot(kJavaLangStringArrayClass, object_array_string.Get());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700538
Nicolas Geoffray796d6302016-03-13 22:22:31 +0000539 LinearAlloc* linear_alloc = runtime->GetLinearAlloc();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700540 // Create runtime resolution and imt conflict methods.
541 runtime->SetResolutionMethod(runtime->CreateResolutionMethod());
Nicolas Geoffray796d6302016-03-13 22:22:31 +0000542 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod(linear_alloc));
543 runtime->SetImtUnimplementedMethod(runtime->CreateImtConflictMethod(linear_alloc));
Ian Rogers4445a7e2012-10-05 17:19:13 -0700544
Ian Rogers23435d02012-09-24 11:23:12 -0700545 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
546 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
547 // these roots.
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800548 if (boot_class_path.empty()) {
549 *error_msg = "Boot classpath is empty.";
550 return false;
551 }
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800552 for (auto& dex_file : boot_class_path) {
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800553 if (dex_file.get() == nullptr) {
554 *error_msg = "Null dex file.";
555 return false;
556 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700557 AppendToBootClassPath(self, *dex_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800558 boot_dex_files_.push_back(std::move(dex_file));
Mathieu Chartier66f19252012-09-18 08:57:04 -0700559 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700560
561 // now we can use FindSystemClass
562
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700563 // run char class through InitializePrimitiveClass to finish init
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700564 InitializePrimitiveClass(char_class.Get(), Primitive::kPrimChar);
565 SetClassRoot(kPrimitiveChar, char_class.Get()); // needs descriptor
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700566
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700567 // Set up GenericJNI entrypoint. That is mainly a hack for common_compiler_test.h so that
568 // we do not need friend classes or a publicly exposed setter.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700569 quick_generic_jni_trampoline_ = GetQuickGenericJniStub();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800570 if (!runtime->IsAotCompiler()) {
Alex Light64ad14d2014-08-19 14:23:13 -0700571 // We need to set up the generic trampolines since we don't have an image.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700572 quick_resolution_trampoline_ = GetQuickResolutionStub();
573 quick_imt_conflict_trampoline_ = GetQuickImtConflictStub();
574 quick_to_interpreter_bridge_trampoline_ = GetQuickToInterpreterBridge();
Alex Light64ad14d2014-08-19 14:23:13 -0700575 }
Dmitry Petrochenkof0972a42014-05-16 17:43:39 +0700576
Alex Lightd6251582016-10-31 11:12:30 -0700577 // Object, String, ClassExt and DexCache need to be rerun through FindSystemClass to finish init
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700578 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800579 CheckSystemClass(self, java_lang_Object, "Ljava/lang/Object;");
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700580 CHECK_EQ(java_lang_Object->GetObjectSize(), mirror::Object::InstanceSize());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700581 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800582 CheckSystemClass(self, java_lang_String, "Ljava/lang/String;");
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700583 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800584 CheckSystemClass(self, java_lang_DexCache, "Ljava/lang/DexCache;");
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700585 CHECK_EQ(java_lang_DexCache->GetObjectSize(), mirror::DexCache::InstanceSize());
Alex Lightd6251582016-10-31 11:12:30 -0700586 mirror::Class::SetStatus(dalvik_system_ClassExt, mirror::Class::kStatusNotReady, self);
587 CheckSystemClass(self, dalvik_system_ClassExt, "Ldalvik/system/ClassExt;");
588 CHECK_EQ(dalvik_system_ClassExt->GetObjectSize(), mirror::ClassExt::InstanceSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700589
Ian Rogers23435d02012-09-24 11:23:12 -0700590 // Setup the primitive array type classes - can't be done until Object has a vtable.
Ian Rogers98379392014-02-24 16:53:16 -0800591 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800592 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700593
Ian Rogers98379392014-02-24 16:53:16 -0800594 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800595 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700596
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800597 CheckSystemClass(self, char_array_class, "[C");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700598
Ian Rogers98379392014-02-24 16:53:16 -0800599 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800600 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700601
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800602 CheckSystemClass(self, int_array_class, "[I");
603 CheckSystemClass(self, long_array_class, "[J");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700604
Ian Rogers98379392014-02-24 16:53:16 -0800605 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800606 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700607
Ian Rogers98379392014-02-24 16:53:16 -0800608 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800609 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700610
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800611 // Run Class through FindSystemClass. This initializes the dex_cache_ fields and register it
612 // in class_table_.
613 CheckSystemClass(self, java_lang_Class, "Ljava/lang/Class;");
Elliott Hughes418d20f2011-09-22 14:00:39 -0700614
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800615 CheckSystemClass(self, class_array_class, "[Ljava/lang/Class;");
616 CheckSystemClass(self, object_array_class, "[Ljava/lang/Object;");
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700617
Ian Rogers23435d02012-09-24 11:23:12 -0700618 // Setup the single, global copy of "iftable".
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700619 auto java_lang_Cloneable = hs.NewHandle(FindSystemClass(self, "Ljava/lang/Cloneable;"));
620 CHECK(java_lang_Cloneable.Get() != nullptr);
621 auto java_io_Serializable = hs.NewHandle(FindSystemClass(self, "Ljava/io/Serializable;"));
622 CHECK(java_io_Serializable.Get() != nullptr);
Ian Rogers23435d02012-09-24 11:23:12 -0700623 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
624 // crawl up and explicitly list all of the supers as well.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700625 array_iftable_.Read()->SetInterface(0, java_lang_Cloneable.Get());
626 array_iftable_.Read()->SetInterface(1, java_io_Serializable.Get());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700627
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700628 // Sanity check Class[] and Object[]'s interfaces. GetDirectInterface may cause thread
629 // suspension.
630 CHECK_EQ(java_lang_Cloneable.Get(),
631 mirror::Class::GetDirectInterface(self, class_array_class, 0));
632 CHECK_EQ(java_io_Serializable.Get(),
633 mirror::Class::GetDirectInterface(self, class_array_class, 1));
634 CHECK_EQ(java_lang_Cloneable.Get(),
635 mirror::Class::GetDirectInterface(self, object_array_class, 0));
636 CHECK_EQ(java_io_Serializable.Get(),
637 mirror::Class::GetDirectInterface(self, object_array_class, 1));
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700638
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700639 CHECK_EQ(object_array_string.Get(),
640 FindSystemClass(self, GetClassRootDescriptor(kJavaLangStringArrayClass)));
Brian Carlstrom1f870082011-08-23 16:02:11 -0700641
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800642 // End of special init trickery, all subsequent classes may be loaded via FindSystemClass.
Ian Rogers466bb252011-10-14 03:29:56 -0700643
Ian Rogers23435d02012-09-24 11:23:12 -0700644 // Create java.lang.reflect.Proxy root.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700645 SetClassRoot(kJavaLangReflectProxy, FindSystemClass(self, "Ljava/lang/reflect/Proxy;"));
Ian Rogers466bb252011-10-14 03:29:56 -0700646
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700647 // Create java.lang.reflect.Field.class root.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700648 auto* class_root = FindSystemClass(self, "Ljava/lang/reflect/Field;");
649 CHECK(class_root != nullptr);
650 SetClassRoot(kJavaLangReflectField, class_root);
651 mirror::Field::SetClass(class_root);
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700652
653 // Create java.lang.reflect.Field array root.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700654 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Field;");
655 CHECK(class_root != nullptr);
656 SetClassRoot(kJavaLangReflectFieldArrayClass, class_root);
657 mirror::Field::SetArrayClass(class_root);
658
659 // Create java.lang.reflect.Constructor.class root and array root.
660 class_root = FindSystemClass(self, "Ljava/lang/reflect/Constructor;");
661 CHECK(class_root != nullptr);
662 SetClassRoot(kJavaLangReflectConstructor, class_root);
663 mirror::Constructor::SetClass(class_root);
664 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Constructor;");
665 CHECK(class_root != nullptr);
666 SetClassRoot(kJavaLangReflectConstructorArrayClass, class_root);
667 mirror::Constructor::SetArrayClass(class_root);
668
669 // Create java.lang.reflect.Method.class root and array root.
670 class_root = FindSystemClass(self, "Ljava/lang/reflect/Method;");
671 CHECK(class_root != nullptr);
672 SetClassRoot(kJavaLangReflectMethod, class_root);
673 mirror::Method::SetClass(class_root);
674 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Method;");
675 CHECK(class_root != nullptr);
676 SetClassRoot(kJavaLangReflectMethodArrayClass, class_root);
677 mirror::Method::SetArrayClass(class_root);
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700678
Narayan Kamathafa48272016-08-03 12:46:58 +0100679 // Create java.lang.invoke.MethodType.class root
680 class_root = FindSystemClass(self, "Ljava/lang/invoke/MethodType;");
681 CHECK(class_root != nullptr);
682 SetClassRoot(kJavaLangInvokeMethodType, class_root);
683 mirror::MethodType::SetClass(class_root);
684
685 // Create java.lang.invoke.MethodHandleImpl.class root
686 class_root = FindSystemClass(self, "Ljava/lang/invoke/MethodHandleImpl;");
687 CHECK(class_root != nullptr);
688 SetClassRoot(kJavaLangInvokeMethodHandleImpl, class_root);
689 mirror::MethodHandleImpl::SetClass(class_root);
690
Narayan Kamath000e1882016-10-24 17:14:25 +0100691 class_root = FindSystemClass(self, "Ldalvik/system/EmulatedStackFrame;");
692 CHECK(class_root != nullptr);
693 SetClassRoot(kDalvikSystemEmulatedStackFrame, class_root);
694 mirror::EmulatedStackFrame::SetClass(class_root);
695
Brian Carlstrom1f870082011-08-23 16:02:11 -0700696 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes
Fred Shih4ee7a662014-07-11 09:59:27 -0700697 // finish initializing Reference class
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -0700698 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusNotReady, self);
Andreas Gampe7ba5a672016-02-04 21:45:01 -0800699 CheckSystemClass(self, java_lang_ref_Reference, "Ljava/lang/ref/Reference;");
Fred Shih4ee7a662014-07-11 09:59:27 -0700700 CHECK_EQ(java_lang_ref_Reference->GetObjectSize(), mirror::Reference::InstanceSize());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700701 CHECK_EQ(java_lang_ref_Reference->GetClassSize(),
702 mirror::Reference::ClassSize(image_pointer_size_));
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700703 class_root = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700704 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700705 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagFinalizerReference);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700706 class_root = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700707 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700708 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagPhantomReference);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700709 class_root = FindSystemClass(self, "Ljava/lang/ref/SoftReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700710 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700711 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagSoftReference);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700712 class_root = FindSystemClass(self, "Ljava/lang/ref/WeakReference;");
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -0700713 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -0700714 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagWeakReference);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700715
Ian Rogers23435d02012-09-24 11:23:12 -0700716 // Setup the ClassLoader, verifying the object_size_.
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700717 class_root = FindSystemClass(self, "Ljava/lang/ClassLoader;");
Mathieu Chartiere4275c02015-08-06 15:34:15 -0700718 class_root->SetClassLoaderClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700719 CHECK_EQ(class_root->GetObjectSize(), mirror::ClassLoader::InstanceSize());
720 SetClassRoot(kJavaLangClassLoader, class_root);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700721
jeffhao8cd6dda2012-02-22 10:15:34 -0800722 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
Ian Rogers23435d02012-09-24 11:23:12 -0700723 // java.lang.StackTraceElement as a convenience.
Ian Rogers98379392014-02-24 16:53:16 -0800724 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800725 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
Brian Carlstromf3632832014-05-20 15:36:53 -0700726 SetClassRoot(kJavaLangClassNotFoundException,
727 FindSystemClass(self, "Ljava/lang/ClassNotFoundException;"));
Ian Rogers98379392014-02-24 16:53:16 -0800728 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;"));
Brian Carlstromf3632832014-05-20 15:36:53 -0700729 SetClassRoot(kJavaLangStackTraceElementArrayClass,
730 FindSystemClass(self, "[Ljava/lang/StackTraceElement;"));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800731 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700732
Andreas Gampe76bd8802014-12-10 16:43:58 -0800733 // Ensure void type is resolved in the core's dex cache so java.lang.Void is correctly
734 // initialized.
735 {
736 const DexFile& dex_file = java_lang_Object->GetDexFile();
Mathieu Chartier9507fa22015-10-29 15:08:57 -0700737 const DexFile::TypeId* void_type_id = dex_file.FindTypeId("V");
Andreas Gampe76bd8802014-12-10 16:43:58 -0800738 CHECK(void_type_id != nullptr);
Andreas Gampea5b09a62016-11-17 15:21:22 -0800739 dex::TypeIndex void_type_idx = dex_file.GetIndexForTypeId(*void_type_id);
Andreas Gampe76bd8802014-12-10 16:43:58 -0800740 // Now we resolve void type so the dex cache contains it. We use java.lang.Object class
741 // as referrer so the used dex cache is core's one.
Andreas Gampea5b09a62016-11-17 15:21:22 -0800742 ObjPtr<mirror::Class> resolved_type = ResolveType(dex_file,
743 void_type_idx,
744 java_lang_Object.Get());
Andreas Gampe76bd8802014-12-10 16:43:58 -0800745 CHECK_EQ(resolved_type, GetClassRoot(kPrimitiveVoid));
746 self->AssertNoPendingException();
747 }
748
Mathieu Chartiercdca4762016-04-28 09:44:54 -0700749 // Create conflict tables that depend on the class linker.
750 runtime->FixupConflictTables();
751
Ian Rogers98379392014-02-24 16:53:16 -0800752 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700753
Brian Carlstroma004aa92012-02-08 18:05:09 -0800754 VLOG(startup) << "ClassLinker::InitFromCompiler exiting";
Andreas Gampe3db9c5d2015-11-17 11:52:46 -0800755
756 return true;
Brian Carlstroma663ea52011-08-19 23:33:41 -0700757}
758
Ian Rogers98379392014-02-24 16:53:16 -0800759void ClassLinker::FinishInit(Thread* self) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800760 VLOG(startup) << "ClassLinker::FinishInit entering";
Brian Carlstrom16192862011-09-12 17:50:06 -0700761
762 // Let the heap know some key offsets into java.lang.ref instances
Elliott Hughes20cde902011-10-04 17:37:27 -0700763 // Note: we hard code the field indexes here rather than using FindInstanceField
Brian Carlstrom16192862011-09-12 17:50:06 -0700764 // as the types of the field can't be resolved prior to the runtime being
765 // fully initialized
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700766 StackHandleScope<2> hs(self);
767 Handle<mirror::Class> java_lang_ref_Reference = hs.NewHandle(GetClassRoot(kJavaLangRefReference));
768 Handle<mirror::Class> java_lang_ref_FinalizerReference =
769 hs.NewHandle(FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800770
Mathieu Chartierc7853442015-03-27 14:35:38 -0700771 ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700772 CHECK_STREQ(pendingNext->GetName(), "pendingNext");
773 CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700774
Mathieu Chartierc7853442015-03-27 14:35:38 -0700775 ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700776 CHECK_STREQ(queue->GetName(), "queue");
777 CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700778
Mathieu Chartierc7853442015-03-27 14:35:38 -0700779 ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700780 CHECK_STREQ(queueNext->GetName(), "queueNext");
781 CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700782
Mathieu Chartierc7853442015-03-27 14:35:38 -0700783 ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700784 CHECK_STREQ(referent->GetName(), "referent");
785 CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700786
Mathieu Chartierc7853442015-03-27 14:35:38 -0700787 ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700788 CHECK_STREQ(zombie->GetName(), "zombie");
789 CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;");
Brian Carlstrom16192862011-09-12 17:50:06 -0700790
Brian Carlstroma663ea52011-08-19 23:33:41 -0700791 // ensure all class_roots_ are initialized
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700792 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstroma663ea52011-08-19 23:33:41 -0700793 ClassRoot class_root = static_cast<ClassRoot>(i);
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700794 ObjPtr<mirror::Class> klass = GetClassRoot(class_root);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700795 CHECK(klass != nullptr);
796 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != nullptr);
Brian Carlstroma663ea52011-08-19 23:33:41 -0700797 // note SetClassRoot does additional validation.
798 // if possible add new checks there to catch errors early
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700799 }
800
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700801 CHECK(!array_iftable_.IsNull());
Elliott Hughes92f14b22011-10-06 12:29:54 -0700802
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700803 // disable the slow paths in FindClass and CreatePrimitiveClass now
804 // that Object, Class, and Object[] are setup
805 init_done_ = true;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700806
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800807 VLOG(startup) << "ClassLinker::FinishInit exiting";
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700808}
809
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700810void ClassLinker::RunRootClinits() {
811 Thread* self = Thread::Current();
812 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700813 ObjPtr<mirror::Class> c = GetClassRoot(ClassRoot(i));
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700814 if (!c->IsArrayClass() && !c->IsPrimitive()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700815 StackHandleScope<1> hs(self);
816 Handle<mirror::Class> h_class(hs.NewHandle(GetClassRoot(ClassRoot(i))));
Ian Rogers7b078e82014-09-10 14:44:24 -0700817 EnsureInitialized(self, h_class, true, true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700818 self->AssertNoPendingException();
Elliott Hughes2a20cfd2011-09-23 19:30:41 -0700819 }
820 }
821}
822
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -0700823static void SanityCheckArtMethod(ArtMethod* m,
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700824 ObjPtr<mirror::Class> expected_class,
Jeff Haoacd7a6a2016-01-08 10:44:20 -0800825 const std::vector<gc::space::ImageSpace*>& spaces)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700826 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700827 if (m->IsRuntimeMethod()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700828 ObjPtr<mirror::Class> declaring_class = m->GetDeclaringClassUnchecked();
David Sehr709b0702016-10-13 09:12:37 -0700829 CHECK(declaring_class == nullptr) << declaring_class << " " << m->PrettyMethod();
Alex Light36121492016-02-22 13:43:29 -0800830 } else if (m->IsCopied()) {
David Sehr709b0702016-10-13 09:12:37 -0700831 CHECK(m->GetDeclaringClass() != nullptr) << m->PrettyMethod();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700832 } else if (expected_class != nullptr) {
David Sehr709b0702016-10-13 09:12:37 -0700833 CHECK_EQ(m->GetDeclaringClassUnchecked(), expected_class) << m->PrettyMethod();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700834 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800835 if (!spaces.empty()) {
836 bool contains = false;
837 for (gc::space::ImageSpace* space : spaces) {
838 auto& header = space->GetImageHeader();
Mathieu Chartiercdca4762016-04-28 09:44:54 -0700839 size_t offset = reinterpret_cast<uint8_t*>(m) - space->Begin();
840
841 const ImageSection& methods = header.GetMethodsSection();
842 contains = contains || methods.Contains(offset);
843
844 const ImageSection& runtime_methods = header.GetRuntimeMethodsSection();
845 contains = contains || runtime_methods.Contains(offset);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800846 }
847 CHECK(contains) << m << " not found";
Mathieu Chartiere401d142015-04-22 13:56:20 -0700848 }
849}
850
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700851static void SanityCheckArtMethodPointerArray(ObjPtr<mirror::PointerArray> arr,
852 ObjPtr<mirror::Class> expected_class,
Andreas Gampe542451c2016-07-26 09:02:02 -0700853 PointerSize pointer_size,
Jeff Haoacd7a6a2016-01-08 10:44:20 -0800854 const std::vector<gc::space::ImageSpace*>& spaces)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700855 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700856 CHECK(arr != nullptr);
857 for (int32_t j = 0; j < arr->GetLength(); ++j) {
858 auto* method = arr->GetElementPtrSize<ArtMethod*>(j, pointer_size);
859 // expected_class == null means we are a dex cache.
860 if (expected_class != nullptr) {
861 CHECK(method != nullptr);
862 }
863 if (method != nullptr) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800864 SanityCheckArtMethod(method, expected_class, spaces);
Ian Rogers848871b2013-08-05 10:56:33 -0700865 }
866 }
867}
868
Jeff Hao1c1a3422016-01-05 14:13:00 -0800869static void SanityCheckArtMethodPointerArray(ArtMethod** arr,
870 size_t size,
Andreas Gampe542451c2016-07-26 09:02:02 -0700871 PointerSize pointer_size,
Jeff Haoacd7a6a2016-01-08 10:44:20 -0800872 const std::vector<gc::space::ImageSpace*>& spaces)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700873 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Marko05792b92015-08-03 11:56:49 +0100874 CHECK_EQ(arr != nullptr, size != 0u);
875 if (arr != nullptr) {
Jeff Hao1c1a3422016-01-05 14:13:00 -0800876 bool contains = false;
877 for (auto space : spaces) {
878 auto offset = reinterpret_cast<uint8_t*>(arr) - space->Begin();
879 if (space->GetImageHeader().GetImageSection(
880 ImageHeader::kSectionDexCacheArrays).Contains(offset)) {
881 contains = true;
882 break;
883 }
884 }
885 CHECK(contains);
Vladimir Marko05792b92015-08-03 11:56:49 +0100886 }
887 for (size_t j = 0; j < size; ++j) {
888 ArtMethod* method = mirror::DexCache::GetElementPtrSize(arr, j, pointer_size);
889 // expected_class == null means we are a dex cache.
890 if (method != nullptr) {
Jeff Hao1c1a3422016-01-05 14:13:00 -0800891 SanityCheckArtMethod(method, nullptr, spaces);
Vladimir Marko05792b92015-08-03 11:56:49 +0100892 }
893 }
894}
895
Mathieu Chartiere401d142015-04-22 13:56:20 -0700896static void SanityCheckObjectsCallback(mirror::Object* obj, void* arg ATTRIBUTE_UNUSED)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700897 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700898 DCHECK(obj != nullptr);
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700899 CHECK(obj->GetClass() != nullptr) << "Null class in object " << obj;
Mathieu Chartierc7853442015-03-27 14:35:38 -0700900 CHECK(obj->GetClass()->GetClass() != nullptr) << "Null class class " << obj;
901 if (obj->IsClass()) {
902 auto klass = obj->AsClass();
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700903 for (ArtField& field : klass->GetIFields()) {
904 CHECK_EQ(field.GetDeclaringClass(), klass);
905 }
906 for (ArtField& field : klass->GetSFields()) {
907 CHECK_EQ(field.GetDeclaringClass(), klass);
Mathieu Chartierc7853442015-03-27 14:35:38 -0700908 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700909 auto* runtime = Runtime::Current();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800910 auto image_spaces = runtime->GetHeap()->GetBootImageSpaces();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700911 auto pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
Alex Lighte64300b2015-12-15 15:02:47 -0800912 for (auto& m : klass->GetMethods(pointer_size)) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800913 SanityCheckArtMethod(&m, klass, image_spaces);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700914 }
915 auto* vtable = klass->GetVTable();
916 if (vtable != nullptr) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800917 SanityCheckArtMethodPointerArray(vtable, nullptr, pointer_size, image_spaces);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700918 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +0000919 if (klass->ShouldHaveImt()) {
920 ImTable* imt = klass->GetImt(pointer_size);
921 for (size_t i = 0; i < ImTable::kSize; ++i) {
922 SanityCheckArtMethod(imt->Get(i, pointer_size), nullptr, image_spaces);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700923 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +0000924 }
925 if (klass->ShouldHaveEmbeddedVTable()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700926 for (int32_t i = 0; i < klass->GetEmbeddedVTableLength(); ++i) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800927 SanityCheckArtMethod(klass->GetEmbeddedVTableEntry(i, pointer_size), nullptr, image_spaces);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700928 }
929 }
Mathieu Chartier6beced42016-11-15 15:51:31 -0800930 mirror::IfTable* iftable = klass->GetIfTable();
931 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
932 if (iftable->GetMethodArrayCount(i) > 0) {
933 SanityCheckArtMethodPointerArray(
934 iftable->GetMethodArray(i), nullptr, pointer_size, image_spaces);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700935 }
936 }
Mathieu Chartierc7853442015-03-27 14:35:38 -0700937 }
938}
939
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200940// Set image methods' entry point to interpreter.
941class SetInterpreterEntrypointArtMethodVisitor : public ArtMethodVisitor {
942 public:
Andreas Gampe542451c2016-07-26 09:02:02 -0700943 explicit SetInterpreterEntrypointArtMethodVisitor(PointerSize image_pointer_size)
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200944 : image_pointer_size_(image_pointer_size) {}
945
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700946 void Visit(ArtMethod* method) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200947 if (kIsDebugBuild && !method->IsRuntimeMethod()) {
948 CHECK(method->GetDeclaringClass() != nullptr);
949 }
950 if (!method->IsNative() && !method->IsRuntimeMethod() && !method->IsResolutionMethod()) {
951 method->SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(),
952 image_pointer_size_);
953 }
954 }
955
956 private:
Andreas Gampe542451c2016-07-26 09:02:02 -0700957 const PointerSize image_pointer_size_;
Sebastien Hertz46e857a2015-08-06 12:52:43 +0200958
959 DISALLOW_COPY_AND_ASSIGN(SetInterpreterEntrypointArtMethodVisitor);
960};
961
Jeff Haodcdc85b2015-12-04 14:06:18 -0800962struct TrampolineCheckData {
963 const void* quick_resolution_trampoline;
964 const void* quick_imt_conflict_trampoline;
965 const void* quick_generic_jni_trampoline;
966 const void* quick_to_interpreter_bridge_trampoline;
Andreas Gampe542451c2016-07-26 09:02:02 -0700967 PointerSize pointer_size;
Jeff Haodcdc85b2015-12-04 14:06:18 -0800968 ArtMethod* m;
969 bool error;
970};
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800971
Jeff Haodcdc85b2015-12-04 14:06:18 -0800972static void CheckTrampolines(mirror::Object* obj, void* arg) NO_THREAD_SAFETY_ANALYSIS {
973 if (obj->IsClass()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700974 ObjPtr<mirror::Class> klass = obj->AsClass();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800975 TrampolineCheckData* d = reinterpret_cast<TrampolineCheckData*>(arg);
976 for (ArtMethod& m : klass->GetMethods(d->pointer_size)) {
977 const void* entrypoint = m.GetEntryPointFromQuickCompiledCodePtrSize(d->pointer_size);
978 if (entrypoint == d->quick_resolution_trampoline ||
979 entrypoint == d->quick_imt_conflict_trampoline ||
980 entrypoint == d->quick_generic_jni_trampoline ||
981 entrypoint == d->quick_to_interpreter_bridge_trampoline) {
982 d->m = &m;
983 d->error = true;
984 return;
985 }
986 }
987 }
988}
989
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800990bool ClassLinker::InitFromBootImage(std::string* error_msg) {
991 VLOG(startup) << __FUNCTION__ << " entering";
Brian Carlstroma663ea52011-08-19 23:33:41 -0700992 CHECK(!init_done_);
993
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700994 Runtime* const runtime = Runtime::Current();
995 Thread* const self = Thread::Current();
996 gc::Heap* const heap = runtime->GetHeap();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800997 std::vector<gc::space::ImageSpace*> spaces = heap->GetBootImageSpaces();
998 CHECK(!spaces.empty());
Andreas Gampe542451c2016-07-26 09:02:02 -0700999 uint32_t pointer_size_unchecked = spaces[0]->GetImageHeader().GetPointerSizeUnchecked();
1000 if (!ValidPointerSize(pointer_size_unchecked)) {
1001 *error_msg = StringPrintf("Invalid image pointer size: %u", pointer_size_unchecked);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001002 return false;
1003 }
Andreas Gampe542451c2016-07-26 09:02:02 -07001004 image_pointer_size_ = spaces[0]->GetImageHeader().GetPointerSize();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001005 if (!runtime->IsAotCompiler()) {
1006 // Only the Aot compiler supports having an image with a different pointer size than the
1007 // runtime. This happens on the host for compiling 32 bit tests since we use a 64 bit libart
1008 // compiler. We may also use 32 bit dex2oat on a system with 64 bit apps.
Andreas Gampe542451c2016-07-26 09:02:02 -07001009 if (image_pointer_size_ != kRuntimePointerSize) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001010 *error_msg = StringPrintf("Runtime must use current image pointer size: %zu vs %zu",
Andreas Gampe542451c2016-07-26 09:02:02 -07001011 static_cast<size_t>(image_pointer_size_),
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001012 sizeof(void*));
1013 return false;
1014 }
1015 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08001016 std::vector<const OatFile*> oat_files =
1017 runtime->GetOatFileManager().RegisterImageOatFiles(spaces);
1018 DCHECK(!oat_files.empty());
1019 const OatHeader& default_oat_header = oat_files[0]->GetOatHeader();
1020 CHECK_EQ(default_oat_header.GetImageFileLocationOatChecksum(), 0U);
1021 CHECK_EQ(default_oat_header.GetImageFileLocationOatDataBegin(), 0U);
1022 const char* image_file_location = oat_files[0]->GetOatHeader().
Andreas Gampe22f8e5c2014-07-09 11:38:21 -07001023 GetStoreValueByKey(OatHeader::kImageLocationKey);
1024 CHECK(image_file_location == nullptr || *image_file_location == 0);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001025 quick_resolution_trampoline_ = default_oat_header.GetQuickResolutionTrampoline();
1026 quick_imt_conflict_trampoline_ = default_oat_header.GetQuickImtConflictTrampoline();
1027 quick_generic_jni_trampoline_ = default_oat_header.GetQuickGenericJniTrampoline();
1028 quick_to_interpreter_bridge_trampoline_ = default_oat_header.GetQuickToInterpreterBridge();
1029 if (kIsDebugBuild) {
1030 // Check that the other images use the same trampoline.
1031 for (size_t i = 1; i < oat_files.size(); ++i) {
1032 const OatHeader& ith_oat_header = oat_files[i]->GetOatHeader();
1033 const void* ith_quick_resolution_trampoline =
1034 ith_oat_header.GetQuickResolutionTrampoline();
1035 const void* ith_quick_imt_conflict_trampoline =
1036 ith_oat_header.GetQuickImtConflictTrampoline();
1037 const void* ith_quick_generic_jni_trampoline =
1038 ith_oat_header.GetQuickGenericJniTrampoline();
1039 const void* ith_quick_to_interpreter_bridge_trampoline =
1040 ith_oat_header.GetQuickToInterpreterBridge();
1041 if (ith_quick_resolution_trampoline != quick_resolution_trampoline_ ||
1042 ith_quick_imt_conflict_trampoline != quick_imt_conflict_trampoline_ ||
1043 ith_quick_generic_jni_trampoline != quick_generic_jni_trampoline_ ||
1044 ith_quick_to_interpreter_bridge_trampoline != quick_to_interpreter_bridge_trampoline_) {
1045 // Make sure that all methods in this image do not contain those trampolines as
1046 // entrypoints. Otherwise the class-linker won't be able to work with a single set.
1047 TrampolineCheckData data;
1048 data.error = false;
1049 data.pointer_size = GetImagePointerSize();
1050 data.quick_resolution_trampoline = ith_quick_resolution_trampoline;
1051 data.quick_imt_conflict_trampoline = ith_quick_imt_conflict_trampoline;
1052 data.quick_generic_jni_trampoline = ith_quick_generic_jni_trampoline;
1053 data.quick_to_interpreter_bridge_trampoline = ith_quick_to_interpreter_bridge_trampoline;
1054 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
1055 spaces[i]->GetLiveBitmap()->Walk(CheckTrampolines, &data);
1056 if (data.error) {
1057 ArtMethod* m = data.m;
David Sehr709b0702016-10-13 09:12:37 -07001058 LOG(ERROR) << "Found a broken ArtMethod: " << ArtMethod::PrettyMethod(m);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001059 *error_msg = "Found an ArtMethod with a bad entrypoint";
1060 return false;
1061 }
1062 }
1063 }
1064 }
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001065
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001066 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(
1067 down_cast<mirror::ObjectArray<mirror::Class>*>(
1068 spaces[0]->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)));
1069 mirror::Class::SetClassClass(class_roots_.Read()->Get(kJavaLangClass));
Mathieu Chartier02b6a782012-10-26 13:51:26 -07001070
Brian Carlstromfddf6f62012-03-15 16:56:45 -07001071 // Special case of setting up the String class early so that we can test arbitrary objects
1072 // as being Strings or not
Anwar Ghuloumc4f105d2013-04-10 16:12:11 -07001073 mirror::String::SetClass(GetClassRoot(kJavaLangString));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001074
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001075 ObjPtr<mirror::Class> java_lang_Object = GetClassRoot(kJavaLangObject);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001076 java_lang_Object->SetObjectSize(sizeof(mirror::Object));
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001077 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been
1078 // cleared without triggering the read barrier and unintentionally mark the sentinel alive.
Jeff Haodcdc85b2015-12-04 14:06:18 -08001079 runtime->SetSentinel(heap->AllocNonMovableObject<true>(
1080 self, java_lang_Object, java_lang_Object->GetObjectSize(), VoidFunctor()));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001081
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001082 // reinit array_iftable_ from any array class instance, they should be ==
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001083 array_iftable_ = GcRoot<mirror::IfTable>(GetClassRoot(kObjectArrayClass)->GetIfTable());
Mathieu Chartier2d721012014-11-10 11:08:06 -08001084 DCHECK_EQ(array_iftable_.Read(), GetClassRoot(kBooleanArrayClass)->GetIfTable());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001085 // String class root was set above
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07001086 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
1087 mirror::Field::SetArrayClass(GetClassRoot(kJavaLangReflectFieldArrayClass));
Mathieu Chartierfc58af42015-04-16 18:00:39 -07001088 mirror::Constructor::SetClass(GetClassRoot(kJavaLangReflectConstructor));
1089 mirror::Constructor::SetArrayClass(GetClassRoot(kJavaLangReflectConstructorArrayClass));
1090 mirror::Method::SetClass(GetClassRoot(kJavaLangReflectMethod));
1091 mirror::Method::SetArrayClass(GetClassRoot(kJavaLangReflectMethodArrayClass));
Narayan Kamathafa48272016-08-03 12:46:58 +01001092 mirror::MethodType::SetClass(GetClassRoot(kJavaLangInvokeMethodType));
1093 mirror::MethodHandleImpl::SetClass(GetClassRoot(kJavaLangInvokeMethodHandleImpl));
Fred Shih4ee7a662014-07-11 09:59:27 -07001094 mirror::Reference::SetClass(GetClassRoot(kJavaLangRefReference));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001095 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
1096 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
1097 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
1098 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
1099 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
1100 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
1101 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
1102 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
1103 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
1104 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
Narayan Kamath000e1882016-10-24 17:14:25 +01001105 mirror::EmulatedStackFrame::SetClass(GetClassRoot(kDalvikSystemEmulatedStackFrame));
Alex Lightd6251582016-10-31 11:12:30 -07001106 mirror::ClassExt::SetClass(GetClassRoot(kDalvikSystemClassExt));
Brian Carlstroma663ea52011-08-19 23:33:41 -07001107
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001108 for (gc::space::ImageSpace* image_space : spaces) {
1109 // Boot class loader, use a null handle.
1110 std::vector<std::unique_ptr<const DexFile>> dex_files;
1111 if (!AddImageSpace(image_space,
1112 ScopedNullHandle<mirror::ClassLoader>(),
1113 /*dex_elements*/nullptr,
1114 /*dex_location*/nullptr,
1115 /*out*/&dex_files,
1116 error_msg)) {
1117 return false;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001118 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001119 // Append opened dex files at the end.
1120 boot_dex_files_.insert(boot_dex_files_.end(),
1121 std::make_move_iterator(dex_files.begin()),
1122 std::make_move_iterator(dex_files.end()));
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08001123 }
Ian Rogers98379392014-02-24 16:53:16 -08001124 FinishInit(self);
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -07001125
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001126 VLOG(startup) << __FUNCTION__ << " exiting";
1127 return true;
1128}
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001129
Jeff Hao5872d7c2016-04-27 11:07:41 -07001130bool ClassLinker::IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001131 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001132 return class_loader == nullptr ||
Mathieu Chartier0795f232016-09-27 18:43:30 -07001133 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader) ==
1134 class_loader->GetClass();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001135}
1136
Andreas Gampe08883de2016-11-08 13:20:52 -08001137static mirror::String* GetDexPathListElementName(ObjPtr<mirror::Object> element)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001138 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001139 ArtField* const dex_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001140 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001141 ArtField* const dex_file_name_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001142 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_fileName);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001143 DCHECK(dex_file_field != nullptr);
1144 DCHECK(dex_file_name_field != nullptr);
1145 DCHECK(element != nullptr);
David Sehr709b0702016-10-13 09:12:37 -07001146 CHECK_EQ(dex_file_field->GetDeclaringClass(), element->GetClass()) << element->PrettyTypeOf();
Mathieu Chartier3398c782016-09-30 10:27:43 -07001147 ObjPtr<mirror::Object> dex_file = dex_file_field->GetObject(element);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001148 if (dex_file == nullptr) {
1149 return nullptr;
1150 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07001151 ObjPtr<mirror::Object> name_object = dex_file_name_field->GetObject(dex_file);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001152 if (name_object != nullptr) {
1153 return name_object->AsString();
1154 }
1155 return nullptr;
1156}
1157
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001158static bool FlattenPathClassLoader(ObjPtr<mirror::ClassLoader> class_loader,
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001159 std::list<mirror::String*>* out_dex_file_names,
1160 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001161 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001162 DCHECK(out_dex_file_names != nullptr);
1163 DCHECK(error_msg != nullptr);
1164 ScopedObjectAccessUnchecked soa(Thread::Current());
1165 ArtField* const dex_path_list_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001166 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001167 ArtField* const dex_elements_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08001168 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001169 CHECK(dex_path_list_field != nullptr);
1170 CHECK(dex_elements_field != nullptr);
Jeff Hao5872d7c2016-04-27 11:07:41 -07001171 while (!ClassLinker::IsBootClassLoader(soa, class_loader)) {
Mathieu Chartier0795f232016-09-27 18:43:30 -07001172 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader) !=
1173 class_loader->GetClass()) {
David Sehr709b0702016-10-13 09:12:37 -07001174 *error_msg = StringPrintf("Unknown class loader type %s",
1175 class_loader->PrettyTypeOf().c_str());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001176 // Unsupported class loader.
1177 return false;
1178 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07001179 ObjPtr<mirror::Object> dex_path_list = dex_path_list_field->GetObject(class_loader);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001180 if (dex_path_list != nullptr) {
1181 // DexPathList has an array dexElements of Elements[] which each contain a dex file.
Mathieu Chartier3398c782016-09-30 10:27:43 -07001182 ObjPtr<mirror::Object> dex_elements_obj = dex_elements_field->GetObject(dex_path_list);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001183 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
1184 // at the mCookie which is a DexFile vector.
1185 if (dex_elements_obj != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001186 ObjPtr<mirror::ObjectArray<mirror::Object>> dex_elements =
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001187 dex_elements_obj->AsObjectArray<mirror::Object>();
1188 // Reverse order since we insert the parent at the front.
1189 for (int32_t i = dex_elements->GetLength() - 1; i >= 0; --i) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001190 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001191 if (element == nullptr) {
1192 *error_msg = StringPrintf("Null dex element at index %d", i);
1193 return false;
1194 }
Andreas Gampe08883de2016-11-08 13:20:52 -08001195 ObjPtr<mirror::String> const name = GetDexPathListElementName(element);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001196 if (name == nullptr) {
1197 *error_msg = StringPrintf("Null name for dex element at index %d", i);
1198 return false;
1199 }
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07001200 out_dex_file_names->push_front(name.Ptr());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001201 }
1202 }
1203 }
1204 class_loader = class_loader->GetParent();
1205 }
1206 return true;
1207}
1208
1209class FixupArtMethodArrayVisitor : public ArtMethodVisitor {
1210 public:
1211 explicit FixupArtMethodArrayVisitor(const ImageHeader& header) : header_(header) {}
1212
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001213 virtual void Visit(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe542451c2016-07-26 09:02:02 -07001214 GcRoot<mirror::Class>* resolved_types = method->GetDexCacheResolvedTypes(kRuntimePointerSize);
Alex Light36121492016-02-22 13:43:29 -08001215 const bool is_copied = method->IsCopied();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001216 if (resolved_types != nullptr) {
1217 bool in_image_space = false;
Alex Light36121492016-02-22 13:43:29 -08001218 if (kIsDebugBuild || is_copied) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001219 in_image_space = header_.GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains(
1220 reinterpret_cast<const uint8_t*>(resolved_types) - header_.GetImageBegin());
1221 }
1222 // Must be in image space for non-miranda method.
Alex Light36121492016-02-22 13:43:29 -08001223 DCHECK(is_copied || in_image_space)
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001224 << resolved_types << " is not in image starting at "
1225 << reinterpret_cast<void*>(header_.GetImageBegin());
Alex Light36121492016-02-22 13:43:29 -08001226 if (!is_copied || in_image_space) {
Vladimir Marko6dd14882016-10-25 11:51:35 +01001227 method->SetDexCacheResolvedTypes(method->GetDexCache()->GetResolvedTypes(),
Andreas Gampe542451c2016-07-26 09:02:02 -07001228 kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001229 }
1230 }
Andreas Gampe542451c2016-07-26 09:02:02 -07001231 ArtMethod** resolved_methods = method->GetDexCacheResolvedMethods(kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001232 if (resolved_methods != nullptr) {
1233 bool in_image_space = false;
Alex Light36121492016-02-22 13:43:29 -08001234 if (kIsDebugBuild || is_copied) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001235 in_image_space = header_.GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains(
1236 reinterpret_cast<const uint8_t*>(resolved_methods) - header_.GetImageBegin());
1237 }
1238 // Must be in image space for non-miranda method.
Alex Light36121492016-02-22 13:43:29 -08001239 DCHECK(is_copied || in_image_space)
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001240 << resolved_methods << " is not in image starting at "
1241 << reinterpret_cast<void*>(header_.GetImageBegin());
Alex Light36121492016-02-22 13:43:29 -08001242 if (!is_copied || in_image_space) {
Vladimir Marko6dd14882016-10-25 11:51:35 +01001243 method->SetDexCacheResolvedMethods(method->GetDexCache()->GetResolvedMethods(),
Andreas Gampe542451c2016-07-26 09:02:02 -07001244 kRuntimePointerSize);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001245 }
1246 }
1247 }
1248
1249 private:
1250 const ImageHeader& header_;
1251};
1252
1253class VerifyClassInTableArtMethodVisitor : public ArtMethodVisitor {
1254 public:
1255 explicit VerifyClassInTableArtMethodVisitor(ClassTable* table) : table_(table) {}
1256
1257 virtual void Visit(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001258 REQUIRES_SHARED(Locks::mutator_lock_, Locks::classlinker_classes_lock_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001259 ObjPtr<mirror::Class> klass = method->GetDeclaringClass();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001260 if (klass != nullptr && !Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) {
David Sehr709b0702016-10-13 09:12:37 -07001261 CHECK_EQ(table_->LookupByDescriptor(klass), klass) << mirror::Class::PrettyClass(klass);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001262 }
1263 }
1264
1265 private:
1266 ClassTable* const table_;
1267};
1268
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001269class VerifyDeclaringClassVisitor : public ArtMethodVisitor {
1270 public:
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001271 VerifyDeclaringClassVisitor() REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_)
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001272 : live_bitmap_(Runtime::Current()->GetHeap()->GetLiveBitmap()) {}
1273
1274 virtual void Visit(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001275 REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001276 ObjPtr<mirror::Class> klass = method->GetDeclaringClassUnchecked();
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001277 if (klass != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001278 CHECK(live_bitmap_->Test(klass.Ptr())) << "Image method has unmarked declaring class";
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001279 }
1280 }
1281
1282 private:
1283 gc::accounting::HeapBitmap* const live_bitmap_;
1284};
1285
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001286// Copies data from one array to another array at the same position
1287// if pred returns false. If there is a page of continuous data in
1288// the src array for which pred consistently returns true then
1289// corresponding page in the dst array will not be touched.
1290// This should reduce number of allocated physical pages.
1291template <class T, class NullPred>
1292static void CopyNonNull(const T* src, size_t count, T* dst, const NullPred& pred) {
1293 for (size_t i = 0; i < count; ++i) {
1294 if (!pred(src[i])) {
1295 dst[i] = src[i];
1296 }
1297 }
1298}
1299
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001300bool ClassLinker::UpdateAppImageClassLoadersAndDexCaches(
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001301 gc::space::ImageSpace* space,
1302 Handle<mirror::ClassLoader> class_loader,
1303 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
Mathieu Chartier69731002016-03-02 16:08:31 -08001304 ClassTable::ClassSet* new_class_set,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001305 bool* out_forward_dex_cache_array,
1306 std::string* out_error_msg) {
1307 DCHECK(out_forward_dex_cache_array != nullptr);
1308 DCHECK(out_error_msg != nullptr);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001309 Thread* const self = Thread::Current();
1310 gc::Heap* const heap = Runtime::Current()->GetHeap();
1311 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001312 {
1313 // Add image classes into the class table for the class loader, and fixup the dex caches and
1314 // class loader fields.
1315 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001316 // Dex cache array fixup is all or nothing, we must reject app images that have mixed since we
1317 // rely on clobering the dex cache arrays in the image to forward to bss.
1318 size_t num_dex_caches_with_bss_arrays = 0;
1319 const size_t num_dex_caches = dex_caches->GetLength();
1320 for (size_t i = 0; i < num_dex_caches; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001321 ObjPtr<mirror::DexCache> const dex_cache = dex_caches->Get(i);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001322 const DexFile* const dex_file = dex_cache->GetDexFile();
1323 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
1324 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
1325 ++num_dex_caches_with_bss_arrays;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001326 }
1327 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001328 *out_forward_dex_cache_array = num_dex_caches_with_bss_arrays != 0;
1329 if (*out_forward_dex_cache_array) {
1330 if (num_dex_caches_with_bss_arrays != num_dex_caches) {
1331 // Reject application image since we cannot forward only some of the dex cache arrays.
1332 // TODO: We could get around this by having a dedicated forwarding slot. It should be an
1333 // uncommon case.
1334 *out_error_msg = StringPrintf("Dex caches in bss does not match total: %zu vs %zu",
1335 num_dex_caches_with_bss_arrays,
1336 num_dex_caches);
1337 return false;
1338 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001339 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001340 // Only add the classes to the class loader after the points where we can return false.
1341 for (size_t i = 0; i < num_dex_caches; i++) {
Vladimir Marko1bc4b172016-10-24 16:53:39 +00001342 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001343 const DexFile* const dex_file = dex_cache->GetDexFile();
1344 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
1345 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
Narayan Kamath25352fc2016-08-03 12:46:58 +01001346 // 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 -08001347 // copy over the arrays.
1348 DCHECK(dex_file != nullptr);
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001349 size_t num_strings = mirror::DexCache::kDexCacheStringCacheSize;
1350 if (dex_file->NumStringIds() < num_strings) {
1351 num_strings = dex_file->NumStringIds();
1352 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001353 const size_t num_types = dex_file->NumTypeIds();
1354 const size_t num_methods = dex_file->NumMethodIds();
1355 const size_t num_fields = dex_file->NumFieldIds();
Narayan Kamath269cb432016-10-28 10:19:54 +01001356 size_t num_method_types = mirror::DexCache::kDexCacheMethodTypeCacheSize;
1357 if (dex_file->NumProtoIds() < num_method_types) {
1358 num_method_types = dex_file->NumProtoIds();
Narayan Kamath25352fc2016-08-03 12:46:58 +01001359 }
1360
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001361 CHECK_EQ(num_strings, dex_cache->NumStrings());
1362 CHECK_EQ(num_types, dex_cache->NumResolvedTypes());
1363 CHECK_EQ(num_methods, dex_cache->NumResolvedMethods());
1364 CHECK_EQ(num_fields, dex_cache->NumResolvedFields());
Narayan Kamath25352fc2016-08-03 12:46:58 +01001365 CHECK_EQ(num_method_types, dex_cache->NumResolvedMethodTypes());
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001366 DexCacheArraysLayout layout(image_pointer_size_, dex_file);
1367 uint8_t* const raw_arrays = oat_dex_file->GetDexCacheArrays();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001368 if (num_strings != 0u) {
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001369 mirror::StringDexCacheType* const image_resolved_strings = dex_cache->GetStrings();
1370 mirror::StringDexCacheType* const strings =
1371 reinterpret_cast<mirror::StringDexCacheType*>(raw_arrays + layout.StringsOffset());
1372 for (size_t j = 0; j < num_strings; ++j) {
Narayan Kamathc38a6f82016-09-29 17:07:20 +01001373 DCHECK_EQ(strings[j].load(std::memory_order_relaxed).index, 0u);
1374 DCHECK(strings[j].load(std::memory_order_relaxed).object.IsNull());
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001375 strings[j].store(image_resolved_strings[j].load(std::memory_order_relaxed),
1376 std::memory_order_relaxed);
Mathieu Chartier9b1c9b72016-02-02 10:09:58 -08001377 }
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001378 mirror::StringDexCachePair::Initialize(strings);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001379 dex_cache->SetStrings(strings);
1380 }
1381 if (num_types != 0u) {
1382 GcRoot<mirror::Class>* const image_resolved_types = dex_cache->GetResolvedTypes();
1383 GcRoot<mirror::Class>* const types =
1384 reinterpret_cast<GcRoot<mirror::Class>*>(raw_arrays + layout.TypesOffset());
1385 for (size_t j = 0; kIsDebugBuild && j < num_types; ++j) {
1386 DCHECK(types[j].IsNull());
1387 }
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001388 CopyNonNull(image_resolved_types,
1389 num_types,
1390 types,
1391 [](const GcRoot<mirror::Class>& elem) {
1392 return elem.IsNull();
1393 });
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001394 dex_cache->SetResolvedTypes(types);
1395 }
1396 if (num_methods != 0u) {
1397 ArtMethod** const methods = reinterpret_cast<ArtMethod**>(
1398 raw_arrays + layout.MethodsOffset());
1399 ArtMethod** const image_resolved_methods = dex_cache->GetResolvedMethods();
1400 for (size_t j = 0; kIsDebugBuild && j < num_methods; ++j) {
1401 DCHECK(methods[j] == nullptr);
1402 }
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001403 CopyNonNull(image_resolved_methods,
1404 num_methods,
1405 methods,
1406 [] (const ArtMethod* method) {
1407 return method == nullptr;
1408 });
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001409 dex_cache->SetResolvedMethods(methods);
1410 }
1411 if (num_fields != 0u) {
1412 ArtField** const fields =
1413 reinterpret_cast<ArtField**>(raw_arrays + layout.FieldsOffset());
1414 for (size_t j = 0; kIsDebugBuild && j < num_fields; ++j) {
1415 DCHECK(fields[j] == nullptr);
1416 }
Artem Udovichenkob3ac45b2016-09-09 14:02:25 +03001417 CopyNonNull(dex_cache->GetResolvedFields(),
1418 num_fields,
1419 fields,
1420 [] (const ArtField* field) {
1421 return field == nullptr;
1422 });
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001423 dex_cache->SetResolvedFields(fields);
1424 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01001425 if (num_method_types != 0u) {
1426 // NOTE: We currently (Sep 2016) do not resolve any method types at
1427 // compile time, but plan to in the future. This code exists for the
1428 // sake of completeness.
1429 mirror::MethodTypeDexCacheType* const image_resolved_method_types =
1430 dex_cache->GetResolvedMethodTypes();
1431 mirror::MethodTypeDexCacheType* const method_types =
1432 reinterpret_cast<mirror::MethodTypeDexCacheType*>(
1433 raw_arrays + layout.MethodTypesOffset());
1434 for (size_t j = 0; j < num_method_types; ++j) {
1435 DCHECK_EQ(method_types[j].load(std::memory_order_relaxed).index, 0u);
1436 DCHECK(method_types[j].load(std::memory_order_relaxed).object.IsNull());
1437 method_types[j].store(
1438 image_resolved_method_types[j].load(std::memory_order_relaxed),
1439 std::memory_order_relaxed);
1440 }
1441
Narayan Kamath7fe56582016-10-14 18:49:12 +01001442 mirror::MethodTypeDexCachePair::Initialize(method_types);
Narayan Kamath25352fc2016-08-03 12:46:58 +01001443 dex_cache->SetResolvedMethodTypes(method_types);
1444 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001445 }
1446 {
1447 WriterMutexLock mu2(self, dex_lock_);
1448 // Make sure to do this after we update the arrays since we store the resolved types array
1449 // in DexCacheData in RegisterDexFileLocked. We need the array pointer to be the one in the
1450 // BSS.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001451 ObjPtr<mirror::DexCache> existing_dex_cache = FindDexCacheLocked(self,
1452 *dex_file,
1453 /*allow_failure*/true);
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001454 CHECK(existing_dex_cache == nullptr);
1455 StackHandleScope<1> hs3(self);
Vladimir Marko1bc4b172016-10-24 16:53:39 +00001456 Handle<mirror::DexCache> h_dex_cache = hs3.NewHandle(dex_cache);
1457 RegisterDexFileLocked(*dex_file, h_dex_cache);
1458 if (kIsDebugBuild) {
1459 dex_cache.Assign(h_dex_cache.Get()); // Update dex_cache, used below in debug build.
1460 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001461 }
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001462 if (kIsDebugBuild) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01001463 CHECK(new_class_set != nullptr);
1464 GcRoot<mirror::Class>* const types = dex_cache->GetResolvedTypes();
1465 const size_t num_types = dex_cache->NumResolvedTypes();
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001466 for (int32_t j = 0; j < static_cast<int32_t>(num_types); j++) {
1467 // The image space is not yet added to the heap, avoid read barriers.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001468 ObjPtr<mirror::Class> klass = types[j].Read();
1469 if (space->HasAddress(klass.Ptr())) {
Mathieu Chartier064e9d42016-03-07 17:41:39 -08001470 DCHECK_NE(klass->GetStatus(), mirror::Class::kStatusError);
Vladimir Marko1a1de672016-10-13 12:53:15 +01001471 auto it = new_class_set->Find(GcRoot<mirror::Class>(klass));
1472 DCHECK(it != new_class_set->end());
1473 DCHECK_EQ(it->Read(), klass);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001474 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Vladimir Marko1a1de672016-10-13 12:53:15 +01001475 if (super_class != nullptr && !heap->ObjectIsInBootImageSpace(super_class)) {
1476 auto it2 = new_class_set->Find(GcRoot<mirror::Class>(super_class));
1477 DCHECK(it2 != new_class_set->end());
1478 DCHECK_EQ(it2->Read(), super_class);
1479 }
1480 for (ArtMethod& m : klass->GetDirectMethods(kRuntimePointerSize)) {
1481 const void* code = m.GetEntryPointFromQuickCompiledCode();
1482 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
1483 if (!IsQuickResolutionStub(code) &&
1484 !IsQuickGenericJniStub(code) &&
1485 !IsQuickToInterpreterBridge(code) &&
1486 !m.IsNative()) {
David Sehr709b0702016-10-13 09:12:37 -07001487 DCHECK_EQ(code, oat_code) << m.PrettyMethod();
Mathieu Chartier69731002016-03-02 16:08:31 -08001488 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001489 }
Vladimir Marko1a1de672016-10-13 12:53:15 +01001490 for (ArtMethod& m : klass->GetVirtualMethods(kRuntimePointerSize)) {
1491 const void* code = m.GetEntryPointFromQuickCompiledCode();
1492 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
1493 if (!IsQuickResolutionStub(code) &&
1494 !IsQuickGenericJniStub(code) &&
1495 !IsQuickToInterpreterBridge(code) &&
1496 !m.IsNative()) {
David Sehr709b0702016-10-13 09:12:37 -07001497 DCHECK_EQ(code, oat_code) << m.PrettyMethod();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001498 }
1499 }
1500 }
1501 }
1502 }
1503 }
Mathieu Chartiera0b95212016-03-07 16:13:54 -08001504 }
1505 if (*out_forward_dex_cache_array) {
1506 ScopedTrace timing("Fixup ArtMethod dex cache arrays");
1507 FixupArtMethodArrayVisitor visitor(header);
Andreas Gampe542451c2016-07-26 09:02:02 -07001508 header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
Mathieu Chartiera0b95212016-03-07 16:13:54 -08001509 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get());
1510 }
1511 if (kVerifyArtMethodDeclaringClasses) {
1512 ScopedTrace timing("Verify declaring classes");
1513 ReaderMutexLock rmu(self, *Locks::heap_bitmap_lock_);
1514 VerifyDeclaringClassVisitor visitor;
Andreas Gampe542451c2016-07-26 09:02:02 -07001515 header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
Mathieu Chartier03c1dd92016-03-07 16:13:54 -08001516 }
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001517 return true;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001518}
1519
Mathieu Chartier69731002016-03-02 16:08:31 -08001520// Update the class loader and resolved string dex cache array of classes. Should only be used on
1521// classes in the image space.
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001522class UpdateClassLoaderAndResolvedStringsVisitor {
1523 public:
1524 UpdateClassLoaderAndResolvedStringsVisitor(gc::space::ImageSpace* space,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001525 ObjPtr<mirror::ClassLoader> class_loader,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001526 bool forward_strings)
1527 : space_(space),
1528 class_loader_(class_loader),
1529 forward_strings_(forward_strings) {}
1530
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001531 bool operator()(ObjPtr<mirror::Class> klass) const REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001532 if (forward_strings_) {
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001533 mirror::StringDexCacheType* strings = klass->GetDexCacheStrings();
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001534 if (strings != nullptr) {
Vladimir Marko69a04052016-02-02 14:43:28 +00001535 DCHECK(
1536 space_->GetImageHeader().GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains(
1537 reinterpret_cast<uint8_t*>(strings) - space_->Begin()))
David Sehr709b0702016-10-13 09:12:37 -07001538 << "String dex cache array for " << klass->PrettyClass() << " is not in app image";
Vladimir Marko69a04052016-02-02 14:43:28 +00001539 // Dex caches have already been updated, so take the strings pointer from there.
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07001540 mirror::StringDexCacheType* new_strings = klass->GetDexCache()->GetStrings();
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001541 DCHECK_NE(strings, new_strings);
1542 klass->SetDexCacheStrings(new_strings);
1543 }
1544 }
1545 // Finally, update class loader.
1546 klass->SetClassLoader(class_loader_);
1547 return true;
1548 }
1549
1550 gc::space::ImageSpace* const space_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001551 ObjPtr<mirror::ClassLoader> const class_loader_;
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001552 const bool forward_strings_;
1553};
1554
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001555static std::unique_ptr<const DexFile> OpenOatDexFile(const OatFile* oat_file,
1556 const char* location,
1557 std::string* error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001558 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001559 DCHECK(error_msg != nullptr);
1560 std::unique_ptr<const DexFile> dex_file;
Richard Uhler9a37efc2016-08-05 16:32:55 -07001561 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(location, nullptr, error_msg);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001562 if (oat_dex_file == nullptr) {
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001563 return std::unique_ptr<const DexFile>();
1564 }
1565 std::string inner_error_msg;
1566 dex_file = oat_dex_file->OpenDexFile(&inner_error_msg);
1567 if (dex_file == nullptr) {
1568 *error_msg = StringPrintf("Failed to open dex file %s from within oat file %s error '%s'",
1569 location,
1570 oat_file->GetLocation().c_str(),
1571 inner_error_msg.c_str());
1572 return std::unique_ptr<const DexFile>();
1573 }
1574
1575 if (dex_file->GetLocationChecksum() != oat_dex_file->GetDexFileLocationChecksum()) {
1576 *error_msg = StringPrintf("Checksums do not match for %s: %x vs %x",
1577 location,
1578 dex_file->GetLocationChecksum(),
1579 oat_dex_file->GetDexFileLocationChecksum());
1580 return std::unique_ptr<const DexFile>();
1581 }
1582 return dex_file;
1583}
1584
1585bool ClassLinker::OpenImageDexFiles(gc::space::ImageSpace* space,
1586 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
1587 std::string* error_msg) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07001588 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001589 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001590 ObjPtr<mirror::Object> dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001591 DCHECK(dex_caches_object != nullptr);
1592 mirror::ObjectArray<mirror::DexCache>* dex_caches =
1593 dex_caches_object->AsObjectArray<mirror::DexCache>();
1594 const OatFile* oat_file = space->GetOatFile();
1595 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001596 ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001597 std::string dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
1598 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file,
1599 dex_file_location.c_str(),
1600 error_msg);
1601 if (dex_file == nullptr) {
1602 return false;
1603 }
1604 dex_cache->SetDexFile(dex_file.get());
1605 out_dex_files->push_back(std::move(dex_file));
1606 }
1607 return true;
1608}
1609
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001610bool ClassLinker::AddImageSpace(
1611 gc::space::ImageSpace* space,
1612 Handle<mirror::ClassLoader> class_loader,
1613 jobjectArray dex_elements,
1614 const char* dex_location,
1615 std::vector<std::unique_ptr<const DexFile>>* out_dex_files,
1616 std::string* error_msg) {
1617 DCHECK(out_dex_files != nullptr);
1618 DCHECK(error_msg != nullptr);
1619 const uint64_t start_time = NanoTime();
1620 const bool app_image = class_loader.Get() != nullptr;
1621 const ImageHeader& header = space->GetImageHeader();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001622 ObjPtr<mirror::Object> dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001623 DCHECK(dex_caches_object != nullptr);
1624 Runtime* const runtime = Runtime::Current();
1625 gc::Heap* const heap = runtime->GetHeap();
1626 Thread* const self = Thread::Current();
1627 StackHandleScope<2> hs(self);
1628 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches(
1629 hs.NewHandle(dex_caches_object->AsObjectArray<mirror::DexCache>()));
1630 Handle<mirror::ObjectArray<mirror::Class>> class_roots(hs.NewHandle(
1631 header.GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>()));
1632 const OatFile* oat_file = space->GetOatFile();
1633 std::unordered_set<mirror::ClassLoader*> image_class_loaders;
1634 // Check that the image is what we are expecting.
1635 if (image_pointer_size_ != space->GetImageHeader().GetPointerSize()) {
1636 *error_msg = StringPrintf("Application image pointer size does not match runtime: %zu vs %zu",
1637 static_cast<size_t>(space->GetImageHeader().GetPointerSize()),
1638 image_pointer_size_);
1639 return false;
1640 }
1641 DCHECK(class_roots.Get() != nullptr);
1642 if (class_roots->GetLength() != static_cast<int32_t>(kClassRootsMax)) {
1643 *error_msg = StringPrintf("Expected %d class roots but got %d",
1644 class_roots->GetLength(),
1645 static_cast<int32_t>(kClassRootsMax));
1646 return false;
1647 }
1648 // Check against existing class roots to make sure they match the ones in the boot image.
1649 for (size_t i = 0; i < kClassRootsMax; i++) {
1650 if (class_roots->Get(i) != GetClassRoot(static_cast<ClassRoot>(i))) {
1651 *error_msg = "App image class roots must have pointer equality with runtime ones.";
1652 return false;
1653 }
1654 }
1655 if (oat_file->GetOatHeader().GetDexFileCount() !=
1656 static_cast<uint32_t>(dex_caches->GetLength())) {
1657 *error_msg = "Dex cache count and dex file count mismatch while trying to initialize from "
1658 "image";
1659 return false;
1660 }
1661
1662 StackHandleScope<1> hs2(self);
1663 MutableHandle<mirror::DexCache> h_dex_cache(hs2.NewHandle<mirror::DexCache>(nullptr));
1664 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
1665 h_dex_cache.Assign(dex_caches->Get(i));
1666 std::string dex_file_location(h_dex_cache->GetLocation()->ToModifiedUtf8());
1667 // TODO: Only store qualified paths.
1668 // If non qualified, qualify it.
1669 if (dex_file_location.find('/') == std::string::npos) {
1670 std::string dex_location_path = dex_location;
1671 const size_t pos = dex_location_path.find_last_of('/');
1672 CHECK_NE(pos, std::string::npos);
1673 dex_location_path = dex_location_path.substr(0, pos + 1); // Keep trailing '/'
1674 dex_file_location = dex_location_path + dex_file_location;
1675 }
Mathieu Chartierbcb6a722016-03-08 16:49:58 -08001676 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file,
1677 dex_file_location.c_str(),
1678 error_msg);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001679 if (dex_file == nullptr) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001680 return false;
1681 }
1682
1683 if (app_image) {
1684 // The current dex file field is bogus, overwrite it so that we can get the dex file in the
1685 // loop below.
1686 h_dex_cache->SetDexFile(dex_file.get());
1687 // Check that each class loader resolved the same way.
1688 // TODO: Store image class loaders as image roots.
1689 GcRoot<mirror::Class>* const types = h_dex_cache->GetResolvedTypes();
1690 for (int32_t j = 0, num_types = h_dex_cache->NumResolvedTypes(); j < num_types; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001691 ObjPtr<mirror::Class> klass = types[j].Read();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001692 if (klass != nullptr) {
1693 DCHECK_NE(klass->GetStatus(), mirror::Class::kStatusError);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001694 ObjPtr<mirror::ClassLoader> image_class_loader = klass->GetClassLoader();
1695 image_class_loaders.insert(image_class_loader.Ptr());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001696 }
1697 }
1698 } else {
1699 if (kSanityCheckObjects) {
1700 SanityCheckArtMethodPointerArray(h_dex_cache->GetResolvedMethods(),
1701 h_dex_cache->NumResolvedMethods(),
1702 image_pointer_size_,
1703 heap->GetBootImageSpaces());
1704 }
1705 // Register dex files, keep track of existing ones that are conflicts.
1706 AppendToBootClassPath(*dex_file.get(), h_dex_cache);
1707 }
1708 out_dex_files->push_back(std::move(dex_file));
1709 }
1710
1711 if (app_image) {
1712 ScopedObjectAccessUnchecked soa(Thread::Current());
1713 // Check that the class loader resolves the same way as the ones in the image.
1714 // Image class loader [A][B][C][image dex files]
1715 // Class loader = [???][dex_elements][image dex files]
1716 // Need to ensure that [???][dex_elements] == [A][B][C].
1717 // For each class loader, PathClassLoader, the laoder checks the parent first. Also the logic
1718 // for PathClassLoader does this by looping through the array of dex files. To ensure they
1719 // resolve the same way, simply flatten the hierarchy in the way the resolution order would be,
1720 // and check that the dex file names are the same.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001721 for (ObjPtr<mirror::ClassLoader> image_class_loader : image_class_loaders) {
Nicolas Geoffray1df3b552016-04-26 18:30:31 +01001722 if (IsBootClassLoader(soa, image_class_loader)) {
1723 // The dex cache can reference types from the boot class loader.
1724 continue;
1725 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001726 std::list<mirror::String*> image_dex_file_names;
1727 std::string temp_error_msg;
1728 if (!FlattenPathClassLoader(image_class_loader, &image_dex_file_names, &temp_error_msg)) {
1729 *error_msg = StringPrintf("Failed to flatten image class loader hierarchy '%s'",
1730 temp_error_msg.c_str());
1731 return false;
1732 }
1733 std::list<mirror::String*> loader_dex_file_names;
1734 if (!FlattenPathClassLoader(class_loader.Get(), &loader_dex_file_names, &temp_error_msg)) {
1735 *error_msg = StringPrintf("Failed to flatten class loader hierarchy '%s'",
1736 temp_error_msg.c_str());
1737 return false;
1738 }
1739 // Add the temporary dex path list elements at the end.
Mathieu Chartier0795f232016-09-27 18:43:30 -07001740 auto elements = soa.Decode<mirror::ObjectArray<mirror::Object>>(dex_elements);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001741 for (size_t i = 0, num_elems = elements->GetLength(); i < num_elems; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001742 ObjPtr<mirror::Object> element = elements->GetWithoutChecks(i);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001743 if (element != nullptr) {
1744 // If we are somewhere in the middle of the array, there may be nulls at the end.
Andreas Gampe08883de2016-11-08 13:20:52 -08001745 loader_dex_file_names.push_back(GetDexPathListElementName(element));
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001746 }
1747 }
1748 // Ignore the number of image dex files since we are adding those to the class loader anyways.
1749 CHECK_GE(static_cast<size_t>(image_dex_file_names.size()),
1750 static_cast<size_t>(dex_caches->GetLength()));
1751 size_t image_count = image_dex_file_names.size() - dex_caches->GetLength();
1752 // Check that the dex file names match.
1753 bool equal = image_count == loader_dex_file_names.size();
1754 if (equal) {
1755 auto it1 = image_dex_file_names.begin();
1756 auto it2 = loader_dex_file_names.begin();
1757 for (size_t i = 0; equal && i < image_count; ++i, ++it1, ++it2) {
1758 equal = equal && (*it1)->Equals(*it2);
1759 }
1760 }
1761 if (!equal) {
Mathieu Chartierd329a3b2016-01-27 15:30:10 -08001762 VLOG(image) << "Image dex files " << image_dex_file_names.size();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001763 for (ObjPtr<mirror::String> name : image_dex_file_names) {
Mathieu Chartierd329a3b2016-01-27 15:30:10 -08001764 VLOG(image) << name->ToModifiedUtf8();
1765 }
1766 VLOG(image) << "Loader dex files " << loader_dex_file_names.size();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001767 for (ObjPtr<mirror::String> name : loader_dex_file_names) {
Mathieu Chartierd329a3b2016-01-27 15:30:10 -08001768 VLOG(image) << name->ToModifiedUtf8();
1769 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001770 *error_msg = "Rejecting application image due to class loader mismatch";
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08001771 // Ignore class loader mismatch for now since these would just use possibly incorrect
1772 // oat code anyways. The structural class check should be done in the parent.
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001773 }
1774 }
1775 }
1776
1777 if (kSanityCheckObjects) {
1778 for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
1779 auto* dex_cache = dex_caches->Get(i);
1780 for (size_t j = 0; j < dex_cache->NumResolvedFields(); ++j) {
1781 auto* field = dex_cache->GetResolvedField(j, image_pointer_size_);
1782 if (field != nullptr) {
1783 CHECK(field->GetDeclaringClass()->GetClass() != nullptr);
1784 }
1785 }
1786 }
1787 if (!app_image) {
1788 heap->VisitObjects(SanityCheckObjectsCallback, nullptr);
1789 }
1790 }
1791
1792 // Set entry point to interpreter if in InterpretOnly mode.
1793 if (!runtime->IsAotCompiler() && runtime->GetInstrumentation()->InterpretOnly()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001794 SetInterpreterEntrypointArtMethodVisitor visitor(image_pointer_size_);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07001795 header.VisitPackedArtMethods(&visitor, space->Begin(), image_pointer_size_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001796 }
1797
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001798 ClassTable* class_table = nullptr;
1799 {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001800 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001801 class_table = InsertClassTableForClassLoader(class_loader.Get());
Mathieu Chartier69731002016-03-02 16:08:31 -08001802 }
1803 // If we have a class table section, read it and use it for verification in
1804 // UpdateAppImageClassLoadersAndDexCaches.
1805 ClassTable::ClassSet temp_set;
1806 const ImageSection& class_table_section = header.GetImageSection(ImageHeader::kSectionClassTable);
1807 const bool added_class_table = class_table_section.Size() > 0u;
1808 if (added_class_table) {
1809 const uint64_t start_time2 = NanoTime();
1810 size_t read_count = 0;
1811 temp_set = ClassTable::ClassSet(space->Begin() + class_table_section.Offset(),
1812 /*make copy*/false,
1813 &read_count);
Mathieu Chartier69731002016-03-02 16:08:31 -08001814 VLOG(image) << "Adding class table classes took " << PrettyDuration(NanoTime() - start_time2);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001815 }
1816 if (app_image) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001817 bool forward_dex_cache_arrays = false;
1818 if (!UpdateAppImageClassLoadersAndDexCaches(space,
1819 class_loader,
1820 dex_caches,
Vladimir Marko1a1de672016-10-13 12:53:15 +01001821 &temp_set,
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001822 /*out*/&forward_dex_cache_arrays,
1823 /*out*/error_msg)) {
1824 return false;
1825 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001826 // Update class loader and resolved strings. If added_class_table is false, the resolved
1827 // strings were forwarded UpdateAppImageClassLoadersAndDexCaches.
1828 UpdateClassLoaderAndResolvedStringsVisitor visitor(space,
1829 class_loader.Get(),
1830 forward_dex_cache_arrays);
Vladimir Marko1a1de672016-10-13 12:53:15 +01001831 for (GcRoot<mirror::Class>& root : temp_set) {
1832 visitor(root.Read());
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001833 }
Mathieu Chartier8c4f0412016-02-03 16:40:20 -08001834 // forward_dex_cache_arrays is true iff we copied all of the dex cache arrays into the .bss.
1835 // In this case, madvise away the dex cache arrays section of the image to reduce RAM usage and
1836 // mark as PROT_NONE to catch any invalid accesses.
1837 if (forward_dex_cache_arrays) {
1838 const ImageSection& dex_cache_section = header.GetImageSection(
1839 ImageHeader::kSectionDexCacheArrays);
1840 uint8_t* section_begin = AlignUp(space->Begin() + dex_cache_section.Offset(), kPageSize);
1841 uint8_t* section_end = AlignDown(space->Begin() + dex_cache_section.End(), kPageSize);
1842 if (section_begin < section_end) {
1843 madvise(section_begin, section_end - section_begin, MADV_DONTNEED);
1844 mprotect(section_begin, section_end - section_begin, PROT_NONE);
1845 VLOG(image) << "Released and protected dex cache array image section from "
1846 << reinterpret_cast<const void*>(section_begin) << "-"
1847 << reinterpret_cast<const void*>(section_end);
1848 }
1849 }
Vladimir Marko1bc4b172016-10-24 16:53:39 +00001850 if (!oat_file->GetBssGcRoots().empty()) {
1851 // Insert oat file to class table for visiting .bss GC roots.
1852 class_table->InsertOatFile(oat_file);
1853 }
1854 } else {
1855 DCHECK(oat_file->GetBssGcRoots().empty());
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001856 }
Mathieu Chartier69731002016-03-02 16:08:31 -08001857 if (added_class_table) {
1858 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
1859 class_table->AddClassSet(std::move(temp_set));
1860 }
1861 if (kIsDebugBuild && app_image) {
1862 // This verification needs to happen after the classes have been added to the class loader.
1863 // Since it ensures classes are in the class table.
1864 VerifyClassInTableArtMethodVisitor visitor2(class_table);
Andreas Gampe542451c2016-07-26 09:02:02 -07001865 header.VisitPackedArtMethods(&visitor2, space->Begin(), kRuntimePointerSize);
Mathieu Chartier69731002016-03-02 16:08:31 -08001866 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001867 VLOG(class_linker) << "Adding image space took " << PrettyDuration(NanoTime() - start_time);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001868 return true;
Brian Carlstroma663ea52011-08-19 23:33:41 -07001869}
1870
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001871bool ClassLinker::ClassInClassTable(ObjPtr<mirror::Class> klass) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001872 ClassTable* const class_table = ClassTableForClassLoader(klass->GetClassLoader());
1873 return class_table != nullptr && class_table->Contains(klass);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001874}
1875
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001876void ClassLinker::VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) {
Mathieu Chartier7778b882015-10-05 16:41:10 -07001877 // Acquire tracing_enabled before locking class linker lock to prevent lock order violation. Since
1878 // enabling tracing requires the mutator lock, there are no race conditions here.
1879 const bool tracing_enabled = Trace::IsTracingEnabled();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001880 Thread* const self = Thread::Current();
1881 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001882 BufferedRootVisitor<kDefaultBufferedRootCount> buffered_visitor(
1883 visitor, RootInfo(kRootStickyClass));
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001884 if ((flags & kVisitRootFlagAllRoots) != 0) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001885 // Argument for how root visiting deals with ArtField and ArtMethod roots.
1886 // There is 3 GC cases to handle:
1887 // Non moving concurrent:
1888 // This case is easy to handle since the reference members of ArtMethod and ArtFields are held
Mathieu Chartierda7c6502015-07-23 16:01:26 -07001889 // live by the class and class roots.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001890 //
1891 // Moving non-concurrent:
1892 // This case needs to call visit VisitNativeRoots in case the classes or dex cache arrays move.
1893 // To prevent missing roots, this case needs to ensure that there is no
1894 // suspend points between the point which we allocate ArtMethod arrays and place them in a
1895 // class which is in the class table.
1896 //
1897 // Moving concurrent:
1898 // Need to make sure to not copy ArtMethods without doing read barriers since the roots are
1899 // marked concurrently and we don't hold the classlinker_classes_lock_ when we do the copy.
Mathieu Chartiere4275c02015-08-06 15:34:15 -07001900 boot_class_table_.VisitRoots(buffered_visitor);
Mathieu Chartier7778b882015-10-05 16:41:10 -07001901
1902 // If tracing is enabled, then mark all the class loaders to prevent unloading.
neo.chaea2d1b282016-11-08 08:40:46 +09001903 if ((flags & kVisitRootFlagClassLoader) != 0 || tracing_enabled) {
Mathieu Chartier7778b882015-10-05 16:41:10 -07001904 for (const ClassLoaderData& data : class_loaders_) {
1905 GcRoot<mirror::Object> root(GcRoot<mirror::Object>(self->DecodeJObject(data.weak_root)));
1906 root.VisitRoot(visitor, RootInfo(kRootVMInternal));
1907 }
1908 }
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001909 } else if ((flags & kVisitRootFlagNewRoots) != 0) {
Mathieu Chartierc2e20622014-11-03 11:41:47 -08001910 for (auto& root : new_class_roots_) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001911 ObjPtr<mirror::Class> old_ref = root.Read<kWithoutReadBarrier>();
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001912 root.VisitRoot(visitor, RootInfo(kRootStickyClass));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001913 ObjPtr<mirror::Class> new_ref = root.Read<kWithoutReadBarrier>();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001914 // Concurrent moving GC marked new roots through the to-space invariant.
1915 CHECK_EQ(new_ref, old_ref);
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001916 }
1917 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07001918 buffered_visitor.Flush(); // Flush before clearing new_class_roots_.
Mathieu Chartier52e4b432014-06-10 11:22:31 -07001919 if ((flags & kVisitRootFlagClearRootLog) != 0) {
1920 new_class_roots_.clear();
1921 }
1922 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) {
1923 log_new_class_table_roots_ = true;
1924 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) {
1925 log_new_class_table_roots_ = false;
1926 }
1927 // We deliberately ignore the class roots in the image since we
1928 // handle image roots by using the MS/CMS rescanning of dirty cards.
1929}
1930
Brian Carlstroma663ea52011-08-19 23:33:41 -07001931// Keep in sync with InitCallback. Anything we visit, we need to
1932// reinit references to when reinitializing a ClassLinker from a
1933// mapped image.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001934void ClassLinker::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) {
Mathieu Chartier31000802015-06-14 14:14:37 -07001935 class_roots_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001936 VisitClassRoots(visitor, flags);
Mathieu Chartier31000802015-06-14 14:14:37 -07001937 array_iftable_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartier6cfc2c02015-10-12 15:06:16 -07001938 // Instead of visiting the find_array_class_cache_ drop it so that it doesn't prevent class
1939 // unloading if we are marking roots.
1940 DropFindArrayClassCache();
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001941}
1942
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001943class VisitClassLoaderClassesVisitor : public ClassLoaderVisitor {
1944 public:
1945 explicit VisitClassLoaderClassesVisitor(ClassVisitor* visitor)
1946 : visitor_(visitor),
1947 done_(false) {}
1948
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001949 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001950 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001951 ClassTable* const class_table = class_loader->GetClassTable();
Vladimir Marko19886db2016-11-11 11:40:40 +00001952 if (!done_ && class_table != nullptr) {
1953 DefiningClassLoaderFilterVisitor visitor(class_loader, visitor_);
1954 if (!class_table->Visit(visitor)) {
1955 // If the visitor ClassTable returns false it means that we don't need to continue.
1956 done_ = true;
1957 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001958 }
1959 }
1960
1961 private:
Vladimir Marko19886db2016-11-11 11:40:40 +00001962 // Class visitor that limits the class visits from a ClassTable to the classes with
1963 // the provided defining class loader. This filter is used to avoid multiple visits
1964 // of the same class which can be recorded for multiple initiating class loaders.
1965 class DefiningClassLoaderFilterVisitor : public ClassVisitor {
1966 public:
1967 DefiningClassLoaderFilterVisitor(ObjPtr<mirror::ClassLoader> defining_class_loader,
1968 ClassVisitor* visitor)
1969 : defining_class_loader_(defining_class_loader), visitor_(visitor) { }
1970
1971 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
1972 if (klass->GetClassLoader() != defining_class_loader_) {
1973 return true;
1974 }
1975 return (*visitor_)(klass);
1976 }
1977
1978 ObjPtr<mirror::ClassLoader> const defining_class_loader_;
1979 ClassVisitor* const visitor_;
1980 };
1981
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001982 ClassVisitor* const visitor_;
1983 // If done is true then we don't need to do any more visiting.
1984 bool done_;
1985};
1986
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07001987void ClassLinker::VisitClassesInternal(ClassVisitor* visitor) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08001988 if (boot_class_table_.Visit(*visitor)) {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07001989 VisitClassLoaderClassesVisitor loader_visitor(visitor);
1990 VisitClassLoaders(&loader_visitor);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001991 }
1992}
1993
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07001994void ClassLinker::VisitClasses(ClassVisitor* visitor) {
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07001995 Thread* const self = Thread::Current();
1996 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
1997 // Not safe to have thread suspension when we are holding a lock.
1998 if (self != nullptr) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07001999 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002000 VisitClassesInternal(visitor);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07002001 } else {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002002 VisitClassesInternal(visitor);
Elliott Hughesa2155262011-11-16 16:26:58 -08002003 }
2004}
2005
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002006class GetClassesInToVector : public ClassVisitor {
2007 public:
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002008 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002009 classes_.push_back(klass);
2010 return true;
2011 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002012 std::vector<ObjPtr<mirror::Class>> classes_;
Ian Rogersdbf3be02014-08-29 15:40:08 -07002013};
2014
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002015class GetClassInToObjectArray : public ClassVisitor {
2016 public:
2017 explicit GetClassInToObjectArray(mirror::ObjectArray<mirror::Class>* arr)
2018 : arr_(arr), index_(0) {}
2019
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002020 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002021 ++index_;
2022 if (index_ <= arr_->GetLength()) {
2023 arr_->Set(index_ - 1, klass);
2024 return true;
2025 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002026 return false;
2027 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002028
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002029 bool Succeeded() const REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002030 return index_ <= arr_->GetLength();
2031 }
2032
2033 private:
2034 mirror::ObjectArray<mirror::Class>* const arr_;
2035 int32_t index_;
2036};
2037
2038void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002039 // TODO: it may be possible to avoid secondary storage if we iterate over dex caches. The problem
2040 // is avoiding duplicates.
2041 if (!kMovingClasses) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002042 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002043 GetClassesInToVector accumulator;
2044 VisitClasses(&accumulator);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002045 for (ObjPtr<mirror::Class> klass : accumulator.classes_) {
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002046 if (!visitor->operator()(klass)) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002047 return;
2048 }
2049 }
2050 } else {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002051 Thread* const self = Thread::Current();
Ian Rogersdbf3be02014-08-29 15:40:08 -07002052 StackHandleScope<1> hs(self);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002053 auto classes = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Ian Rogersdbf3be02014-08-29 15:40:08 -07002054 // We size the array assuming classes won't be added to the class table during the visit.
2055 // If this assumption fails we iterate again.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002056 while (true) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002057 size_t class_table_size;
2058 {
Ian Rogers7b078e82014-09-10 14:44:24 -07002059 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002060 // Add 100 in case new classes get loaded when we are filling in the object array.
2061 class_table_size = NumZygoteClasses() + NumNonZygoteClasses() + 100;
Ian Rogersdbf3be02014-08-29 15:40:08 -07002062 }
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07002063 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002064 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
Ian Rogersdbf3be02014-08-29 15:40:08 -07002065 classes.Assign(
2066 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size));
2067 CHECK(classes.Get() != nullptr); // OOME.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07002068 GetClassInToObjectArray accumulator(classes.Get());
2069 VisitClasses(&accumulator);
2070 if (accumulator.Succeeded()) {
2071 break;
2072 }
Ian Rogersdbf3be02014-08-29 15:40:08 -07002073 }
2074 for (int32_t i = 0; i < classes->GetLength(); ++i) {
2075 // If the class table shrank during creation of the clases array we expect null elements. If
2076 // the class table grew then the loop repeats. If classes are created after the loop has
2077 // finished then we don't visit.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002078 ObjPtr<mirror::Class> klass = classes->Get(i);
Mathieu Chartier1aa8ec22016-02-01 10:34:47 -08002079 if (klass != nullptr && !visitor->operator()(klass)) {
Ian Rogersdbf3be02014-08-29 15:40:08 -07002080 return;
2081 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002082 }
2083 }
2084}
2085
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002086ClassLinker::~ClassLinker() {
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002087 mirror::Class::ResetClass();
2088 mirror::Constructor::ResetClass();
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07002089 mirror::Field::ResetClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002090 mirror::Method::ResetClass();
2091 mirror::Reference::ResetClass();
2092 mirror::StackTraceElement::ResetClass();
2093 mirror::String::ResetClass();
2094 mirror::Throwable::ResetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002095 mirror::BooleanArray::ResetArrayClass();
2096 mirror::ByteArray::ResetArrayClass();
2097 mirror::CharArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002098 mirror::Constructor::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002099 mirror::DoubleArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002100 mirror::Field::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002101 mirror::FloatArray::ResetArrayClass();
Mathieu Chartierfc58af42015-04-16 18:00:39 -07002102 mirror::Method::ResetArrayClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002103 mirror::IntArray::ResetArrayClass();
2104 mirror::LongArray::ResetArrayClass();
2105 mirror::ShortArray::ResetArrayClass();
Narayan Kamathafa48272016-08-03 12:46:58 +01002106 mirror::MethodType::ResetClass();
2107 mirror::MethodHandleImpl::ResetClass();
Narayan Kamath000e1882016-10-24 17:14:25 +01002108 mirror::EmulatedStackFrame::ResetClass();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002109 Thread* const self = Thread::Current();
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002110 for (const ClassLoaderData& data : class_loaders_) {
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002111 DeleteClassLoader(self, data);
Mathieu Chartier6b069532015-08-05 15:08:12 -07002112 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07002113 class_loaders_.clear();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07002114}
2115
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002116void ClassLinker::DeleteClassLoader(Thread* self, const ClassLoaderData& data) {
2117 Runtime* const runtime = Runtime::Current();
2118 JavaVMExt* const vm = runtime->GetJavaVM();
2119 vm->DeleteWeakGlobalRef(self, data.weak_root);
Calin Juravlee5de54c2016-04-20 14:22:09 +01002120 // Notify the JIT that we need to remove the methods and/or profiling info.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +01002121 if (runtime->GetJit() != nullptr) {
2122 jit::JitCodeCache* code_cache = runtime->GetJit()->GetCodeCache();
2123 if (code_cache != nullptr) {
2124 code_cache->RemoveMethodsIn(self, *data.allocator);
2125 }
2126 }
2127 delete data.allocator;
2128 delete data.class_table;
2129}
2130
Mathieu Chartiere401d142015-04-22 13:56:20 -07002131mirror::PointerArray* ClassLinker::AllocPointerArray(Thread* self, size_t length) {
Andreas Gampe542451c2016-07-26 09:02:02 -07002132 return down_cast<mirror::PointerArray*>(
2133 image_pointer_size_ == PointerSize::k64
2134 ? static_cast<mirror::Array*>(mirror::LongArray::Alloc(self, length))
2135 : static_cast<mirror::Array*>(mirror::IntArray::Alloc(self, length)));
Mathieu Chartiere401d142015-04-22 13:56:20 -07002136}
2137
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002138void ClassLinker::InitializeDexCache(Thread* self,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002139 ObjPtr<mirror::DexCache> dex_cache,
2140 ObjPtr<mirror::String> location,
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002141 const DexFile& dex_file,
2142 LinearAlloc* linear_alloc) {
2143 ScopedAssertNoThreadSuspension sants(__FUNCTION__);
Vladimir Marko05792b92015-08-03 11:56:49 +01002144 DexCacheArraysLayout layout(image_pointer_size_, &dex_file);
2145 uint8_t* raw_arrays = nullptr;
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002146
2147 const OatDexFile* const oat_dex = dex_file.GetOatDexFile();
2148 if (oat_dex != nullptr && oat_dex->GetDexCacheArrays() != nullptr) {
2149 raw_arrays = oat_dex->GetDexCacheArrays();
2150 } else if (dex_file.NumStringIds() != 0u ||
2151 dex_file.NumTypeIds() != 0u ||
2152 dex_file.NumMethodIds() != 0u ||
2153 dex_file.NumFieldIds() != 0u) {
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07002154 // Zero-initialized.
2155 raw_arrays = reinterpret_cast<uint8_t*>(linear_alloc->Alloc(self, layout.Size()));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07002156 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01002157
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002158 mirror::StringDexCacheType* strings = (dex_file.NumStringIds() == 0u) ? nullptr :
2159 reinterpret_cast<mirror::StringDexCacheType*>(raw_arrays + layout.StringsOffset());
Vladimir Marko05792b92015-08-03 11:56:49 +01002160 GcRoot<mirror::Class>* types = (dex_file.NumTypeIds() == 0u) ? nullptr :
2161 reinterpret_cast<GcRoot<mirror::Class>*>(raw_arrays + layout.TypesOffset());
2162 ArtMethod** methods = (dex_file.NumMethodIds() == 0u) ? nullptr :
2163 reinterpret_cast<ArtMethod**>(raw_arrays + layout.MethodsOffset());
2164 ArtField** fields = (dex_file.NumFieldIds() == 0u) ? nullptr :
2165 reinterpret_cast<ArtField**>(raw_arrays + layout.FieldsOffset());
Narayan Kamath25352fc2016-08-03 12:46:58 +01002166
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002167 size_t num_strings = mirror::DexCache::kDexCacheStringCacheSize;
2168 if (dex_file.NumStringIds() < num_strings) {
2169 num_strings = dex_file.NumStringIds();
2170 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01002171
2172 // Note that we allocate the method type dex caches regardless of this flag,
2173 // and we make sure here that they're not used by the runtime. This is in the
2174 // interest of simplicity and to avoid extensive compiler and layout class changes.
2175 //
2176 // If this needs to be mitigated in a production system running this code,
2177 // DexCache::kDexCacheMethodTypeCacheSize can be set to zero.
Narayan Kamath25352fc2016-08-03 12:46:58 +01002178 mirror::MethodTypeDexCacheType* method_types = nullptr;
2179 size_t num_method_types = 0;
2180
Narayan Kamath269cb432016-10-28 10:19:54 +01002181 if (dex_file.NumProtoIds() < mirror::DexCache::kDexCacheMethodTypeCacheSize) {
2182 num_method_types = dex_file.NumProtoIds();
2183 } else {
2184 num_method_types = mirror::DexCache::kDexCacheMethodTypeCacheSize;
2185 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01002186
Narayan Kamath269cb432016-10-28 10:19:54 +01002187 if (num_method_types > 0) {
2188 method_types = reinterpret_cast<mirror::MethodTypeDexCacheType*>(
2189 raw_arrays + layout.MethodTypesOffset());
Narayan Kamath25352fc2016-08-03 12:46:58 +01002190 }
2191
Christina Wadsworth6353a632016-08-19 15:58:05 -07002192 DCHECK_ALIGNED(raw_arrays, alignof(mirror::StringDexCacheType)) <<
2193 "Expected raw_arrays to align to StringDexCacheType.";
2194 DCHECK_ALIGNED(layout.StringsOffset(), alignof(mirror::StringDexCacheType)) <<
2195 "Expected StringsOffset() to align to StringDexCacheType.";
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002196 DCHECK_ALIGNED(strings, alignof(mirror::StringDexCacheType)) <<
Christina Wadsworth6353a632016-08-19 15:58:05 -07002197 "Expected strings to align to StringDexCacheType.";
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002198 static_assert(alignof(mirror::StringDexCacheType) == 8u,
2199 "Expected StringDexCacheType to have align of 8.");
Mathieu Chartier05005f72016-06-06 13:10:50 -07002200 if (kIsDebugBuild) {
Mathieu Chartierc7d3f4b2016-06-01 10:48:19 -07002201 // Sanity check to make sure all the dex cache arrays are empty. b/28992179
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002202 for (size_t i = 0; i < num_strings; ++i) {
Narayan Kamathc38a6f82016-09-29 17:07:20 +01002203 CHECK_EQ(strings[i].load(std::memory_order_relaxed).index, 0u);
2204 CHECK(strings[i].load(std::memory_order_relaxed).object.IsNull());
Mathieu Chartierc7d3f4b2016-06-01 10:48:19 -07002205 }
2206 for (size_t i = 0; i < dex_file.NumTypeIds(); ++i) {
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002207 CHECK(types[i].IsNull());
Mathieu Chartierc7d3f4b2016-06-01 10:48:19 -07002208 }
2209 for (size_t i = 0; i < dex_file.NumMethodIds(); ++i) {
2210 CHECK(mirror::DexCache::GetElementPtrSize(methods, i, image_pointer_size_) == nullptr);
2211 }
2212 for (size_t i = 0; i < dex_file.NumFieldIds(); ++i) {
2213 CHECK(mirror::DexCache::GetElementPtrSize(fields, i, image_pointer_size_) == nullptr);
2214 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01002215 for (size_t i = 0; i < num_method_types; ++i) {
2216 CHECK_EQ(method_types[i].load(std::memory_order_relaxed).index, 0u);
2217 CHECK(method_types[i].load(std::memory_order_relaxed).object.IsNull());
2218 }
Mathieu Chartierc7d3f4b2016-06-01 10:48:19 -07002219 }
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002220 if (strings != nullptr) {
2221 mirror::StringDexCachePair::Initialize(strings);
2222 }
Narayan Kamath25352fc2016-08-03 12:46:58 +01002223 if (method_types != nullptr) {
2224 mirror::MethodTypeDexCachePair::Initialize(method_types);
2225 }
Vladimir Marko05792b92015-08-03 11:56:49 +01002226 dex_cache->Init(&dex_file,
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002227 location,
Vladimir Marko05792b92015-08-03 11:56:49 +01002228 strings,
Christina Wadsworthbf44e0e2016-08-18 10:37:42 -07002229 num_strings,
Vladimir Marko05792b92015-08-03 11:56:49 +01002230 types,
2231 dex_file.NumTypeIds(),
2232 methods,
2233 dex_file.NumMethodIds(),
2234 fields,
2235 dex_file.NumFieldIds(),
Narayan Kamath25352fc2016-08-03 12:46:58 +01002236 method_types,
2237 num_method_types,
Vladimir Marko05792b92015-08-03 11:56:49 +01002238 image_pointer_size_);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002239}
2240
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002241mirror::DexCache* ClassLinker::AllocDexCache(ObjPtr<mirror::String>* out_location,
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002242 Thread* self,
2243 const DexFile& dex_file) {
2244 StackHandleScope<1> hs(self);
2245 DCHECK(out_location != nullptr);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07002246 auto dex_cache(hs.NewHandle(ObjPtr<mirror::DexCache>::DownCast(
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002247 GetClassRoot(kJavaLangDexCache)->AllocObject(self))));
2248 if (dex_cache.Get() == nullptr) {
2249 self->AssertPendingOOMException();
2250 return nullptr;
2251 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002252 ObjPtr<mirror::String> location = intern_table_->InternStrong(dex_file.GetLocation().c_str());
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002253 if (location == nullptr) {
2254 self->AssertPendingOOMException();
2255 return nullptr;
2256 }
2257 *out_location = location;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002258 return dex_cache.Get();
Brian Carlstroma0808032011-07-18 00:39:23 -07002259}
2260
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002261mirror::DexCache* ClassLinker::AllocAndInitializeDexCache(Thread* self,
2262 const DexFile& dex_file,
2263 LinearAlloc* linear_alloc) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002264 ObjPtr<mirror::String> location = nullptr;
2265 ObjPtr<mirror::DexCache> dex_cache = AllocDexCache(&location, self, dex_file);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002266 if (dex_cache != nullptr) {
2267 WriterMutexLock mu(self, dex_lock_);
2268 DCHECK(location != nullptr);
2269 InitializeDexCache(self, dex_cache, location, dex_file, linear_alloc);
2270 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002271 return dex_cache.Ptr();
Mathieu Chartier6c60d842016-09-15 10:24:43 -07002272}
2273
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002274mirror::Class* ClassLinker::AllocClass(Thread* self,
2275 ObjPtr<mirror::Class> java_lang_Class,
Ian Rogers6fac4472014-02-25 17:01:10 -08002276 uint32_t class_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002277 DCHECK_GE(class_size, sizeof(mirror::Class));
Ian Rogers1d54e732013-05-02 21:10:01 -07002278 gc::Heap* heap = Runtime::Current()->GetHeap();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002279 mirror::Class::InitializeClassVisitor visitor(class_size);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002280 ObjPtr<mirror::Object> k = kMovingClasses ?
Brian Carlstromf3632832014-05-20 15:36:53 -07002281 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) :
2282 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
Ian Rogers6fac4472014-02-25 17:01:10 -08002283 if (UNLIKELY(k == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002284 self->AssertPendingOOMException();
Ian Rogers6fac4472014-02-25 17:01:10 -08002285 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002286 }
Ian Rogers6fac4472014-02-25 17:01:10 -08002287 return k->AsClass();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07002288}
2289
Ian Rogers6fac4472014-02-25 17:01:10 -08002290mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
Ian Rogers50b35e22012-10-04 10:09:15 -07002291 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
Brian Carlstroma0808032011-07-18 00:39:23 -07002292}
2293
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002294mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002295 Thread* self,
2296 size_t length) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002297 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(
2298 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
Shih-wei Liao55df06b2011-08-26 14:39:27 -07002299}
2300
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002301mirror::Class* ClassLinker::EnsureResolved(Thread* self,
2302 const char* descriptor,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002303 ObjPtr<mirror::Class> klass) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002304 DCHECK(klass != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002305 if (kIsDebugBuild) {
2306 StackHandleScope<1> hs(self);
2307 HandleWrapperObjPtr<mirror::Class> h = hs.NewHandleWrapper(&klass);
2308 Thread::PoisonObjectPointersIfDebug();
2309 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002310
2311 // For temporary classes we must wait for them to be retired.
2312 if (init_done_ && klass->IsTemp()) {
2313 CHECK(!klass->IsResolved());
2314 if (klass->IsErroneous()) {
2315 ThrowEarlierClassFailure(klass);
2316 return nullptr;
2317 }
2318 StackHandleScope<1> hs(self);
2319 Handle<mirror::Class> h_class(hs.NewHandle(klass));
2320 ObjectLock<mirror::Class> lock(self, h_class);
2321 // Loop and wait for the resolving thread to retire this class.
2322 while (!h_class->IsRetired() && !h_class->IsErroneous()) {
2323 lock.WaitIgnoringInterrupts();
2324 }
2325 if (h_class->IsErroneous()) {
2326 ThrowEarlierClassFailure(h_class.Get());
2327 return nullptr;
2328 }
2329 CHECK(h_class->IsRetired());
2330 // Get the updated class from class table.
Andreas Gampe34ee6842014-12-02 15:43:52 -08002331 klass = LookupClass(self, descriptor, h_class.Get()->GetClassLoader());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002332 }
2333
Brian Carlstromaded5f72011-10-07 17:15:04 -07002334 // Wait for the class if it has not already been linked.
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002335 size_t index = 0;
2336 // Maximum number of yield iterations until we start sleeping.
2337 static const size_t kNumYieldIterations = 1000;
2338 // How long each sleep is in us.
2339 static const size_t kSleepDurationUS = 1000; // 1 ms.
2340 while (!klass->IsResolved() && !klass->IsErroneous()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002341 StackHandleScope<1> hs(self);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002342 HandleWrapperObjPtr<mirror::Class> h_class(hs.NewHandleWrapper(&klass));
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002343 {
2344 ObjectTryLock<mirror::Class> lock(self, h_class);
2345 // Can not use a monitor wait here since it may block when returning and deadlock if another
2346 // thread has locked klass.
2347 if (lock.Acquired()) {
2348 // Check for circular dependencies between classes, the lock is required for SetStatus.
2349 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) {
2350 ThrowClassCircularityError(h_class.Get());
2351 mirror::Class::SetStatus(h_class, mirror::Class::kStatusError, self);
2352 return nullptr;
2353 }
2354 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002355 }
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002356 {
2357 // Handle wrapper deals with klass moving.
2358 ScopedThreadSuspension sts(self, kSuspended);
2359 if (index < kNumYieldIterations) {
2360 sched_yield();
2361 } else {
2362 usleep(kSleepDurationUS);
2363 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002364 }
Mathieu Chartier4b0ef1c2016-07-29 16:26:01 -07002365 ++index;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002366 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002367
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002368 if (klass->IsErroneous()) {
Elliott Hughes4a2b4172011-09-20 17:08:25 -07002369 ThrowEarlierClassFailure(klass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08002370 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002371 }
2372 // Return the loaded class. No exceptions should be pending.
David Sehr709b0702016-10-13 09:12:37 -07002373 CHECK(klass->IsResolved()) << klass->PrettyClass();
Ian Rogers62d6c772013-02-27 08:32:07 -08002374 self->AssertNoPendingException();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002375 return klass.Ptr();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002376}
2377
Ian Rogers68b56852014-08-29 20:19:11 -07002378typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry;
2379
2380// Search a collection of DexFiles for a descriptor
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002381ClassPathEntry FindInClassPath(const char* descriptor,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002382 size_t hash, const std::vector<const DexFile*>& class_path) {
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002383 for (const DexFile* dex_file : class_path) {
David Sehr9aa352e2016-09-15 18:13:52 -07002384 const DexFile::ClassDef* dex_class_def = OatDexFile::FindClassDef(*dex_file, descriptor, hash);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002385 if (dex_class_def != nullptr) {
Ian Rogers68b56852014-08-29 20:19:11 -07002386 return ClassPathEntry(dex_file, dex_class_def);
2387 }
2388 }
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002389 return ClassPathEntry(nullptr, nullptr);
Ian Rogers68b56852014-08-29 20:19:11 -07002390}
2391
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002392bool ClassLinker::FindClassInBaseDexClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
2393 Thread* self,
2394 const char* descriptor,
2395 size_t hash,
2396 Handle<mirror::ClassLoader> class_loader,
2397 ObjPtr<mirror::Class>* result) {
Andreas Gampef865ea92015-04-13 22:14:19 -07002398 // Termination case: boot class-loader.
2399 if (IsBootClassLoader(soa, class_loader.Get())) {
2400 // The boot class loader, search the boot class path.
2401 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_);
2402 if (pair.second != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002403 ObjPtr<mirror::Class> klass = LookupClass(self, descriptor, hash, nullptr);
Andreas Gampef865ea92015-04-13 22:14:19 -07002404 if (klass != nullptr) {
2405 *result = EnsureResolved(self, descriptor, klass);
2406 } else {
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002407 *result = DefineClass(self,
2408 descriptor,
2409 hash,
2410 ScopedNullHandle<mirror::ClassLoader>(),
2411 *pair.first,
2412 *pair.second);
Andreas Gampef865ea92015-04-13 22:14:19 -07002413 }
2414 if (*result == nullptr) {
2415 CHECK(self->IsExceptionPending()) << descriptor;
2416 self->ClearException();
2417 }
Ian Rogers32427292014-11-19 14:05:21 -08002418 } else {
Andreas Gampef865ea92015-04-13 22:14:19 -07002419 *result = nullptr;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002420 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002421 return true;
2422 }
2423
2424 // Unsupported class-loader?
Mathieu Chartier0795f232016-09-27 18:43:30 -07002425 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader) !=
2426 class_loader->GetClass()) {
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002427 // PathClassLoader is the most common case, so it's the one we check first. For secondary dex
2428 // files, we also check DexClassLoader here.
2429 if (soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DexClassLoader) !=
2430 class_loader->GetClass()) {
2431 *result = nullptr;
2432 return false;
2433 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002434 }
2435
2436 // Handles as RegisterDexFile may allocate dex caches (and cause thread suspension).
2437 StackHandleScope<4> hs(self);
2438 Handle<mirror::ClassLoader> h_parent(hs.NewHandle(class_loader->GetParent()));
Nicolas Geoffray7d8d8ff2016-11-02 12:38:05 +00002439 bool recursive_result = FindClassInBaseDexClassLoader(soa,
2440 self,
2441 descriptor,
2442 hash,
2443 h_parent,
2444 result);
Andreas Gampef865ea92015-04-13 22:14:19 -07002445
2446 if (!recursive_result) {
2447 // Something wrong up the chain.
2448 return false;
2449 }
2450
2451 if (*result != nullptr) {
2452 // Found the class up the chain.
2453 return true;
2454 }
2455
2456 // Handle this step.
2457 // Handle as if this is the child PathClassLoader.
2458 // The class loader is a PathClassLoader which inherits from BaseDexClassLoader.
2459 // We need to get the DexPathList and loop through it.
Andreas Gampe08883de2016-11-08 13:20:52 -08002460 ArtField* const cookie_field =
2461 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
Andreas Gampef865ea92015-04-13 22:14:19 -07002462 ArtField* const dex_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08002463 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002464 ObjPtr<mirror::Object> dex_path_list =
Andreas Gampe08883de2016-11-08 13:20:52 -08002465 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList)->
2466 GetObject(class_loader.Get());
Andreas Gampef865ea92015-04-13 22:14:19 -07002467 if (dex_path_list != nullptr && dex_file_field != nullptr && cookie_field != nullptr) {
2468 // DexPathList has an array dexElements of Elements[] which each contain a dex file.
Mathieu Chartier3398c782016-09-30 10:27:43 -07002469 ObjPtr<mirror::Object> dex_elements_obj =
Andreas Gampe08883de2016-11-08 13:20:52 -08002470 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements)->
Andreas Gampef865ea92015-04-13 22:14:19 -07002471 GetObject(dex_path_list);
2472 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look
2473 // at the mCookie which is a DexFile vector.
2474 if (dex_elements_obj != nullptr) {
2475 Handle<mirror::ObjectArray<mirror::Object>> dex_elements =
2476 hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>());
2477 for (int32_t i = 0; i < dex_elements->GetLength(); ++i) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07002478 ObjPtr<mirror::Object> element = dex_elements->GetWithoutChecks(i);
Andreas Gampef865ea92015-04-13 22:14:19 -07002479 if (element == nullptr) {
2480 // Should never happen, fall back to java code to throw a NPE.
2481 break;
2482 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07002483 ObjPtr<mirror::Object> dex_file = dex_file_field->GetObject(element);
Andreas Gampef865ea92015-04-13 22:14:19 -07002484 if (dex_file != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07002485 ObjPtr<mirror::LongArray> long_array = cookie_field->GetObject(dex_file)->AsLongArray();
Andreas Gampef865ea92015-04-13 22:14:19 -07002486 if (long_array == nullptr) {
2487 // This should never happen so log a warning.
2488 LOG(WARNING) << "Null DexFile::mCookie for " << descriptor;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002489 break;
2490 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002491 int32_t long_array_size = long_array->GetLength();
Mathieu Chartiere58991b2015-10-13 07:59:34 -07002492 // First element is the oat file.
2493 for (int32_t j = kDexFileIndexStart; j < long_array_size; ++j) {
Andreas Gampef865ea92015-04-13 22:14:19 -07002494 const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(
2495 long_array->GetWithoutChecks(j)));
David Sehr9aa352e2016-09-15 18:13:52 -07002496 const DexFile::ClassDef* dex_class_def =
2497 OatDexFile::FindClassDef(*cp_dex_file, descriptor, hash);
Andreas Gampef865ea92015-04-13 22:14:19 -07002498 if (dex_class_def != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002499 ObjPtr<mirror::Class> klass = DefineClass(self,
Mathieu Chartiere58991b2015-10-13 07:59:34 -07002500 descriptor,
2501 hash,
2502 class_loader,
2503 *cp_dex_file,
2504 *dex_class_def);
Andreas Gampef865ea92015-04-13 22:14:19 -07002505 if (klass == nullptr) {
2506 CHECK(self->IsExceptionPending()) << descriptor;
2507 self->ClearException();
2508 // TODO: Is it really right to break here, and not check the other dex files?
2509 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002510 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002511 *result = klass;
2512 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002513 }
2514 }
2515 }
2516 }
2517 }
Ian Rogers32427292014-11-19 14:05:21 -08002518 self->AssertNoPendingException();
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002519 }
Andreas Gampef865ea92015-04-13 22:14:19 -07002520
2521 // Result is still null from the parent call, no need to set it again...
2522 return true;
Mathieu Chartierab0ed822014-09-11 14:21:41 -07002523}
2524
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002525mirror::Class* ClassLinker::FindClass(Thread* self,
2526 const char* descriptor,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07002527 Handle<mirror::ClassLoader> class_loader) {
Elliott Hughesba8eee12012-01-24 20:25:24 -08002528 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Ian Rogers98379392014-02-24 16:53:16 -08002529 DCHECK(self != nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002530 self->AssertNoPendingException();
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07002531 self->PoisonObjectPointers(); // For DefineClass, CreateArrayClass, etc...
Elliott Hughesc3b77c72011-12-15 20:56:48 -08002532 if (descriptor[1] == '\0') {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08002533 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
2534 // for primitive classes that aren't backed by dex files.
2535 return FindPrimitiveClass(descriptor[0]);
2536 }
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002537 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002538 // Find the class in the loaded classes table.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002539 ObjPtr<mirror::Class> klass = LookupClass(self, descriptor, hash, class_loader.Get());
Ian Rogers68b56852014-08-29 20:19:11 -07002540 if (klass != nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002541 return EnsureResolved(self, descriptor, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002542 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07002543 // Class is not yet loaded.
2544 if (descriptor[0] == '[') {
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002545 return CreateArrayClass(self, descriptor, hash, class_loader);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002546 } else if (class_loader.Get() == nullptr) {
Ian Rogers63557452014-06-04 16:57:15 -07002547 // The boot class loader, search the boot class path.
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002548 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_);
Ian Rogers68b56852014-08-29 20:19:11 -07002549 if (pair.second != nullptr) {
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002550 return DefineClass(self,
2551 descriptor,
2552 hash,
2553 ScopedNullHandle<mirror::ClassLoader>(),
2554 *pair.first,
Ian Rogers7b078e82014-09-10 14:44:24 -07002555 *pair.second);
Ian Rogers63557452014-06-04 16:57:15 -07002556 } else {
2557 // The boot class loader is searched ahead of the application class loader, failures are
2558 // expected and will be wrapped in a ClassNotFoundException. Use the pre-allocated error to
2559 // trigger the chaining with a proper stack trace.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002560 ObjPtr<mirror::Throwable> pre_allocated = Runtime::Current()->GetPreAllocatedNoClassDefFoundError();
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002561 self->SetException(pre_allocated);
Ian Rogers63557452014-06-04 16:57:15 -07002562 return nullptr;
Jesse Wilson47daf872011-11-23 11:42:45 -05002563 }
Jesse Wilson47daf872011-11-23 11:42:45 -05002564 } else {
Ian Rogers98379392014-02-24 16:53:16 -08002565 ScopedObjectAccessUnchecked soa(self);
Vladimir Marko19886db2016-11-11 11:40:40 +00002566 ObjPtr<mirror::Class> result_ptr;
2567 bool descriptor_equals;
2568 bool known_hierarchy =
2569 FindClassInBaseDexClassLoader(soa, self, descriptor, hash, class_loader, &result_ptr);
2570 if (result_ptr != nullptr) {
2571 // The chain was understood and we found the class. We still need to add the class to
2572 // the class table to protect from racy programs that can try and redefine the path list
2573 // which would change the Class<?> returned for subsequent evaluation of const-class.
2574 DCHECK(known_hierarchy);
2575 DCHECK(result_ptr->DescriptorEquals(descriptor));
2576 descriptor_equals = true;
2577 } else {
2578 // Either the chain wasn't understood or the class wasn't found.
2579 //
2580 // If the chain was understood and but we did not find the class, let the Java-side
2581 // rediscover all this and throw the exception with the right stack trace. Note that
2582 // the Java-side could still succeed for racy programs if another thread is actively
2583 // modifying the class loader's path list.
Andreas Gampef865ea92015-04-13 22:14:19 -07002584
Vladimir Marko19886db2016-11-11 11:40:40 +00002585 if (Runtime::Current()->IsAotCompiler()) {
2586 // Oops, compile-time, can't run actual class-loader code.
2587 ObjPtr<mirror::Throwable> pre_allocated =
2588 Runtime::Current()->GetPreAllocatedNoClassDefFoundError();
2589 self->SetException(pre_allocated);
Ian Rogers68b56852014-08-29 20:19:11 -07002590 return nullptr;
Ian Rogers365c1022012-06-22 15:05:28 -07002591 }
Vladimir Marko19886db2016-11-11 11:40:40 +00002592
2593 ScopedLocalRef<jobject> class_loader_object(
2594 soa.Env(), soa.AddLocalReference<jobject>(class_loader.Get()));
2595 std::string class_name_string(DescriptorToDot(descriptor));
2596 ScopedLocalRef<jobject> result(soa.Env(), nullptr);
2597 {
2598 ScopedThreadStateChange tsc(self, kNative);
2599 ScopedLocalRef<jobject> class_name_object(
2600 soa.Env(), soa.Env()->NewStringUTF(class_name_string.c_str()));
2601 if (class_name_object.get() == nullptr) {
2602 DCHECK(self->IsExceptionPending()); // OOME.
2603 return nullptr;
2604 }
2605 CHECK(class_loader_object.get() != nullptr);
2606 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
2607 WellKnownClasses::java_lang_ClassLoader_loadClass,
2608 class_name_object.get()));
2609 }
2610 if (self->IsExceptionPending()) {
2611 // If the ClassLoader threw, pass that exception up.
2612 // However, to comply with the RI behavior, first check if another thread succeeded.
2613 result_ptr = LookupClass(self, descriptor, hash, class_loader.Get());
2614 if (result_ptr != nullptr && result_ptr->IsResolved()) {
2615 self->ClearException();
2616 return result_ptr.Ptr();
2617 }
2618 return nullptr;
2619 } else if (result.get() == nullptr) {
2620 // broken loader - throw NPE to be compatible with Dalvik
2621 ThrowNullPointerException(StringPrintf("ClassLoader.loadClass returned null for %s",
2622 class_name_string.c_str()).c_str());
2623 return nullptr;
2624 }
2625 result_ptr = soa.Decode<mirror::Class>(result.get());
2626 // Check the name of the returned class.
2627 descriptor_equals = result_ptr->DescriptorEquals(descriptor);
Jesse Wilson47daf872011-11-23 11:42:45 -05002628 }
Vladimir Marko19886db2016-11-11 11:40:40 +00002629
2630 // Try to insert the class to the class table, checking for mismatch.
2631 ObjPtr<mirror::Class> old;
2632 {
2633 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
2634 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader.Get());
2635 old = class_table->Lookup(descriptor, hash);
2636 if (old == nullptr) {
2637 old = result_ptr; // For the comparison below, after releasing the lock.
2638 if (descriptor_equals) {
2639 class_table->InsertWithHash(result_ptr.Ptr(), hash);
2640 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get());
2641 } // else throw below, after releasing the lock.
2642 }
Ian Rogers6b0870d2011-12-15 19:38:12 -08002643 }
Vladimir Marko19886db2016-11-11 11:40:40 +00002644 if (UNLIKELY(old != result_ptr)) {
2645 // Return `old` (even if `!descriptor_equals`) to mimic the RI behavior for parallel
2646 // capable class loaders. (All class loaders are considered parallel capable on Android.)
2647 mirror::Class* loader_class = class_loader->GetClass();
2648 const char* loader_class_name =
2649 loader_class->GetDexFile().StringByTypeIdx(loader_class->GetDexTypeIndex());
2650 LOG(WARNING) << "Initiating class loader of type " << DescriptorToDot(loader_class_name)
2651 << " is not well-behaved; it a returned different Class for racing loadClass(\""
2652 << DescriptorToDot(descriptor) << "\").";
2653 return old.Ptr();
2654 }
2655 if (UNLIKELY(!descriptor_equals)) {
2656 std::string result_storage;
2657 const char* result_name = result_ptr->GetDescriptor(&result_storage);
2658 std::string loader_storage;
2659 const char* loader_class_name = class_loader->GetClass()->GetDescriptor(&loader_storage);
2660 ThrowNoClassDefFoundError(
2661 "Initiating class loader of type %s returned class %s instead of %s.",
2662 DescriptorToDot(loader_class_name).c_str(),
2663 DescriptorToDot(result_name).c_str(),
2664 DescriptorToDot(descriptor).c_str());
2665 return nullptr;
2666 }
2667 // success, return mirror::Class*
2668 return result_ptr.Ptr();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002669 }
Ian Rogers07140832014-09-30 15:43:59 -07002670 UNREACHABLE();
Brian Carlstromaded5f72011-10-07 17:15:04 -07002671}
2672
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002673mirror::Class* ClassLinker::DefineClass(Thread* self,
2674 const char* descriptor,
2675 size_t hash,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07002676 Handle<mirror::ClassLoader> class_loader,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002677 const DexFile& dex_file,
2678 const DexFile::ClassDef& dex_class_def) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002679 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002680 auto klass = hs.NewHandle<mirror::Class>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002681
Brian Carlstromaded5f72011-10-07 17:15:04 -07002682 // Load the class from the dex file.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002683 if (UNLIKELY(!init_done_)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002684 // finish up init of hand crafted class_roots_
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002685 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002686 klass.Assign(GetClassRoot(kJavaLangObject));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002687 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002688 klass.Assign(GetClassRoot(kJavaLangClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002689 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002690 klass.Assign(GetClassRoot(kJavaLangString));
Fred Shih4ee7a662014-07-11 09:59:27 -07002691 } else if (strcmp(descriptor, "Ljava/lang/ref/Reference;") == 0) {
2692 klass.Assign(GetClassRoot(kJavaLangRefReference));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07002693 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002694 klass.Assign(GetClassRoot(kJavaLangDexCache));
Alex Lightd6251582016-10-31 11:12:30 -07002695 } else if (strcmp(descriptor, "Ldalvik/system/ClassExt;") == 0) {
2696 klass.Assign(GetClassRoot(kDalvikSystemClassExt));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002697 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002698 }
2699
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08002700 if (klass.Get() == nullptr) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002701 // Allocate a class with the status of not ready.
2702 // Interface object should get the right size here. Regular class will
2703 // figure out the right size later and be replaced with one of the right
2704 // size when the class becomes resolved.
2705 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def)));
Brian Carlstromaded5f72011-10-07 17:15:04 -07002706 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002707 if (UNLIKELY(klass.Get() == nullptr)) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002708 self->AssertPendingOOMException();
Ian Rogersc114b5f2014-07-21 08:55:01 -07002709 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07002710 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002711 ObjPtr<mirror::DexCache> dex_cache = RegisterDexFile(dex_file, class_loader.Get());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07002712 if (dex_cache == nullptr) {
2713 self->AssertPendingOOMException();
2714 return nullptr;
2715 }
2716 klass->SetDexCache(dex_cache);
Mathieu Chartierc7853442015-03-27 14:35:38 -07002717 SetupClass(dex_file, dex_class_def, klass, class_loader.Get());
2718
Jeff Hao848f70a2014-01-15 13:49:50 -08002719 // Mark the string class by setting its access flag.
2720 if (UNLIKELY(!init_done_)) {
2721 if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
2722 klass->SetStringClass();
2723 }
2724 }
2725
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07002726 ObjectLock<mirror::Class> lock(self, klass);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002727 klass->SetClinitThreadId(self->GetTid());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002728
Mathieu Chartier590fee92013-09-13 13:46:47 -07002729 // Add the newly loaded class to the loaded classes table.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002730 ObjPtr<mirror::Class> existing = InsertClass(descriptor, klass.Get(), hash);
Ian Rogersc114b5f2014-07-21 08:55:01 -07002731 if (existing != nullptr) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07002732 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
2733 // this thread to block.
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002734 return EnsureResolved(self, descriptor, existing);
Brian Carlstromaded5f72011-10-07 17:15:04 -07002735 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002736
Mathieu Chartierc7853442015-03-27 14:35:38 -07002737 // Load the fields and other things after we are inserted in the table. This is so that we don't
2738 // end up allocating unfree-able linear alloc resources and then lose the race condition. The
2739 // other reason is that the field roots are only visited from the class table. So we need to be
2740 // inserted before we allocate / fill in these fields.
2741 LoadClass(self, dex_file, dex_class_def, klass);
2742 if (self->IsExceptionPending()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002743 VLOG(class_linker) << self->GetException()->Dump();
Mathieu Chartierc7853442015-03-27 14:35:38 -07002744 // An exception occured during load, set status to erroneous while holding klass' lock in case
2745 // notification is necessary.
2746 if (!klass->IsErroneous()) {
2747 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
2748 }
2749 return nullptr;
2750 }
2751
Brian Carlstromaded5f72011-10-07 17:15:04 -07002752 // Finish loading (if necessary) by finding parents
2753 CHECK(!klass->IsLoaded());
2754 if (!LoadSuperAndInterfaces(klass, dex_file)) {
2755 // Loading failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002756 if (!klass->IsErroneous()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07002757 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002758 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002759 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002760 }
2761 CHECK(klass->IsLoaded());
2762 // Link the class (if necessary)
2763 CHECK(!klass->IsResolved());
Mathieu Chartier590fee92013-09-13 13:46:47 -07002764 // TODO: Use fast jobjects?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07002765 auto interfaces = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002766
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002767 MutableHandle<mirror::Class> h_new_class = hs.NewHandle<mirror::Class>(nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002768 if (!LinkClass(self, descriptor, klass, interfaces, &h_new_class)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002769 // Linking failed.
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002770 if (!klass->IsErroneous()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07002771 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Ian Rogersecd4d9a2014-07-22 00:59:52 -07002772 }
Ian Rogersc114b5f2014-07-21 08:55:01 -07002773 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -07002774 }
Mathieu Chartier524507a2014-08-27 15:28:28 -07002775 self->AssertNoPendingException();
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002776 CHECK(h_new_class.Get() != nullptr) << descriptor;
2777 CHECK(h_new_class->IsResolved()) << descriptor;
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002778
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01002779 // Update the dex cache of where the class is defined. Inlining depends on having
2780 // this filled.
2781 h_new_class->GetDexCache()->SetResolvedType(h_new_class->GetDexTypeIndex(), h_new_class.Get());
2782
Sebastien Hertza8a697f2015-01-15 12:28:47 +01002783 // Instrumentation may have updated entrypoints for all methods of all
2784 // classes. However it could not update methods of this class while we
2785 // were loading it. Now the class is resolved, we can update entrypoints
2786 // as required by instrumentation.
2787 if (Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
2788 // We must be in the kRunnable state to prevent instrumentation from
2789 // suspending all threads to update entrypoints while we are doing it
2790 // for this class.
2791 DCHECK_EQ(self->GetState(), kRunnable);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002792 Runtime::Current()->GetInstrumentation()->InstallStubsForClass(h_new_class.Get());
Sebastien Hertza8a697f2015-01-15 12:28:47 +01002793 }
2794
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002795 /*
2796 * We send CLASS_PREPARE events to the debugger from here. The
2797 * definition of "preparation" is creating the static fields for a
2798 * class and initializing them to the standard default values, but not
2799 * executing any code (that comes later, during "initialization").
2800 *
2801 * We did the static preparation in LinkClass.
2802 *
2803 * The class has been prepared and resolved but possibly not yet verified
2804 * at this point.
2805 */
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002806 Dbg::PostClassPrepare(h_new_class.Get());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002807
Tamas Berghammer160e6df2016-01-05 14:29:02 +00002808 // Notify native debugger of the new class and its layout.
2809 jit::Jit::NewTypeLoadedIfUsingJit(h_new_class.Get());
2810
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07002811 return h_new_class.Get();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002812}
2813
Mingyao Yang98d1cc82014-05-15 17:02:16 -07002814uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
2815 const DexFile::ClassDef& dex_class_def) {
Ian Rogers13735952014-10-08 12:43:28 -07002816 const uint8_t* class_data = dex_file.GetClassData(dex_class_def);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002817 size_t num_ref = 0;
Fred Shih37f05ef2014-07-16 18:38:08 -07002818 size_t num_8 = 0;
2819 size_t num_16 = 0;
Brian Carlstrom4873d462011-08-21 15:23:39 -07002820 size_t num_32 = 0;
2821 size_t num_64 = 0;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002822 if (class_data != nullptr) {
Vladimir Marko879d27b2016-03-15 20:31:50 +00002823 // We allow duplicate definitions of the same field in a class_data_item
2824 // but ignore the repeated indexes here, b/21868015.
2825 uint32_t last_field_idx = DexFile::kDexNoIndex;
Ian Rogers0571d352011-11-03 19:51:38 -07002826 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) {
Vladimir Marko879d27b2016-03-15 20:31:50 +00002827 uint32_t field_idx = it.GetMemberIndex();
2828 // Ordering enforced by DexFileVerifier.
2829 DCHECK(last_field_idx == DexFile::kDexNoIndex || last_field_idx <= field_idx);
2830 if (UNLIKELY(field_idx == last_field_idx)) {
2831 continue;
2832 }
2833 last_field_idx = field_idx;
2834 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07002835 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002836 char c = descriptor[0];
Fred Shih37f05ef2014-07-16 18:38:08 -07002837 switch (c) {
2838 case 'L':
2839 case '[':
2840 num_ref++;
2841 break;
2842 case 'J':
2843 case 'D':
2844 num_64++;
2845 break;
2846 case 'I':
2847 case 'F':
2848 num_32++;
2849 break;
2850 case 'S':
2851 case 'C':
2852 num_16++;
2853 break;
2854 case 'B':
2855 case 'Z':
2856 num_8++;
2857 break;
2858 default:
2859 LOG(FATAL) << "Unknown descriptor: " << c;
Ian Rogerse0a02da2014-12-02 14:10:53 -08002860 UNREACHABLE();
Brian Carlstrom4873d462011-08-21 15:23:39 -07002861 }
2862 }
2863 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07002864 return mirror::Class::ComputeClassSize(false,
2865 0,
2866 num_8,
2867 num_16,
2868 num_32,
2869 num_64,
2870 num_ref,
Mathieu Chartiere401d142015-04-22 13:56:20 -07002871 image_pointer_size_);
Brian Carlstrom4873d462011-08-21 15:23:39 -07002872}
2873
TDYa12785321912012-04-01 15:24:56 -07002874// Special case to get oat code without overwriting a trampoline.
Mathieu Chartiere401d142015-04-22 13:56:20 -07002875const void* ClassLinker::GetQuickOatCodeFor(ArtMethod* method) {
David Sehr709b0702016-10-13 09:12:37 -07002876 CHECK(method->IsInvokable()) << method->PrettyMethod();
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00002877 if (method->IsProxyMethod()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08002878 return GetQuickProxyInvokeHandler();
Jeff Hao8df6cea2013-07-29 13:54:48 -07002879 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002880 auto* code = method->GetOatMethodQuickCode(GetImagePointerSize());
2881 if (code != nullptr) {
2882 return code;
Mathieu Chartier2535abe2015-02-17 10:38:49 -08002883 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002884 if (method->IsNative()) {
2885 // No code and native? Use generic trampoline.
2886 return GetQuickGenericJniStub();
2887 }
2888 return GetQuickToInterpreterBridge();
TDYa12785321912012-04-01 15:24:56 -07002889}
2890
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002891bool ClassLinker::ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) {
2892 if (UNLIKELY(method->IsNative() || method->IsProxyMethod())) {
2893 return false;
2894 }
2895
Elliott Hughes956af0f2014-12-11 14:34:28 -08002896 if (quick_code == nullptr) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002897 return true;
2898 }
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002899
2900 Runtime* runtime = Runtime::Current();
2901 instrumentation::Instrumentation* instr = runtime->GetInstrumentation();
2902 if (instr->InterpretOnly()) {
2903 return true;
2904 }
2905
2906 if (runtime->GetClassLinker()->IsQuickToInterpreterBridge(quick_code)) {
2907 // Doing this check avoids doing compiled/interpreter transitions.
2908 return true;
2909 }
2910
2911 if (Dbg::IsForcedInterpreterNeededForCalling(Thread::Current(), method)) {
2912 // Force the use of interpreter when it is required by the debugger.
2913 return true;
2914 }
2915
Alex Light6b16d892016-11-11 11:21:04 -08002916 if (runtime->IsFullyDeoptable()) {
2917 // We need to be able to deoptimize at any time so we should always just ignore precompiled
2918 // code and go to the interpreter assuming we don't already have jitted code.
2919 jit::Jit* jit = Runtime::Current()->GetJit();
2920 return (jit == nullptr) || !jit->GetCodeCache()->ContainsPc(quick_code);
2921 }
2922
David Srbeckyf4480162016-03-16 00:06:24 +00002923 if (runtime->IsNativeDebuggable()) {
Calin Juravlee5de54c2016-04-20 14:22:09 +01002924 DCHECK(runtime->UseJitCompilation() && runtime->GetJit()->JitAtFirstUse());
David Srbeckyf4480162016-03-16 00:06:24 +00002925 // If we are doing native debugging, ignore application's AOT code,
2926 // since we want to JIT it with extra stackmaps for native debugging.
2927 // On the other hand, keep all AOT code from the boot image, since the
2928 // blocking JIT would results in non-negligible performance impact.
2929 return !runtime->GetHeap()->IsInBootImageOatFile(quick_code);
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002930 }
2931
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -08002932 if (Dbg::IsDebuggerActive()) {
David Srbeckyf4480162016-03-16 00:06:24 +00002933 // Boot image classes may be AOT-compiled as non-debuggable.
2934 // This is not suitable for the Java debugger, so ignore the AOT code.
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -08002935 return runtime->GetHeap()->IsInBootImageOatFile(quick_code);
2936 }
2937
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002938 return false;
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002939}
2940
Mathieu Chartier28357fa2016-10-18 16:27:40 -07002941void ClassLinker::FixupStaticTrampolines(ObjPtr<mirror::Class> klass) {
David Sehr709b0702016-10-13 09:12:37 -07002942 DCHECK(klass->IsInitialized()) << klass->PrettyDescriptor();
Ian Rogers1c829822013-09-30 18:18:50 -07002943 if (klass->NumDirectMethods() == 0) {
2944 return; // No direct methods => no static methods.
Ian Rogers19846512012-02-24 11:42:47 -08002945 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002946 Runtime* runtime = Runtime::Current();
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07002947 if (!runtime->IsStarted()) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002948 if (runtime->IsAotCompiler() || runtime->GetHeap()->HasBootImageSpace()) {
Alex Light64ad14d2014-08-19 14:23:13 -07002949 return; // OAT file unavailable.
2950 }
Ian Rogers19846512012-02-24 11:42:47 -08002951 }
Alex Light64ad14d2014-08-19 14:23:13 -07002952
Mathieu Chartierf8322842014-05-16 10:59:25 -07002953 const DexFile& dex_file = klass->GetDexFile();
2954 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Ian Rogers1c829822013-09-30 18:18:50 -07002955 CHECK(dex_class_def != nullptr);
Ian Rogers13735952014-10-08 12:43:28 -07002956 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
Ian Rogers1c829822013-09-30 18:18:50 -07002957 // There should always be class data if there were direct methods.
David Sehr709b0702016-10-13 09:12:37 -07002958 CHECK(class_data != nullptr) << klass->PrettyDescriptor();
Ian Rogers19846512012-02-24 11:42:47 -08002959 ClassDataItemIterator it(dex_file, class_data);
2960 // Skip fields
2961 while (it.HasNextStaticField()) {
2962 it.Next();
2963 }
2964 while (it.HasNextInstanceField()) {
2965 it.Next();
2966 }
Ian Rogers97b52f82014-08-14 11:34:07 -07002967 bool has_oat_class;
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002968 OatFile::OatClass oat_class = OatFile::FindOatClass(dex_file,
2969 klass->GetDexClassDefIndex(),
2970 &has_oat_class);
Ian Rogers1c829822013-09-30 18:18:50 -07002971 // Link the code of methods skipped by LinkCode.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002972 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002973 ArtMethod* method = klass->GetDirectMethod(method_index, image_pointer_size_);
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002974 if (!method->IsStatic()) {
2975 // Only update static methods.
2976 continue;
Ian Rogers19846512012-02-24 11:42:47 -08002977 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01002978 const void* quick_code = nullptr;
2979 if (has_oat_class) {
2980 OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01002981 quick_code = oat_method.GetQuickCode();
2982 }
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002983 // Check whether the method is native, in which case it's generic JNI.
2984 if (quick_code == nullptr && method->IsNative()) {
2985 quick_code = GetQuickGenericJniStub();
2986 } else if (ShouldUseInterpreterEntrypoint(method, quick_code)) {
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002987 // Use interpreter entry point.
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00002988 quick_code = GetQuickToInterpreterBridge();
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02002989 }
Elliott Hughes956af0f2014-12-11 14:34:28 -08002990 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code);
Ian Rogers19846512012-02-24 11:42:47 -08002991 }
Ian Rogers62d6c772013-02-27 08:32:07 -08002992 // Ignore virtual methods on the iterator.
Ian Rogers19846512012-02-24 11:42:47 -08002993}
2994
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01002995// Does anything needed to make sure that the compiler will not generate a direct invoke to this
2996// method. Should only be called on non-invokable methods.
2997inline void EnsureThrowsInvocationError(ClassLinker* class_linker, ArtMethod* method) {
Alex Light9139e002015-10-09 15:59:48 -07002998 DCHECK(method != nullptr);
2999 DCHECK(!method->IsInvokable());
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003000 method->SetEntryPointFromQuickCompiledCodePtrSize(
3001 class_linker->GetQuickToInterpreterBridgeTrampoline(),
3002 class_linker->GetImagePointerSize());
Alex Light9139e002015-10-09 15:59:48 -07003003}
3004
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003005static void LinkCode(ClassLinker* class_linker,
3006 ArtMethod* method,
3007 const OatFile::OatClass* oat_class,
3008 uint32_t class_def_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003009 Runtime* const runtime = Runtime::Current();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08003010 if (runtime->IsAotCompiler()) {
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003011 // The following code only applies to a non-compiler runtime.
3012 return;
3013 }
Ian Rogers62d6c772013-02-27 08:32:07 -08003014 // Method shouldn't have already been linked.
Ian Rogersef7d42f2014-01-06 12:55:46 -08003015 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003016 if (oat_class != nullptr) {
3017 // Every kind of method should at least get an invoke stub from the oat_method.
3018 // non-abstract methods also get their code pointers.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07003019 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003020 oat_method.LinkMethod(method);
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +01003021 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07003022
Tamas Berghammer3a98aae2016-02-08 20:21:54 +00003023 // Install entry point from interpreter.
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003024 const void* quick_code = method->GetEntryPointFromQuickCompiledCode();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003025 bool enter_interpreter = class_linker->ShouldUseInterpreterEntrypoint(method, quick_code);
Jeff Hao16743632013-05-08 10:59:04 -07003026
Alex Light9139e002015-10-09 15:59:48 -07003027 if (!method->IsInvokable()) {
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003028 EnsureThrowsInvocationError(class_linker, method);
Brian Carlstrom92827a52011-10-10 15:50:01 -07003029 return;
3030 }
Ian Rogers19846512012-02-24 11:42:47 -08003031
3032 if (method->IsStatic() && !method->IsConstructor()) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003033 // For static methods excluding the class initializer, install the trampoline.
Sebastien Hertz7d658cf2013-07-09 10:56:11 +02003034 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines
3035 // after initializing class (see ClassLinker::InitializeClass method).
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003036 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub());
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003037 } else if (quick_code == nullptr && method->IsNative()) {
3038 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniStub());
Tamas Berghammer3a98aae2016-02-08 20:21:54 +00003039 } else if (enter_interpreter) {
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003040 // Set entry point from compiled code if there's no code or in interpreter only mode.
3041 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
Ian Rogers0d6de042012-02-29 08:50:26 -08003042 }
jeffhao26c0a1a2012-01-17 16:28:33 -08003043
Ian Rogers62d6c772013-02-27 08:32:07 -08003044 if (method->IsNative()) {
3045 // Unregistering restores the dlsym lookup stub.
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003046 method->UnregisterNative();
Andreas Gampe90546832014-03-12 18:07:19 -07003047
Tamas Berghammerdd5e5e92016-02-12 16:29:00 +00003048 if (enter_interpreter || quick_code == nullptr) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003049 // We have a native method here without code. Then it should have either the generic JNI
3050 // trampoline as entrypoint (non-static), or the resolution trampoline (static).
3051 // TODO: this doesn't handle all the cases where trampolines may be installed.
3052 const void* entry_point = method->GetEntryPointFromQuickCompiledCode();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003053 DCHECK(class_linker->IsQuickGenericJniStub(entry_point) ||
3054 class_linker->IsQuickResolutionStub(entry_point));
Andreas Gampe90546832014-03-12 18:07:19 -07003055 }
Brian Carlstrom92827a52011-10-10 15:50:01 -07003056 }
3057}
3058
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003059void ClassLinker::SetupClass(const DexFile& dex_file,
3060 const DexFile::ClassDef& dex_class_def,
3061 Handle<mirror::Class> klass,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003062 ObjPtr<mirror::ClassLoader> class_loader) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003063 CHECK(klass.Get() != nullptr);
3064 CHECK(klass->GetDexCache() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003065 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
Brian Carlstromf615a612011-07-23 12:50:34 -07003066 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003067 CHECK(descriptor != nullptr);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003068
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003069 klass->SetClass(GetClassRoot(kJavaLangClass));
Andreas Gampe51829322014-08-25 15:05:04 -07003070 uint32_t access_flags = dex_class_def.GetJavaAccessFlags();
Brian Carlstrom8e3fb142013-10-09 21:00:27 -07003071 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003072 klass->SetAccessFlags(access_flags);
3073 klass->SetClassLoader(class_loader);
Ian Rogersc2b44472011-12-14 21:17:17 -08003074 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003075 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, nullptr);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003076
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003077 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003078 klass->SetDexTypeIndex(dex_class_def.class_idx_);
Mathieu Chartier91a6dc42014-12-01 10:31:15 -08003079 CHECK(klass->GetDexCacheStrings() != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07003080}
Brian Carlstrom934486c2011-07-12 23:42:50 -07003081
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003082void ClassLinker::LoadClass(Thread* self,
3083 const DexFile& dex_file,
Mathieu Chartierc7853442015-03-27 14:35:38 -07003084 const DexFile::ClassDef& dex_class_def,
3085 Handle<mirror::Class> klass) {
Ian Rogers13735952014-10-08 12:43:28 -07003086 const uint8_t* class_data = dex_file.GetClassData(dex_class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003087 if (class_data == nullptr) {
Ian Rogers0571d352011-11-03 19:51:38 -07003088 return; // no fields or methods - for example a marker interface
Brian Carlstrom934486c2011-07-12 23:42:50 -07003089 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003090 LoadClassMembers(self, dex_file, class_data, klass);
Vladimir Markod3c5beb2014-04-11 16:32:51 +01003091}
3092
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003093LengthPrefixedArray<ArtField>* ClassLinker::AllocArtFieldArray(Thread* self,
3094 LinearAlloc* allocator,
3095 size_t length) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003096 if (length == 0) {
3097 return nullptr;
3098 }
Vladimir Markocf36d492015-08-12 19:27:26 +01003099 // If the ArtField alignment changes, review all uses of LengthPrefixedArray<ArtField>.
3100 static_assert(alignof(ArtField) == 4, "ArtField alignment is expected to be 4.");
3101 size_t storage_size = LengthPrefixedArray<ArtField>::ComputeSize(length);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003102 void* array_storage = allocator->Alloc(self, storage_size);
Vladimir Markocf36d492015-08-12 19:27:26 +01003103 auto* ret = new(array_storage) LengthPrefixedArray<ArtField>(length);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003104 CHECK(ret != nullptr);
3105 std::uninitialized_fill_n(&ret->At(0), length, ArtField());
3106 return ret;
Mathieu Chartierc7853442015-03-27 14:35:38 -07003107}
3108
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003109LengthPrefixedArray<ArtMethod>* ClassLinker::AllocArtMethodArray(Thread* self,
3110 LinearAlloc* allocator,
3111 size_t length) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003112 if (length == 0) {
3113 return nullptr;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003114 }
Vladimir Marko14632852015-08-17 12:07:23 +01003115 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_);
3116 const size_t method_size = ArtMethod::Size(image_pointer_size_);
Vladimir Markocf36d492015-08-12 19:27:26 +01003117 const size_t storage_size =
3118 LengthPrefixedArray<ArtMethod>::ComputeSize(length, method_size, method_alignment);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003119 void* array_storage = allocator->Alloc(self, storage_size);
Vladimir Markocf36d492015-08-12 19:27:26 +01003120 auto* ret = new (array_storage) LengthPrefixedArray<ArtMethod>(length);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003121 CHECK(ret != nullptr);
3122 for (size_t i = 0; i < length; ++i) {
Vladimir Markocf36d492015-08-12 19:27:26 +01003123 new(reinterpret_cast<void*>(&ret->At(i, method_size, method_alignment))) ArtMethod;
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003124 }
3125 return ret;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003126}
3127
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003128LinearAlloc* ClassLinker::GetAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003129 if (class_loader == nullptr) {
3130 return Runtime::Current()->GetLinearAlloc();
3131 }
3132 LinearAlloc* allocator = class_loader->GetAllocator();
3133 DCHECK(allocator != nullptr);
3134 return allocator;
3135}
3136
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003137LinearAlloc* ClassLinker::GetOrCreateAllocatorForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003138 if (class_loader == nullptr) {
3139 return Runtime::Current()->GetLinearAlloc();
3140 }
3141 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3142 LinearAlloc* allocator = class_loader->GetAllocator();
3143 if (allocator == nullptr) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08003144 RegisterClassLoader(class_loader);
3145 allocator = class_loader->GetAllocator();
3146 CHECK(allocator != nullptr);
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003147 }
3148 return allocator;
3149}
3150
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003151void ClassLinker::LoadClassMembers(Thread* self,
3152 const DexFile& dex_file,
Ian Rogers13735952014-10-08 12:43:28 -07003153 const uint8_t* class_data,
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003154 Handle<mirror::Class> klass) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003155 {
3156 // Note: We cannot have thread suspension until the field and method arrays are setup or else
3157 // Class::VisitFieldRoots may miss some fields or methods.
Mathieu Chartier268764d2016-09-13 12:09:38 -07003158 ScopedAssertNoThreadSuspension nts(__FUNCTION__);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003159 // Load static fields.
Vladimir Marko23682bf2015-06-24 14:28:03 +01003160 // We allow duplicate definitions of the same field in a class_data_item
3161 // but ignore the repeated indexes here, b/21868015.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003162 LinearAlloc* const allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
Mathieu Chartiere401d142015-04-22 13:56:20 -07003163 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003164 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self,
3165 allocator,
3166 it.NumStaticFields());
Vladimir Marko23682bf2015-06-24 14:28:03 +01003167 size_t num_sfields = 0;
3168 uint32_t last_field_idx = 0u;
3169 for (; it.HasNextStaticField(); it.Next()) {
3170 uint32_t field_idx = it.GetMemberIndex();
3171 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier.
3172 if (num_sfields == 0 || LIKELY(field_idx > last_field_idx)) {
3173 DCHECK_LT(num_sfields, it.NumStaticFields());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003174 LoadField(it, klass, &sfields->At(num_sfields));
Vladimir Marko23682bf2015-06-24 14:28:03 +01003175 ++num_sfields;
3176 last_field_idx = field_idx;
3177 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003178 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003179 // Load instance fields.
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003180 LengthPrefixedArray<ArtField>* ifields = AllocArtFieldArray(self,
3181 allocator,
3182 it.NumInstanceFields());
Vladimir Marko23682bf2015-06-24 14:28:03 +01003183 size_t num_ifields = 0u;
3184 last_field_idx = 0u;
3185 for (; it.HasNextInstanceField(); it.Next()) {
3186 uint32_t field_idx = it.GetMemberIndex();
3187 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier.
3188 if (num_ifields == 0 || LIKELY(field_idx > last_field_idx)) {
3189 DCHECK_LT(num_ifields, it.NumInstanceFields());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003190 LoadField(it, klass, &ifields->At(num_ifields));
Vladimir Marko23682bf2015-06-24 14:28:03 +01003191 ++num_ifields;
3192 last_field_idx = field_idx;
3193 }
3194 }
3195 if (UNLIKELY(num_sfields != it.NumStaticFields()) ||
3196 UNLIKELY(num_ifields != it.NumInstanceFields())) {
David Sehr709b0702016-10-13 09:12:37 -07003197 LOG(WARNING) << "Duplicate fields in class " << klass->PrettyDescriptor()
Vladimir Marko23682bf2015-06-24 14:28:03 +01003198 << " (unique static fields: " << num_sfields << "/" << it.NumStaticFields()
3199 << ", unique instance fields: " << num_ifields << "/" << it.NumInstanceFields() << ")";
Vladimir Marko81819db2015-11-05 15:30:12 +00003200 // NOTE: Not shrinking the over-allocated sfields/ifields, just setting size.
3201 if (sfields != nullptr) {
3202 sfields->SetSize(num_sfields);
3203 }
3204 if (ifields != nullptr) {
3205 ifields->SetSize(num_ifields);
3206 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07003207 }
Vladimir Marko81819db2015-11-05 15:30:12 +00003208 // Set the field arrays.
3209 klass->SetSFieldsPtr(sfields);
3210 DCHECK_EQ(klass->NumStaticFields(), num_sfields);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003211 klass->SetIFieldsPtr(ifields);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003212 DCHECK_EQ(klass->NumInstanceFields(), num_ifields);
3213 // Load methods.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003214 bool has_oat_class = false;
3215 const OatFile::OatClass oat_class =
3216 (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler())
3217 ? OatFile::FindOatClass(dex_file, klass->GetDexClassDefIndex(), &has_oat_class)
3218 : OatFile::OatClass::Invalid();
3219 const OatFile::OatClass* oat_class_ptr = has_oat_class ? &oat_class : nullptr;
Alex Lighte64300b2015-12-15 15:02:47 -08003220 klass->SetMethodsPtr(
3221 AllocArtMethodArray(self, allocator, it.NumDirectMethods() + it.NumVirtualMethods()),
3222 it.NumDirectMethods(),
3223 it.NumVirtualMethods());
Mathieu Chartiere401d142015-04-22 13:56:20 -07003224 size_t class_def_method_index = 0;
3225 uint32_t last_dex_method_index = DexFile::kDexNoIndex;
3226 size_t last_class_def_method_index = 0;
Alex Lighte64300b2015-12-15 15:02:47 -08003227 // TODO These should really use the iterators.
Mathieu Chartiere401d142015-04-22 13:56:20 -07003228 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
3229 ArtMethod* method = klass->GetDirectMethodUnchecked(i, image_pointer_size_);
Mathieu Chartier268764d2016-09-13 12:09:38 -07003230 LoadMethod(dex_file, it, klass, method);
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003231 LinkCode(this, method, oat_class_ptr, class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003232 uint32_t it_method_index = it.GetMemberIndex();
3233 if (last_dex_method_index == it_method_index) {
3234 // duplicate case
3235 method->SetMethodIndex(last_class_def_method_index);
3236 } else {
3237 method->SetMethodIndex(class_def_method_index);
3238 last_dex_method_index = it_method_index;
3239 last_class_def_method_index = class_def_method_index;
3240 }
3241 class_def_method_index++;
3242 }
3243 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
3244 ArtMethod* method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
Mathieu Chartier268764d2016-09-13 12:09:38 -07003245 LoadMethod(dex_file, it, klass, method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003246 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01003247 LinkCode(this, method, oat_class_ptr, class_def_method_index);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003248 class_def_method_index++;
3249 }
3250 DCHECK(!it.HasNext());
Ian Rogers0571d352011-11-03 19:51:38 -07003251 }
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07003252 // Ensure that the card is marked so that remembered sets pick up native roots.
3253 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass.Get());
Mathieu Chartierf3f2a7a2015-04-14 15:43:10 -07003254 self->AllowThreadSuspension();
Brian Carlstrom934486c2011-07-12 23:42:50 -07003255}
3256
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003257void ClassLinker::LoadField(const ClassDataItemIterator& it,
3258 Handle<mirror::Class> klass,
Mathieu Chartierc7853442015-03-27 14:35:38 -07003259 ArtField* dst) {
3260 const uint32_t field_idx = it.GetMemberIndex();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003261 dst->SetDexFieldIndex(field_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003262 dst->SetDeclaringClass(klass.Get());
Andreas Gampe51829322014-08-25 15:05:04 -07003263 dst->SetAccessFlags(it.GetFieldAccessFlags());
Brian Carlstrom934486c2011-07-12 23:42:50 -07003264}
3265
Mathieu Chartier268764d2016-09-13 12:09:38 -07003266void ClassLinker::LoadMethod(const DexFile& dex_file,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003267 const ClassDataItemIterator& it,
3268 Handle<mirror::Class> klass,
3269 ArtMethod* dst) {
Ian Rogers19846512012-02-24 11:42:47 -08003270 uint32_t dex_method_idx = it.GetMemberIndex();
Ian Rogers19846512012-02-24 11:42:47 -08003271 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07003272 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07003273
Mathieu Chartier268764d2016-09-13 12:09:38 -07003274 ScopedAssertNoThreadSuspension ants("LoadMethod");
Mathieu Chartier66f19252012-09-18 08:57:04 -07003275 dst->SetDexMethodIndex(dex_method_idx);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003276 dst->SetDeclaringClass(klass.Get());
Ian Rogers0571d352011-11-03 19:51:38 -07003277 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset());
Brian Carlstrom934486c2011-07-12 23:42:50 -07003278
Vladimir Marko05792b92015-08-03 11:56:49 +01003279 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods(), image_pointer_size_);
3280 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes(), image_pointer_size_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07003281
Andreas Gampe51829322014-08-25 15:05:04 -07003282 uint32_t access_flags = it.GetMethodAccessFlags();
Ian Rogers241b5de2013-10-09 17:58:57 -07003283
Ian Rogersdfb325e2013-10-30 01:00:44 -07003284 if (UNLIKELY(strcmp("finalize", method_name) == 0)) {
Ian Rogers241b5de2013-10-09 17:58:57 -07003285 // Set finalizable flag on declaring class.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003286 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) {
3287 // Void return type.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003288 if (klass->GetClassLoader() != nullptr) { // All non-boot finalizer methods are flagged.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003289 klass->SetFinalizable();
3290 } else {
Ian Rogers1ff3c982014-08-12 02:30:58 -07003291 std::string temp;
3292 const char* klass_descriptor = klass->GetDescriptor(&temp);
Ian Rogersdfb325e2013-10-30 01:00:44 -07003293 // The Enum class declares a "final" finalize() method to prevent subclasses from
3294 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
3295 // subclasses, so we exclude it here.
3296 // We also want to avoid setting the flag on Object, where we know that finalize() is
3297 // empty.
Ian Rogers1ff3c982014-08-12 02:30:58 -07003298 if (strcmp(klass_descriptor, "Ljava/lang/Object;") != 0 &&
3299 strcmp(klass_descriptor, "Ljava/lang/Enum;") != 0) {
Ian Rogers241b5de2013-10-09 17:58:57 -07003300 klass->SetFinalizable();
Ian Rogers241b5de2013-10-09 17:58:57 -07003301 }
3302 }
3303 }
3304 } else if (method_name[0] == '<') {
3305 // Fix broken access flags for initializers. Bug 11157540.
Ian Rogersdfb325e2013-10-30 01:00:44 -07003306 bool is_init = (strcmp("<init>", method_name) == 0);
3307 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0);
Ian Rogers241b5de2013-10-09 17:58:57 -07003308 if (UNLIKELY(!is_init && !is_clinit)) {
3309 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name;
3310 } else {
3311 if (UNLIKELY((access_flags & kAccConstructor) == 0)) {
3312 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class "
David Sehr709b0702016-10-13 09:12:37 -07003313 << klass->PrettyDescriptor() << " in dex file " << dex_file.GetLocation();
Ian Rogers241b5de2013-10-09 17:58:57 -07003314 access_flags |= kAccConstructor;
3315 }
3316 }
3317 }
3318 dst->SetAccessFlags(access_flags);
Brian Carlstrom934486c2011-07-12 23:42:50 -07003319}
3320
Ian Rogers7b078e82014-09-10 14:44:24 -07003321void ClassLinker::AppendToBootClassPath(Thread* self, const DexFile& dex_file) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003322 StackHandleScope<1> hs(self);
Mathieu Chartier6c60d842016-09-15 10:24:43 -07003323 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocAndInitializeDexCache(
Mathieu Chartierd57d4542015-10-14 10:55:30 -07003324 self,
3325 dex_file,
3326 Runtime::Current()->GetLinearAlloc())));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003327 CHECK(dex_cache.Get() != nullptr) << "Failed to allocate dex cache for "
3328 << dex_file.GetLocation();
Brian Carlstrom40381fb2011-10-19 14:13:40 -07003329 AppendToBootClassPath(dex_file, dex_cache);
Brian Carlstroma663ea52011-08-19 23:33:41 -07003330}
3331
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003332void ClassLinker::AppendToBootClassPath(const DexFile& dex_file,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003333 Handle<mirror::DexCache> dex_cache) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003334 CHECK(dex_cache.Get() != nullptr) << dex_file.GetLocation();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07003335 boot_class_path_.push_back(&dex_file);
Brian Carlstroma663ea52011-08-19 23:33:41 -07003336 RegisterDexFile(dex_file, dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003337}
3338
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003339void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003340 Handle<mirror::DexCache> dex_cache) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003341 Thread* const self = Thread::Current();
3342 dex_lock_.AssertExclusiveHeld(self);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003343 CHECK(dex_cache.Get() != nullptr) << dex_file.GetLocation();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003344 // For app images, the dex cache location may be a suffix of the dex file location since the
3345 // dex file location is an absolute path.
Mathieu Chartier76172162016-01-26 14:54:06 -08003346 const std::string dex_cache_location = dex_cache->GetLocation()->ToModifiedUtf8();
3347 const size_t dex_cache_length = dex_cache_location.length();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003348 CHECK_GT(dex_cache_length, 0u) << dex_file.GetLocation();
3349 std::string dex_file_location = dex_file.GetLocation();
3350 CHECK_GE(dex_file_location.length(), dex_cache_length)
Mathieu Chartier76172162016-01-26 14:54:06 -08003351 << dex_cache_location << " " << dex_file.GetLocation();
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003352 // Take suffix.
3353 const std::string dex_file_suffix = dex_file_location.substr(
3354 dex_file_location.length() - dex_cache_length,
3355 dex_cache_length);
3356 // Example dex_cache location is SettingsProvider.apk and
3357 // dex file location is /system/priv-app/SettingsProvider/SettingsProvider.apk
Mathieu Chartier76172162016-01-26 14:54:06 -08003358 CHECK_EQ(dex_cache_location, dex_file_suffix);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003359 // Clean up pass to remove null dex caches.
3360 // Null dex caches can occur due to class unloading and we are lazily removing null entries.
3361 JavaVMExt* const vm = self->GetJniEnv()->vm;
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003362 for (auto it = dex_caches_.begin(); it != dex_caches_.end(); ) {
3363 DexCacheData data = *it;
3364 if (self->IsJWeakCleared(data.weak_root)) {
3365 vm->DeleteWeakGlobalRef(self, data.weak_root);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003366 it = dex_caches_.erase(it);
3367 } else {
3368 ++it;
3369 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003370 }
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003371 jweak dex_cache_jweak = vm->AddWeakGlobalRef(self, dex_cache.Get());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003372 dex_cache->SetDexFile(&dex_file);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003373 DexCacheData data;
3374 data.weak_root = dex_cache_jweak;
3375 data.dex_file = dex_cache->GetDexFile();
3376 data.resolved_types = dex_cache->GetResolvedTypes();
3377 dex_caches_.push_back(data);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003378}
3379
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003380mirror::DexCache* ClassLinker::RegisterDexFile(const DexFile& dex_file,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003381 ObjPtr<mirror::ClassLoader> class_loader) {
Ian Rogers1f539342012-10-03 21:09:42 -07003382 Thread* self = Thread::Current();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003383 {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003384 ReaderMutexLock mu(self, dex_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003385 ObjPtr<mirror::DexCache> dex_cache = FindDexCacheLocked(self, dex_file, true);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003386 if (dex_cache != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003387 return dex_cache.Ptr();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003388 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07003389 }
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003390 LinearAlloc* const linear_alloc = GetOrCreateAllocatorForClassLoader(class_loader);
3391 DCHECK(linear_alloc != nullptr);
3392 ClassTable* table;
3393 {
3394 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
3395 table = InsertClassTableForClassLoader(class_loader);
3396 }
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003397 // Don't alloc while holding the lock, since allocation may need to
3398 // suspend all threads and another thread may need the dex_lock_ to
3399 // get to a suspend point.
Mathieu Chartier6c60d842016-09-15 10:24:43 -07003400 StackHandleScope<2> hs(self);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003401 ObjPtr<mirror::String> location;
Mathieu Chartier6c60d842016-09-15 10:24:43 -07003402 Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(AllocDexCache(/*out*/&location,
3403 self,
3404 dex_file)));
3405 Handle<mirror::String> h_location(hs.NewHandle(location));
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003406 {
3407 WriterMutexLock mu(self, dex_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003408 ObjPtr<mirror::DexCache> dex_cache = FindDexCacheLocked(self, dex_file, true);
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003409 if (dex_cache != nullptr) {
Vladimir Markoc9a6fa52016-10-25 13:04:00 +01003410 // Another thread managed to initialize the dex cache faster, so use that DexCache.
3411 // If this thread encountered OOME, ignore it.
3412 DCHECK_EQ(h_dex_cache.Get() == nullptr, self->IsExceptionPending());
3413 self->ClearException();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003414 return dex_cache.Ptr();
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003415 }
3416 if (h_dex_cache.Get() == nullptr) {
3417 self->AssertPendingOOMException();
3418 return nullptr;
3419 }
Mathieu Chartier6c60d842016-09-15 10:24:43 -07003420 // Do InitializeDexCache while holding dex lock to make sure two threads don't call it at the
3421 // same time with the same dex cache. Since the .bss is shared this can cause failing DCHECK
3422 // that the arrays are null.
3423 InitializeDexCache(self, h_dex_cache.Get(), h_location.Get(), dex_file, linear_alloc);
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003424 RegisterDexFileLocked(dex_file, h_dex_cache);
Brian Carlstrom47d237a2011-10-18 15:08:33 -07003425 }
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07003426 table->InsertStrongRoot(h_dex_cache.Get());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003427 return h_dex_cache.Get();
Brian Carlstromaded5f72011-10-07 17:15:04 -07003428}
3429
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003430void ClassLinker::RegisterDexFile(const DexFile& dex_file,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003431 Handle<mirror::DexCache> dex_cache) {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07003432 WriterMutexLock mu(Thread::Current(), dex_lock_);
Brian Carlstromaded5f72011-10-07 17:15:04 -07003433 RegisterDexFileLocked(dex_file, dex_cache);
3434}
3435
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003436mirror::DexCache* ClassLinker::FindDexCache(Thread* self,
3437 const DexFile& dex_file,
3438 bool allow_failure) {
3439 ReaderMutexLock mu(self, dex_lock_);
3440 return FindDexCacheLocked(self, dex_file, allow_failure);
3441}
3442
3443mirror::DexCache* ClassLinker::FindDexCacheLocked(Thread* self,
3444 const DexFile& dex_file,
3445 bool allow_failure) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003446 // Search assuming unique-ness of dex file.
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003447 for (const DexCacheData& data : dex_caches_) {
3448 // Avoid decoding (and read barriers) other unrelated dex caches.
3449 if (data.dex_file == &dex_file) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003450 ObjPtr<mirror::DexCache> dex_cache =
3451 ObjPtr<mirror::DexCache>::DownCast(self->DecodeJObject(data.weak_root));
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003452 if (dex_cache != nullptr) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003453 return dex_cache.Ptr();
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003454 }
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003455 break;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003456 }
3457 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003458 if (allow_failure) {
3459 return nullptr;
3460 }
Mathieu Chartierac8f4392015-08-27 13:54:20 -07003461 std::string location(dex_file.GetLocation());
Brian Carlstrom81a90872015-08-28 09:07:14 -07003462 // Failure, dump diagnostic and abort.
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003463 for (const DexCacheData& data : dex_caches_) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003464 ObjPtr<mirror::DexCache> dex_cache =
3465 ObjPtr<mirror::DexCache>::DownCast(self->DecodeJObject(data.weak_root));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003466 if (dex_cache != nullptr) {
3467 LOG(ERROR) << "Registered dex file " << dex_cache->GetDexFile()->GetLocation();
3468 }
Brian Carlstrom81a90872015-08-28 09:07:14 -07003469 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003470 LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
Ian Rogerse0a02da2014-12-02 14:10:53 -08003471 UNREACHABLE();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003472}
3473
Mathieu Chartiere401d142015-04-22 13:56:20 -07003474void ClassLinker::FixupDexCaches(ArtMethod* resolution_method) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003475 Thread* const self = Thread::Current();
3476 ReaderMutexLock mu(self, dex_lock_);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003477 for (const DexCacheData& data : dex_caches_) {
3478 if (!self->IsJWeakCleared(data.weak_root)) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07003479 ObjPtr<mirror::DexCache> dex_cache = ObjPtr<mirror::DexCache>::DownCast(
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08003480 self->DecodeJObject(data.weak_root));
3481 if (dex_cache != nullptr) {
3482 dex_cache->Fixup(resolution_method, image_pointer_size_);
3483 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003484 }
Ian Rogers19846512012-02-24 11:42:47 -08003485 }
3486}
3487
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003488mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
Mathieu Chartier6beced42016-11-15 15:51:31 -08003489 ObjPtr<mirror::Class> klass =
3490 AllocClass(self, mirror::Class::PrimitiveClassSize(image_pointer_size_));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003491 if (UNLIKELY(klass == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003492 self->AssertPendingOOMException();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003493 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07003494 }
3495 return InitializePrimitiveClass(klass, type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003496}
3497
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003498mirror::Class* ClassLinker::InitializePrimitiveClass(ObjPtr<mirror::Class> primitive_class,
Mathieu Chartierc528dba2013-11-26 12:00:11 -08003499 Primitive::Type type) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003500 CHECK(primitive_class != nullptr);
Ian Rogers1f539342012-10-03 21:09:42 -07003501 // Must hold lock on object when initializing.
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003502 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003503 StackHandleScope<1> hs(self);
3504 Handle<mirror::Class> h_class(hs.NewHandle(primitive_class));
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003505 ObjectLock<mirror::Class> lock(self, h_class);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003506 h_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
3507 h_class->SetPrimitiveType(type);
Mathieu Chartier6beced42016-11-15 15:51:31 -08003508 h_class->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003509 mirror::Class::SetStatus(h_class, mirror::Class::kStatusInitialized, self);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003510 const char* descriptor = Primitive::Descriptor(type);
Mathieu Chartier6beced42016-11-15 15:51:31 -08003511 ObjPtr<mirror::Class> existing = InsertClass(descriptor,
3512 h_class.Get(),
3513 ComputeModifiedUtf8Hash(descriptor));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003514 CHECK(existing == nullptr) << "InitPrimitiveClass(" << type << ") failed";
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003515 return h_class.Get();
Carl Shapiro565f5072011-07-10 13:39:43 -07003516}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003517
Brian Carlstrombe977852011-07-19 14:54:54 -07003518// Create an array class (i.e. the class object for the array, not the
3519// array itself). "descriptor" looks like "[C" or "[[[[B" or
3520// "[Ljava/lang/String;".
3521//
3522// If "descriptor" refers to an array of primitives, look up the
3523// primitive type's internally-generated class object.
3524//
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003525// "class_loader" is the class loader of the class that's referring to
3526// us. It's used to ensure that we're looking for the element type in
3527// the right context. It does NOT become the class loader for the
3528// array class; that always comes from the base element class.
Brian Carlstrombe977852011-07-19 14:54:54 -07003529//
Mathieu Chartier2cebb242015-04-21 16:50:40 -07003530// Returns null with an exception raised on failure.
Igor Murashkinb1d8c312015-08-04 11:18:43 -07003531mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor, size_t hash,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003532 Handle<mirror::ClassLoader> class_loader) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003533 // Identify the underlying component type
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003534 CHECK_EQ('[', descriptor[0]);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003535 StackHandleScope<2> hs(self);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07003536 MutableHandle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1,
3537 class_loader)));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003538 if (component_type.Get() == nullptr) {
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003539 DCHECK(self->IsExceptionPending());
Andreas Gampedc13d7d2014-07-23 20:18:36 -07003540 // We need to accept erroneous classes as component types.
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08003541 const size_t component_hash = ComputeModifiedUtf8Hash(descriptor + 1);
3542 component_type.Assign(LookupClass(self, descriptor + 1, component_hash, class_loader.Get()));
Andreas Gampedc13d7d2014-07-23 20:18:36 -07003543 if (component_type.Get() == nullptr) {
3544 DCHECK(self->IsExceptionPending());
3545 return nullptr;
3546 } else {
3547 self->ClearException();
3548 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003549 }
Ian Rogers2d10b202014-05-12 19:15:18 -07003550 if (UNLIKELY(component_type->IsPrimitiveVoid())) {
3551 ThrowNoClassDefFoundError("Attempt to create array of void primitive type");
3552 return nullptr;
3553 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003554 // See if the component type is already loaded. Array classes are
3555 // always associated with the class loader of their underlying
3556 // element type -- an array of Strings goes with the loader for
3557 // java/lang/String -- so we need to look for it there. (The
3558 // caller should have checked for the existence of the class
3559 // before calling here, but they did so with *their* class loader,
3560 // not the component type's loader.)
3561 //
3562 // If we find it, the caller adds "loader" to the class' initiating
3563 // loader list, which should prevent us from going through this again.
3564 //
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003565 // This call is unnecessary if "loader" and "component_type->GetClassLoader()"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003566 // are the same, because our caller (FindClass) just did the
3567 // lookup. (Even if we get this wrong we still have correct behavior,
3568 // because we effectively do this lookup again when we add the new
3569 // class to the hash table --- necessary because of possible races with
3570 // other threads.)
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003571 if (class_loader.Get() != component_type->GetClassLoader()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003572 ObjPtr<mirror::Class> new_class = LookupClass(self, descriptor, hash, component_type->GetClassLoader());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003573 if (new_class != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003574 return new_class.Ptr();
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003575 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003576 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003577
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003578 // Fill out the fields in the Class.
3579 //
3580 // It is possible to execute some methods against arrays, because
3581 // all arrays are subclasses of java_lang_Object_, so we need to set
3582 // up a vtable. We can just point at the one in java_lang_Object_.
3583 //
3584 // Array classes are simple enough that we don't need to do a full
3585 // link step.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003586 auto new_class = hs.NewHandle<mirror::Class>(nullptr);
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003587 if (UNLIKELY(!init_done_)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003588 // Classes that were hand created, ie not by FindSystemClass
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003589 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003590 new_class.Assign(GetClassRoot(kClassArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003591 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003592 new_class.Assign(GetClassRoot(kObjectArrayClass));
Ian Rogers6f3dbba2014-10-14 17:41:57 -07003593 } else if (strcmp(descriptor, GetClassRootDescriptor(kJavaLangStringArrayClass)) == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003594 new_class.Assign(GetClassRoot(kJavaLangStringArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003595 } else if (strcmp(descriptor, "[C") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003596 new_class.Assign(GetClassRoot(kCharArrayClass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003597 } else if (strcmp(descriptor, "[I") == 0) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003598 new_class.Assign(GetClassRoot(kIntArrayClass));
Mathieu Chartierc7853442015-03-27 14:35:38 -07003599 } else if (strcmp(descriptor, "[J") == 0) {
3600 new_class.Assign(GetClassRoot(kLongArrayClass));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003601 }
3602 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003603 if (new_class.Get() == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003604 new_class.Assign(AllocClass(self, mirror::Array::ClassSize(image_pointer_size_)));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003605 if (new_class.Get() == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003606 self->AssertPendingOOMException();
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003607 return nullptr;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003608 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003609 new_class->SetComponentType(component_type.Get());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003610 }
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07003611 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003612 DCHECK(new_class->GetComponentType() != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003613 ObjPtr<mirror::Class> java_lang_Object = GetClassRoot(kJavaLangObject);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003614 new_class->SetSuperClass(java_lang_Object);
3615 new_class->SetVTable(java_lang_Object->GetVTable());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003616 new_class->SetPrimitiveType(Primitive::kPrimNot);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003617 new_class->SetClassLoader(component_type->GetClassLoader());
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07003618 if (component_type->IsPrimitive()) {
3619 new_class->SetClassFlags(mirror::kClassFlagNoReferenceFields);
3620 } else {
3621 new_class->SetClassFlags(mirror::kClassFlagObjectArray);
3622 }
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003623 mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self);
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00003624 new_class->PopulateEmbeddedVTable(image_pointer_size_);
3625 ImTable* object_imt = java_lang_Object->GetImt(image_pointer_size_);
3626 new_class->SetImt(object_imt, image_pointer_size_);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07003627 mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07003628 // don't need to set new_class->SetObjectSize(..)
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07003629 // because Object::SizeOf delegates to Array::SizeOf
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003630
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003631 // All arrays have java/lang/Cloneable and java/io/Serializable as
3632 // interfaces. We need to set that up here, so that stuff like
3633 // "instanceof" works right.
3634 //
3635 // Note: The GC could run during the call to FindSystemClass,
3636 // so we need to make sure the class object is GC-valid while we're in
3637 // there. Do this by clearing the interface list so the GC will just
3638 // think that the entries are null.
3639
3640
3641 // Use the single, global copies of "interfaces" and "iftable"
3642 // (remember not to free them for arrays).
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003643 {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003644 ObjPtr<mirror::IfTable> array_iftable = array_iftable_.Read();
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07003645 CHECK(array_iftable != nullptr);
3646 new_class->SetIfTable(array_iftable);
3647 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003648
Elliott Hughes00626c22013-06-14 15:04:14 -07003649 // Inherit access flags from the component type.
3650 int access_flags = new_class->GetComponentType()->GetAccessFlags();
3651 // Lose any implementation detail flags; in particular, arrays aren't finalizable.
3652 access_flags &= kAccJavaFlagsMask;
3653 // Arrays can't be used as a superclass or interface, so we want to add "abstract final"
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003654 // and remove "interface".
Elliott Hughes00626c22013-06-14 15:04:14 -07003655 access_flags |= kAccAbstract | kAccFinal;
3656 access_flags &= ~kAccInterface;
3657
3658 new_class->SetAccessFlags(access_flags);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003659
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003660 ObjPtr<mirror::Class> existing = InsertClass(descriptor, new_class.Get(), hash);
Mathieu Chartierc0a9ea42014-02-03 16:36:49 -08003661 if (existing == nullptr) {
Tamas Berghammer160e6df2016-01-05 14:29:02 +00003662 jit::Jit::NewTypeLoadedIfUsingJit(new_class.Get());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003663 return new_class.Get();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003664 }
3665 // Another thread must have loaded the class after we
3666 // started but before we finished. Abandon what we've
3667 // done.
3668 //
3669 // (Yes, this happens.)
3670
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003671 return existing.Ptr();
Brian Carlstroma331b3c2011-07-18 17:47:56 -07003672}
3673
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003674mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
Ian Rogers62f05122014-03-21 11:21:29 -07003675 switch (type) {
3676 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003677 return GetClassRoot(kPrimitiveByte);
Ian Rogers62f05122014-03-21 11:21:29 -07003678 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003679 return GetClassRoot(kPrimitiveChar);
Ian Rogers62f05122014-03-21 11:21:29 -07003680 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003681 return GetClassRoot(kPrimitiveDouble);
Ian Rogers62f05122014-03-21 11:21:29 -07003682 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003683 return GetClassRoot(kPrimitiveFloat);
Ian Rogers62f05122014-03-21 11:21:29 -07003684 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003685 return GetClassRoot(kPrimitiveInt);
Ian Rogers62f05122014-03-21 11:21:29 -07003686 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003687 return GetClassRoot(kPrimitiveLong);
Ian Rogers62f05122014-03-21 11:21:29 -07003688 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003689 return GetClassRoot(kPrimitiveShort);
Ian Rogers62f05122014-03-21 11:21:29 -07003690 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003691 return GetClassRoot(kPrimitiveBoolean);
Ian Rogers62f05122014-03-21 11:21:29 -07003692 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07003693 return GetClassRoot(kPrimitiveVoid);
Ian Rogers62f05122014-03-21 11:21:29 -07003694 default:
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003695 break;
Carl Shapiro744ad052011-08-06 15:53:36 -07003696 }
Elliott Hughesbd935992011-08-22 11:59:34 -07003697 std::string printable_type(PrintableChar(type));
Elliott Hughes4a2b4172011-09-20 17:08:25 -07003698 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003699 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003700}
3701
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003702mirror::Class* ClassLinker::InsertClass(const char* descriptor, ObjPtr<mirror::Class> klass, size_t hash) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08003703 if (VLOG_IS_ON(class_linker)) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003704 ObjPtr<mirror::DexCache> dex_cache = klass->GetDexCache();
Brian Carlstromae826982011-11-09 01:33:42 -08003705 std::string source;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003706 if (dex_cache != nullptr) {
Brian Carlstromae826982011-11-09 01:33:42 -08003707 source += " from ";
3708 source += dex_cache->GetLocation()->ToModifiedUtf8();
3709 }
3710 LOG(INFO) << "Loaded class " << descriptor << source;
3711 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003712 {
3713 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003714 ObjPtr<mirror::ClassLoader> const class_loader = klass->GetClassLoader();
Mathieu Chartier65975772016-08-05 10:46:36 -07003715 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003716 ObjPtr<mirror::Class> existing = class_table->Lookup(descriptor, hash);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003717 if (existing != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003718 return existing.Ptr();
Mathieu Chartier65975772016-08-05 10:46:36 -07003719 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003720 VerifyObject(klass);
3721 class_table->InsertWithHash(klass, hash);
3722 if (class_loader != nullptr) {
3723 // This is necessary because we need to have the card dirtied for remembered sets.
3724 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
3725 }
3726 if (log_new_class_table_roots_) {
3727 new_class_roots_.push_back(GcRoot<mirror::Class>(klass));
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003728 }
3729 }
Mathieu Chartier65975772016-08-05 10:46:36 -07003730 if (kIsDebugBuild) {
3731 // Test that copied methods correctly can find their holder.
3732 for (ArtMethod& method : klass->GetCopiedMethods(image_pointer_size_)) {
3733 CHECK_EQ(GetHoldingClassOfCopiedMethod(&method), klass);
3734 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08003735 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07003736 return nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07003737}
3738
Alex Lighte64300b2015-12-15 15:02:47 -08003739// TODO This should really be in mirror::Class.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003740void ClassLinker::UpdateClassMethods(ObjPtr<mirror::Class> klass,
Alex Lighte64300b2015-12-15 15:02:47 -08003741 LengthPrefixedArray<ArtMethod>* new_methods) {
3742 klass->SetMethodsPtrUnchecked(new_methods,
3743 klass->NumDirectMethods(),
3744 klass->NumDeclaredVirtualMethods());
Mathieu Chartier54d220e2015-07-30 16:20:06 -07003745 // Need to mark the card so that the remembered sets and mod union tables get updated.
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07003746 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003747}
3748
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003749mirror::Class* ClassLinker::LookupClass(Thread* self,
3750 const char* descriptor,
3751 size_t hash,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003752 ObjPtr<mirror::ClassLoader> class_loader) {
Vladimir Marko1a1de672016-10-13 12:53:15 +01003753 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
3754 ClassTable* const class_table = ClassTableForClassLoader(class_loader);
3755 if (class_table != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003756 ObjPtr<mirror::Class> result = class_table->Lookup(descriptor, hash);
Vladimir Marko1a1de672016-10-13 12:53:15 +01003757 if (result != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003758 return result.Ptr();
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003759 }
Sameer Abu Asal2c6de222013-05-02 17:38:59 -07003760 }
Vladimir Marko1a1de672016-10-13 12:53:15 +01003761 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003762}
3763
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003764class MoveClassTableToPreZygoteVisitor : public ClassLoaderVisitor {
3765 public:
3766 explicit MoveClassTableToPreZygoteVisitor() {}
3767
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003768 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003769 REQUIRES(Locks::classlinker_classes_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003770 REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003771 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier6b069532015-08-05 15:08:12 -07003772 if (class_table != nullptr) {
3773 class_table->FreezeSnapshot();
3774 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07003775 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003776};
3777
3778void ClassLinker::MoveClassTableToPreZygote() {
3779 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
3780 boot_class_table_.FreezeSnapshot();
3781 MoveClassTableToPreZygoteVisitor visitor;
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07003782 VisitClassLoaders(&visitor);
Mathieu Chartierc2e20622014-11-03 11:41:47 -08003783}
3784
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003785// Look up classes by hash and descriptor and put all matching ones in the result array.
3786class LookupClassesVisitor : public ClassLoaderVisitor {
3787 public:
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003788 LookupClassesVisitor(const char* descriptor,
3789 size_t hash,
3790 std::vector<ObjPtr<mirror::Class>>* result)
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003791 : descriptor_(descriptor),
3792 hash_(hash),
3793 result_(result) {}
3794
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003795 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003796 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003797 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003798 ObjPtr<mirror::Class> klass = class_table->Lookup(descriptor_, hash_);
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003799 if (klass != nullptr) {
3800 result_->push_back(klass);
3801 }
3802 }
3803
3804 private:
3805 const char* const descriptor_;
3806 const size_t hash_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003807 std::vector<ObjPtr<mirror::Class>>* const result_;
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003808};
3809
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003810void ClassLinker::LookupClasses(const char* descriptor,
3811 std::vector<ObjPtr<mirror::Class>>& result) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07003812 result.clear();
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003813 Thread* const self = Thread::Current();
3814 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003815 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07003816 ObjPtr<mirror::Class> klass = boot_class_table_.Lookup(descriptor, hash);
Mathieu Chartier6b069532015-08-05 15:08:12 -07003817 if (klass != nullptr) {
3818 result.push_back(klass);
3819 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07003820 LookupClassesVisitor visitor(descriptor, hash, &result);
3821 VisitClassLoaders(&visitor);
Elliott Hughes6fa602d2011-12-02 17:54:25 -08003822}
3823
Alex Lightf1f10492015-10-07 16:08:36 -07003824bool ClassLinker::AttemptSupertypeVerification(Thread* self,
3825 Handle<mirror::Class> klass,
3826 Handle<mirror::Class> supertype) {
3827 DCHECK(self != nullptr);
3828 DCHECK(klass.Get() != nullptr);
3829 DCHECK(supertype.Get() != nullptr);
3830
Alex Lightf1f10492015-10-07 16:08:36 -07003831 if (!supertype->IsVerified() && !supertype->IsErroneous()) {
3832 VerifyClass(self, supertype);
3833 }
3834 if (supertype->IsCompileTimeVerified()) {
3835 // Either we are verified or we soft failed and need to retry at runtime.
3836 return true;
3837 }
3838 // If we got this far then we have a hard failure.
3839 std::string error_msg =
3840 StringPrintf("Rejecting class %s that attempts to sub-type erroneous class %s",
David Sehr709b0702016-10-13 09:12:37 -07003841 klass->PrettyDescriptor().c_str(),
3842 supertype->PrettyDescriptor().c_str());
Alex Lightf1f10492015-10-07 16:08:36 -07003843 LOG(WARNING) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003844 StackHandleScope<1> hs(self);
Alex Lightf1f10492015-10-07 16:08:36 -07003845 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
3846 if (cause.Get() != nullptr) {
3847 // Set during VerifyClass call (if at all).
3848 self->ClearException();
3849 }
3850 // Change into a verify error.
3851 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
3852 if (cause.Get() != nullptr) {
3853 self->GetException()->SetCause(cause.Get());
3854 }
3855 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex());
3856 if (Runtime::Current()->IsAotCompiler()) {
3857 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref);
3858 }
Andreas Gampe884f3b82016-03-30 19:52:58 -07003859 // Need to grab the lock to change status.
3860 ObjectLock<mirror::Class> super_lock(self, klass);
Alex Lightf1f10492015-10-07 16:08:36 -07003861 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3862 return false;
3863}
3864
Nicolas Geoffray08025182016-10-25 17:20:18 +01003865verifier::MethodVerifier::FailureKind ClassLinker::VerifyClass(
3866 Thread* self, Handle<mirror::Class> klass, verifier::HardFailLogMode log_level) {
Andreas Gampe884f3b82016-03-30 19:52:58 -07003867 {
3868 // TODO: assert that the monitor on the Class is held
3869 ObjectLock<mirror::Class> lock(self, klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08003870
Andreas Gampe884f3b82016-03-30 19:52:58 -07003871 // Is somebody verifying this now?
3872 mirror::Class::Status old_status = klass->GetStatus();
3873 while (old_status == mirror::Class::kStatusVerifying ||
3874 old_status == mirror::Class::kStatusVerifyingAtRuntime) {
3875 lock.WaitIgnoringInterrupts();
Alex Light06039ba2016-04-04 13:23:14 -07003876 CHECK(klass->IsErroneous() || (klass->GetStatus() > old_status))
David Sehr709b0702016-10-13 09:12:37 -07003877 << "Class '" << klass->PrettyClass()
3878 << "' performed an illegal verification state transition from " << old_status
3879 << " to " << klass->GetStatus();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003880 old_status = klass->GetStatus();
3881 }
jeffhao98eacac2011-09-14 16:11:53 -07003882
Andreas Gampe884f3b82016-03-30 19:52:58 -07003883 // The class might already be erroneous, for example at compile time if we attempted to verify
3884 // this class as a parent to another.
3885 if (klass->IsErroneous()) {
3886 ThrowEarlierClassFailure(klass.Get());
Nicolas Geoffray08025182016-10-25 17:20:18 +01003887 return verifier::MethodVerifier::kHardFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003888 }
Brian Carlstrom9b5ee882012-02-28 09:48:54 -08003889
Andreas Gampe884f3b82016-03-30 19:52:58 -07003890 // Don't attempt to re-verify if already sufficiently verified.
3891 if (klass->IsVerified()) {
3892 EnsureSkipAccessChecksMethods(klass);
Nicolas Geoffray08025182016-10-25 17:20:18 +01003893 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003894 }
3895 if (klass->IsCompileTimeVerified() && Runtime::Current()->IsAotCompiler()) {
Nicolas Geoffray08025182016-10-25 17:20:18 +01003896 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003897 }
jeffhao98eacac2011-09-14 16:11:53 -07003898
Andreas Gampe884f3b82016-03-30 19:52:58 -07003899 if (klass->GetStatus() == mirror::Class::kStatusResolved) {
3900 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifying, self);
3901 } else {
3902 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
David Sehr709b0702016-10-13 09:12:37 -07003903 << klass->PrettyClass();
Andreas Gampe884f3b82016-03-30 19:52:58 -07003904 CHECK(!Runtime::Current()->IsAotCompiler());
3905 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifyingAtRuntime, self);
3906 }
3907
3908 // Skip verification if disabled.
3909 if (!Runtime::Current()->IsVerificationEnabled()) {
3910 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
3911 EnsureSkipAccessChecksMethods(klass);
Nicolas Geoffray08025182016-10-25 17:20:18 +01003912 return verifier::MethodVerifier::kNoFailure;
Andreas Gampe884f3b82016-03-30 19:52:58 -07003913 }
Jeff Hao4a200f52014-04-01 14:58:49 -07003914 }
3915
Ian Rogers9ffb0392012-09-10 11:56:50 -07003916 // Verify super class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003917 StackHandleScope<2> hs(self);
Alex Lightf1f10492015-10-07 16:08:36 -07003918 MutableHandle<mirror::Class> supertype(hs.NewHandle(klass->GetSuperClass()));
3919 // If we have a superclass and we get a hard verification failure we can return immediately.
3920 if (supertype.Get() != nullptr && !AttemptSupertypeVerification(self, klass, supertype)) {
3921 CHECK(self->IsExceptionPending()) << "Verification error should be pending.";
Nicolas Geoffray08025182016-10-25 17:20:18 +01003922 return verifier::MethodVerifier::kHardFailure;
Alex Lightf1f10492015-10-07 16:08:36 -07003923 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08003924
Alex Lightf1f10492015-10-07 16:08:36 -07003925 // Verify all default super-interfaces.
3926 //
3927 // (1) Don't bother if the superclass has already had a soft verification failure.
3928 //
3929 // (2) Interfaces shouldn't bother to do this recursive verification because they cannot cause
3930 // recursive initialization by themselves. This is because when an interface is initialized
3931 // directly it must not initialize its superinterfaces. We are allowed to verify regardless
3932 // but choose not to for an optimization. If the interfaces is being verified due to a class
3933 // initialization (which would need all the default interfaces to be verified) the class code
3934 // will trigger the recursive verification anyway.
3935 if ((supertype.Get() == nullptr || supertype->IsVerified()) // See (1)
3936 && !klass->IsInterface()) { // See (2)
3937 int32_t iftable_count = klass->GetIfTableCount();
3938 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
3939 // Loop through all interfaces this class has defined. It doesn't matter the order.
3940 for (int32_t i = 0; i < iftable_count; i++) {
3941 iface.Assign(klass->GetIfTable()->GetInterface(i));
3942 DCHECK(iface.Get() != nullptr);
3943 // We only care if we have default interfaces and can skip if we are already verified...
3944 if (LIKELY(!iface->HasDefaultMethods() || iface->IsVerified())) {
3945 continue;
3946 } else if (UNLIKELY(!AttemptSupertypeVerification(self, klass, iface))) {
3947 // We had a hard failure while verifying this interface. Just return immediately.
3948 CHECK(self->IsExceptionPending()) << "Verification error should be pending.";
Nicolas Geoffray08025182016-10-25 17:20:18 +01003949 return verifier::MethodVerifier::kHardFailure;
Alex Lightf1f10492015-10-07 16:08:36 -07003950 } else if (UNLIKELY(!iface->IsVerified())) {
3951 // We softly failed to verify the iface. Stop checking and clean up.
3952 // Put the iface into the supertype handle so we know what caused us to fail.
3953 supertype.Assign(iface.Get());
3954 break;
Ian Rogers1c5eb702012-02-01 09:18:34 -08003955 }
Ian Rogers1c5eb702012-02-01 09:18:34 -08003956 }
3957 }
3958
Alex Lightf1f10492015-10-07 16:08:36 -07003959 // At this point if verification failed, then supertype is the "first" supertype that failed
3960 // verification (without a specific order). If verification succeeded, then supertype is either
3961 // null or the original superclass of klass and is verified.
3962 DCHECK(supertype.Get() == nullptr ||
3963 supertype.Get() == klass->GetSuperClass() ||
3964 !supertype->IsVerified());
3965
Elliott Hughes634eb2e2012-03-22 16:06:28 -07003966 // Try to use verification information from the oat file, otherwise do runtime verification.
Ian Rogers4445a7e2012-10-05 17:19:13 -07003967 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003968 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07003969 bool preverified = VerifyClassUsingOatFile(dex_file, klass.Get(), oat_file_class_status);
Andreas Gampeec6e6c12015-11-05 20:39:56 -08003970 // If the oat file says the class had an error, re-run the verifier. That way we will get a
3971 // precise error message. To ensure a rerun, test:
3972 // oat_file_class_status == mirror::Class::kStatusError => !preverified
3973 DCHECK(!(oat_file_class_status == mirror::Class::kStatusError) || !preverified);
3974
Ian Rogers62d6c772013-02-27 08:32:07 -08003975 std::string error_msg;
Nicolas Geoffray08025182016-10-25 17:20:18 +01003976 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
jeffhaof1e6b7c2012-06-05 18:33:30 -07003977 if (!preverified) {
Andreas Gampe53e32d12015-12-09 21:03:23 -08003978 Runtime* runtime = Runtime::Current();
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07003979 verifier_failure = verifier::MethodVerifier::VerifyClass(self,
3980 klass.Get(),
Andreas Gampe53e32d12015-12-09 21:03:23 -08003981 runtime->GetCompilerCallbacks(),
3982 runtime->IsAotCompiler(),
Andreas Gampe7fe30232016-03-25 16:58:00 -07003983 log_level,
Ian Rogers8b2c0b92013-09-19 02:56:49 -07003984 &error_msg);
jeffhaof1e6b7c2012-06-05 18:33:30 -07003985 }
Andreas Gampe884f3b82016-03-30 19:52:58 -07003986
3987 // Verification is done, grab the lock again.
3988 ObjectLock<mirror::Class> lock(self, klass);
3989
jeffhaof1e6b7c2012-06-05 18:33:30 -07003990 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
Ian Rogers529781d2012-07-23 17:24:29 -07003991 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
David Sehr709b0702016-10-13 09:12:37 -07003992 VLOG(class_linker) << "Soft verification failure in class "
3993 << klass->PrettyDescriptor()
3994 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
3995 << " because: " << error_msg;
Ian Rogers529781d2012-07-23 17:24:29 -07003996 }
Ian Rogers1f539342012-10-03 21:09:42 -07003997 self->AssertNoPendingException();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07003998 // Make sure all classes referenced by catch blocks are resolved.
Alex Light5a559862016-01-29 12:24:48 -08003999 ResolveClassExceptionHandlerTypes(klass);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004000 if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
Alex Lightf1f10492015-10-07 16:08:36 -07004001 // Even though there were no verifier failures we need to respect whether the super-class and
4002 // super-default-interfaces were verified or requiring runtime reverification.
4003 if (supertype.Get() == nullptr || supertype->IsVerified()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004004 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004005 } else {
Alex Lightf1f10492015-10-07 16:08:36 -07004006 CHECK_EQ(supertype->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004007 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
Alex Lightf1f10492015-10-07 16:08:36 -07004008 // Pretend a soft failure occurred so that we don't consider the class verified below.
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004009 verifier_failure = verifier::MethodVerifier::kSoftFailure;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004010 }
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004011 } else {
4012 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
4013 // Soft failures at compile time should be retried at runtime. Soft
4014 // failures at runtime will be handled by slow paths in the generated
4015 // code. Set status accordingly.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004016 if (Runtime::Current()->IsAotCompiler()) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004017 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004018 } else {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004019 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
Igor Murashkindf707e42016-02-02 16:56:50 -08004020 // As this is a fake verified status, make sure the methods are _not_ marked
4021 // kAccSkipAccessChecks later.
4022 klass->SetVerificationAttempted();
jeffhaoe4f0b2a2012-08-30 11:18:57 -07004023 }
4024 }
jeffhao5cfd6fb2011-09-27 13:54:29 -07004025 } else {
David Sehr709b0702016-10-13 09:12:37 -07004026 VLOG(verifier) << "Verification failed on class " << klass->PrettyDescriptor()
Andreas Gampeec6e6c12015-11-05 20:39:56 -08004027 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
4028 << " because: " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004029 self->AssertNoPendingException();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004030 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004031 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
jeffhao5cfd6fb2011-09-27 13:54:29 -07004032 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004033 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004034 // Class is verified so we don't need to do any access check on its methods.
Igor Murashkindf707e42016-02-02 16:56:50 -08004035 // Let the interpreter know it by setting the kAccSkipAccessChecks flag onto each
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004036 // method.
4037 // Note: we're going here during compilation and at runtime. When we set the
Igor Murashkindf707e42016-02-02 16:56:50 -08004038 // kAccSkipAccessChecks flag when compiling image classes, the flag is recorded
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004039 // in the image and is set when loading the image.
Igor Murashkindf707e42016-02-02 16:56:50 -08004040
4041 if (UNLIKELY(Runtime::Current()->IsVerificationSoftFail())) {
4042 // Never skip access checks if the verification soft fail is forced.
4043 // Mark the class as having a verification attempt to avoid re-running the verifier.
4044 klass->SetVerificationAttempted();
4045 } else {
4046 EnsureSkipAccessChecksMethods(klass);
4047 }
Andreas Gampe48498592014-09-10 19:48:05 -07004048 }
Nicolas Geoffray08025182016-10-25 17:20:18 +01004049 return verifier_failure;
Andreas Gampe48498592014-09-10 19:48:05 -07004050}
4051
Igor Murashkindf707e42016-02-02 16:56:50 -08004052void ClassLinker::EnsureSkipAccessChecksMethods(Handle<mirror::Class> klass) {
4053 if (!klass->WasVerificationAttempted()) {
4054 klass->SetSkipAccessChecksFlagOnAllMethods(image_pointer_size_);
4055 klass->SetVerificationAttempted();
Sebastien Hertz233ea8e2013-06-06 11:57:09 +02004056 }
jeffhao98eacac2011-09-14 16:11:53 -07004057}
4058
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004059bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004060 ObjPtr<mirror::Class> klass,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004061 mirror::Class::Status& oat_file_class_status) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004062 // If we're compiling, we can only verify the class using the oat file if
4063 // we are not compiling the image or if the class we're verifying is not part of
4064 // the app. In other words, we will only check for preverification of bootclasspath
4065 // classes.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004066 if (Runtime::Current()->IsAotCompiler()) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004067 // Are we compiling the bootclasspath?
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07004068 if (Runtime::Current()->GetCompilerCallbacks()->IsBootImage()) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004069 return false;
4070 }
4071 // We are compiling an app (not the image).
4072
4073 // Is this an app class? (I.e. not a bootclasspath class)
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004074 if (klass->GetClassLoader() != nullptr) {
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004075 return false;
4076 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004077 }
Anwar Ghuloum044d2832013-07-17 15:22:31 -07004078
Richard Uhler07b3c232015-03-31 15:57:54 -07004079 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004080 // In case we run without an image there won't be a backing oat file.
Mathieu Chartier1b868492016-11-16 16:22:37 -08004081 if (oat_dex_file == nullptr || oat_dex_file->GetOatFile() == nullptr) {
Anwar Ghuloumad256bb2013-07-18 14:58:55 -07004082 return false;
4083 }
4084
Andreas Gampe76bd8802014-12-10 16:43:58 -08004085 // We may be running with a preopted oat file but without image. In this case,
Igor Murashkindf707e42016-02-02 16:56:50 -08004086 // we don't skip verification of skip_access_checks classes to ensure we initialize
Andreas Gampe76bd8802014-12-10 16:43:58 -08004087 // dex caches with all types resolved during verification.
4088 // We need to trust image classes, as these might be coming out of a pre-opted, quickened boot
4089 // image (that we just failed loading), and the verifier can't be run on quickened opcodes when
4090 // the runtime isn't started. On the other hand, app classes can be re-verified even if they are
4091 // already pre-opted, as then the runtime is started.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004092 if (!Runtime::Current()->IsAotCompiler() &&
Jeff Haodcdc85b2015-12-04 14:06:18 -08004093 !Runtime::Current()->GetHeap()->HasBootImageSpace() &&
Andreas Gampe76bd8802014-12-10 16:43:58 -08004094 klass->GetClassLoader() != nullptr) {
4095 return false;
4096 }
4097
Ian Rogers8b2c0b92013-09-19 02:56:49 -07004098 uint16_t class_def_index = klass->GetDexClassDefIndex();
Vladimir Markod3c5beb2014-04-11 16:32:51 +01004099 oat_file_class_status = oat_dex_file->GetOatClass(class_def_index).GetStatus();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004100 if (oat_file_class_status == mirror::Class::kStatusVerified ||
4101 oat_file_class_status == mirror::Class::kStatusInitialized) {
Mathieu Chartiera079e3a2016-03-16 19:08:31 -07004102 return true;
4103 }
4104 // If we only verified a subset of the classes at compile time, we can end up with classes that
4105 // were resolved by the verifier.
4106 if (oat_file_class_status == mirror::Class::kStatusResolved) {
4107 return false;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004108 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004109 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
jeffhao1ac29442012-03-26 11:37:32 -07004110 // Compile time verification failed with a soft error. Compile time verification can fail
4111 // because we have incomplete type information. Consider the following:
Ian Rogersc4762272012-02-01 15:55:55 -08004112 // class ... {
4113 // Foo x;
4114 // .... () {
4115 // if (...) {
4116 // v1 gets assigned a type of resolved class Foo
4117 // } else {
4118 // v1 gets assigned a type of unresolved class Bar
4119 // }
4120 // iput x = v1
4121 // } }
4122 // when we merge v1 following the if-the-else it results in Conflict
4123 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be
4124 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as
4125 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk
4126 // at compile time).
4127 return false;
4128 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004129 if (oat_file_class_status == mirror::Class::kStatusError) {
jeffhao1ac29442012-03-26 11:37:32 -07004130 // Compile time verification failed with a hard error. This is caused by invalid instructions
4131 // in the class. These errors are unrecoverable.
4132 return false;
4133 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004134 if (oat_file_class_status == mirror::Class::kStatusNotReady) {
Ian Rogersc4762272012-02-01 15:55:55 -08004135 // Status is uninitialized if we couldn't determine the status at compile time, for example,
4136 // not loading the class.
4137 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
4138 // isn't a problem and this case shouldn't occur
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004139 return false;
4140 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07004141 std::string temp;
Elliott Hughes634eb2e2012-03-22 16:06:28 -07004142 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status
David Sehr709b0702016-10-13 09:12:37 -07004143 << " " << dex_file.GetLocation() << " " << klass->PrettyClass() << " "
Ian Rogers1ff3c982014-08-12 02:30:58 -07004144 << klass->GetDescriptor(&temp);
Ian Rogerse0a02da2014-12-02 14:10:53 -08004145 UNREACHABLE();
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004146}
4147
Alex Light5a559862016-01-29 12:24:48 -08004148void ClassLinker::ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass) {
Alex Light51a64d52015-12-17 13:55:59 -08004149 for (ArtMethod& method : klass->GetMethods(image_pointer_size_)) {
Alex Light5a559862016-01-29 12:24:48 -08004150 ResolveMethodExceptionHandlerTypes(&method);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004151 }
4152}
4153
Alex Light5a559862016-01-29 12:24:48 -08004154void ClassLinker::ResolveMethodExceptionHandlerTypes(ArtMethod* method) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004155 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
Alex Light5a559862016-01-29 12:24:48 -08004156 const DexFile::CodeItem* code_item =
4157 method->GetDexFile()->GetCodeItem(method->GetCodeItemOffset());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004158 if (code_item == nullptr) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004159 return; // native or abstract method
4160 }
4161 if (code_item->tries_size_ == 0) {
4162 return; // nothing to process
4163 }
Ian Rogers13735952014-10-08 12:43:28 -07004164 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004165 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004166 for (uint32_t idx = 0; idx < handlers_size; idx++) {
4167 CatchHandlerIterator iterator(handlers_ptr);
4168 for (; iterator.HasNext(); iterator.Next()) {
4169 // Ensure exception types are resolved so that they don't need resolution to be delivered,
4170 // unresolved exception types will be ignored by exception delivery
Andreas Gampea5b09a62016-11-17 15:21:22 -08004171 if (iterator.GetHandlerTypeIndex().IsValid()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004172 ObjPtr<mirror::Class> exception_type = ResolveType(iterator.GetHandlerTypeIndex(), method);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004173 if (exception_type == nullptr) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08004174 DCHECK(Thread::Current()->IsExceptionPending());
4175 Thread::Current()->ClearException();
4176 }
4177 }
4178 }
4179 handlers_ptr = iterator.EndDataPointer();
4180 }
4181}
4182
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004183mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa,
4184 jstring name,
4185 jobjectArray interfaces,
4186 jobject loader,
4187 jobjectArray methods,
4188 jobjectArray throws) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07004189 Thread* self = soa.Self();
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004190 StackHandleScope<10> hs(self);
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07004191 MutableHandle<mirror::Class> klass(hs.NewHandle(
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004192 AllocClass(self, GetClassRoot(kJavaLangClass), sizeof(mirror::Class))));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004193 if (klass.Get() == nullptr) {
Ian Rogersa436fde2013-08-27 23:34:06 -07004194 CHECK(self->IsExceptionPending()); // OOME.
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004195 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07004196 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004197 DCHECK(klass->GetClass() != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004198 klass->SetObjectSize(sizeof(mirror::Proxy));
Igor Murashkindf707e42016-02-02 16:56:50 -08004199 // Set the class access flags incl. VerificationAttempted, so we do not try to set the flag on
4200 // the methods.
4201 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal | kAccVerificationAttempted);
Mathieu Chartier1a5337f2016-10-13 13:48:23 -07004202 klass->SetClassLoader(soa.Decode<mirror::ClassLoader>(loader));
Ian Rogersc2b44472011-12-14 21:17:17 -08004203 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
Mathieu Chartier1a5337f2016-10-13 13:48:23 -07004204 klass->SetName(soa.Decode<mirror::String>(name));
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004205 klass->SetDexCache(GetClassRoot(kJavaLangReflectProxy)->GetDexCache());
Mathieu Chartier6beced42016-11-15 15:51:31 -08004206 // Object has an empty iftable, copy it for that reason.
4207 klass->SetIfTable(GetClassRoot(kJavaLangObject)->GetIfTable());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004208 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, self);
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004209 std::string descriptor(GetDescriptorForProxy(klass.Get()));
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07004210 const size_t hash = ComputeModifiedUtf8Hash(descriptor.c_str());
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004211
Mathieu Chartierd57d4542015-10-14 10:55:30 -07004212 // Needs to be before we insert the class so that the allocator field is set.
4213 LinearAlloc* const allocator = GetOrCreateAllocatorForClassLoader(klass->GetClassLoader());
4214
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004215 // Insert the class before loading the fields as the field roots
4216 // (ArtField::declaring_class_) are only visited from the class
4217 // table. There can't be any suspend points between inserting the
4218 // class and setting the field arrays below.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004219 ObjPtr<mirror::Class> existing = InsertClass(descriptor.c_str(), klass.Get(), hash);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004220 CHECK(existing == nullptr);
Ian Rogersc2b44472011-12-14 21:17:17 -08004221
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004222 // Instance fields are inherited, but we add a couple of static fields...
Mathieu Chartierc7853442015-03-27 14:35:38 -07004223 const size_t num_fields = 2;
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07004224 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self, allocator, num_fields);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004225 klass->SetSFieldsPtr(sfields);
Mathieu Chartierc7853442015-03-27 14:35:38 -07004226
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004227 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
4228 // our proxy, so Class.getInterfaces doesn't return the flattened set.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004229 ArtField& interfaces_sfield = sfields->At(0);
4230 interfaces_sfield.SetDexFieldIndex(0);
4231 interfaces_sfield.SetDeclaringClass(klass.Get());
4232 interfaces_sfield.SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Mathieu Chartierc7853442015-03-27 14:35:38 -07004233
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004234 // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004235 ArtField& throws_sfield = sfields->At(1);
4236 throws_sfield.SetDexFieldIndex(1);
4237 throws_sfield.SetDeclaringClass(klass.Get());
4238 throws_sfield.SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
Jesse Wilson95caa792011-10-12 18:14:17 -04004239
Ian Rogers466bb252011-10-14 03:29:56 -07004240 // Proxies have 1 direct method, the constructor
Alex Lighte64300b2015-12-15 15:02:47 -08004241 const size_t num_direct_methods = 1;
Jesse Wilson95caa792011-10-12 18:14:17 -04004242
Alex Lighte64300b2015-12-15 15:02:47 -08004243 // They have as many virtual methods as the array
Mathieu Chartier0795f232016-09-27 18:43:30 -07004244 auto h_methods = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Method>>(methods));
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004245 DCHECK_EQ(h_methods->GetClass(), mirror::Method::ArrayClass())
David Sehr709b0702016-10-13 09:12:37 -07004246 << mirror::Class::PrettyClass(h_methods->GetClass());
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004247 const size_t num_virtual_methods = h_methods->GetLength();
Alex Lighte64300b2015-12-15 15:02:47 -08004248
4249 // Create the methods array.
4250 LengthPrefixedArray<ArtMethod>* proxy_class_methods = AllocArtMethodArray(
4251 self, allocator, num_direct_methods + num_virtual_methods);
Mathieu Chartiere401d142015-04-22 13:56:20 -07004252 // Currently AllocArtMethodArray cannot return null, but the OOM logic is left there in case we
4253 // want to throw OOM in the future.
Alex Lighte64300b2015-12-15 15:02:47 -08004254 if (UNLIKELY(proxy_class_methods == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004255 self->AssertPendingOOMException();
4256 return nullptr;
Ian Rogersa436fde2013-08-27 23:34:06 -07004257 }
Alex Lighte64300b2015-12-15 15:02:47 -08004258 klass->SetMethodsPtr(proxy_class_methods, num_direct_methods, num_virtual_methods);
4259
4260 // Create the single direct method.
4261 CreateProxyConstructor(klass, klass->GetDirectMethodUnchecked(0, image_pointer_size_));
4262
4263 // Create virtual method using specified prototypes.
4264 // TODO These should really use the iterators.
Jesse Wilson95caa792011-10-12 18:14:17 -04004265 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004266 auto* virtual_method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
4267 auto* prototype = h_methods->Get(i)->GetArtMethod();
4268 CreateProxyMethod(klass, prototype, virtual_method);
4269 DCHECK(virtual_method->GetDeclaringClass() != nullptr);
4270 DCHECK(prototype->GetDeclaringClass() != nullptr);
Jesse Wilson95caa792011-10-12 18:14:17 -04004271 }
Ian Rogersc2b44472011-12-14 21:17:17 -08004272
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004273 // The super class is java.lang.reflect.Proxy
4274 klass->SetSuperClass(GetClassRoot(kJavaLangReflectProxy));
4275 // Now effectively in the loaded state.
4276 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, self);
Ian Rogers62d6c772013-02-27 08:32:07 -08004277 self->AssertNoPendingException();
Ian Rogersc2b44472011-12-14 21:17:17 -08004278
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004279 MutableHandle<mirror::Class> new_class = hs.NewHandle<mirror::Class>(nullptr);
Ian Rogersc8982582012-09-07 16:53:25 -07004280 {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004281 // Must hold lock on object when resolved.
4282 ObjectLock<mirror::Class> resolution_lock(self, klass);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004283 // Link the fields and virtual methods, creating vtable and iftables.
4284 // The new class will replace the old one in the class table.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004285 Handle<mirror::ObjectArray<mirror::Class>> h_interfaces(
Mathieu Chartier0795f232016-09-27 18:43:30 -07004286 hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces)));
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004287 if (!LinkClass(self, descriptor.c_str(), klass, h_interfaces, &new_class)) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004288 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004289 return nullptr;
Ian Rogers7dfb28c2013-08-22 08:18:36 -07004290 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004291 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004292 CHECK(klass->IsRetired());
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004293 CHECK_NE(klass.Get(), new_class.Get());
4294 klass.Assign(new_class.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004295
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004296 CHECK_EQ(interfaces_sfield.GetDeclaringClass(), klass.Get());
Mathieu Chartier0795f232016-09-27 18:43:30 -07004297 interfaces_sfield.SetObject<false>(
4298 klass.Get(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004299 soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces));
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004300 CHECK_EQ(throws_sfield.GetDeclaringClass(), klass.Get());
4301 throws_sfield.SetObject<false>(
Mathieu Chartier0795f232016-09-27 18:43:30 -07004302 klass.Get(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004303 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>>(throws));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07004304
4305 {
4306 // Lock on klass is released. Lock new class object.
4307 ObjectLock<mirror::Class> initialization_lock(self, klass);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004308 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
Ian Rogersc8982582012-09-07 16:53:25 -07004309 }
Ian Rogersc2b44472011-12-14 21:17:17 -08004310
4311 // sanity checks
Elliott Hughes67d92002012-03-26 15:08:51 -07004312 if (kIsDebugBuild) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07004313 CHECK(klass->GetIFieldsPtr() == nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07004314 CheckProxyConstructor(klass->GetDirectMethod(0, image_pointer_size_));
4315
Ian Rogersc2b44472011-12-14 21:17:17 -08004316 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004317 auto* virtual_method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
4318 auto* prototype = h_methods->Get(i++)->GetArtMethod();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004319 CheckProxyMethod(virtual_method, prototype);
Ian Rogersc2b44472011-12-14 21:17:17 -08004320 }
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004321
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004322 StackHandleScope<1> hs2(self);
Mathieu Chartier0795f232016-09-27 18:43:30 -07004323 Handle<mirror::String> decoded_name = hs2.NewHandle(soa.Decode<mirror::String>(name));
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004324 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces",
Mathieu Chartier590fee92013-09-13 13:46:47 -07004325 decoded_name->ToModifiedUtf8().c_str()));
David Sehr709b0702016-10-13 09:12:37 -07004326 CHECK_EQ(ArtField::PrettyField(klass->GetStaticField(0)), interfaces_field_name);
Elliott Hughes2ed52c42012-03-21 16:56:56 -07004327
4328 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws",
Mathieu Chartier590fee92013-09-13 13:46:47 -07004329 decoded_name->ToModifiedUtf8().c_str()));
David Sehr709b0702016-10-13 09:12:37 -07004330 CHECK_EQ(ArtField::PrettyField(klass->GetStaticField(1)), throws_field_name);
Ian Rogersc2b44472011-12-14 21:17:17 -08004331
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004332 CHECK_EQ(klass.Get()->GetInterfaces(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004333 soa.Decode<mirror::ObjectArray<mirror::Class>>(interfaces));
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004334 CHECK_EQ(klass.Get()->GetThrows(),
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07004335 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>>(throws));
Ian Rogersc2b44472011-12-14 21:17:17 -08004336 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004337 return klass.Get();
Jesse Wilson95caa792011-10-12 18:14:17 -04004338}
4339
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004340std::string ClassLinker::GetDescriptorForProxy(ObjPtr<mirror::Class> proxy_class) {
Nicolas Geoffraya7a47592015-11-24 09:17:30 +00004341 DCHECK(proxy_class->IsProxyClass());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004342 ObjPtr<mirror::String> name = proxy_class->GetName();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004343 DCHECK(name != nullptr);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004344 return DotToDescriptor(name->ToModifiedUtf8().c_str());
4345}
4346
Mathieu Chartiere401d142015-04-22 13:56:20 -07004347void ClassLinker::CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out) {
4348 // Create constructor for Proxy that must initialize the method.
Igor Murashkine3d4ff52016-02-02 10:46:42 -08004349 CHECK_EQ(GetClassRoot(kJavaLangReflectProxy)->NumDirectMethods(), 18u);
Mathieu Chartiere401d142015-04-22 13:56:20 -07004350 ArtMethod* proxy_constructor = GetClassRoot(kJavaLangReflectProxy)->GetDirectMethodUnchecked(
4351 2, image_pointer_size_);
Igor Murashkine3d4ff52016-02-02 10:46:42 -08004352 DCHECK_EQ(std::string(proxy_constructor->GetName()), "<init>");
Sebastien Hertzae94e352014-08-27 15:32:56 +02004353 // Ensure constructor is in dex cache so that we can use the dex cache to look up the overridden
4354 // constructor method.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07004355 GetClassRoot(kJavaLangReflectProxy)->GetDexCache()->SetResolvedMethod(
Mathieu Chartiere401d142015-04-22 13:56:20 -07004356 proxy_constructor->GetDexMethodIndex(), proxy_constructor, image_pointer_size_);
Jeff Haodb8a6642014-08-14 17:18:52 -07004357 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
4358 // code_ too)
Mathieu Chartiere401d142015-04-22 13:56:20 -07004359 DCHECK(out != nullptr);
4360 out->CopyFrom(proxy_constructor, image_pointer_size_);
Ian Rogers466bb252011-10-14 03:29:56 -07004361 // Make this constructor public and fix the class to be our Proxy version
Mathieu Chartiere401d142015-04-22 13:56:20 -07004362 out->SetAccessFlags((out->GetAccessFlags() & ~kAccProtected) | kAccPublic);
4363 out->SetDeclaringClass(klass.Get());
Ian Rogersc2b44472011-12-14 21:17:17 -08004364}
4365
Mathieu Chartiere401d142015-04-22 13:56:20 -07004366void ClassLinker::CheckProxyConstructor(ArtMethod* constructor) const {
Ian Rogers466bb252011-10-14 03:29:56 -07004367 CHECK(constructor->IsConstructor());
Mathieu Chartiere401d142015-04-22 13:56:20 -07004368 auto* np = constructor->GetInterfaceMethodIfProxy(image_pointer_size_);
4369 CHECK_STREQ(np->GetName(), "<init>");
4370 CHECK_STREQ(np->GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V");
Ian Rogers466bb252011-10-14 03:29:56 -07004371 DCHECK(constructor->IsPublic());
Jesse Wilson95caa792011-10-12 18:14:17 -04004372}
4373
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004374void ClassLinker::CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004375 ArtMethod* out) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004376 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
4377 // prototype method
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004378 auto* dex_cache = prototype->GetDeclaringClass()->GetDexCache();
4379 // Avoid dirtying the dex cache unless we need to.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004380 if (dex_cache->GetResolvedMethod(prototype->GetDexMethodIndex(), image_pointer_size_) !=
4381 prototype) {
4382 dex_cache->SetResolvedMethod(
4383 prototype->GetDexMethodIndex(), prototype, image_pointer_size_);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07004384 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004385 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
Ian Rogers466bb252011-10-14 03:29:56 -07004386 // as necessary
Mathieu Chartiere401d142015-04-22 13:56:20 -07004387 DCHECK(out != nullptr);
4388 out->CopyFrom(prototype, image_pointer_size_);
Ian Rogers466bb252011-10-14 03:29:56 -07004389
Alex Lighte9dd04f2016-03-16 16:09:45 -07004390 // Set class to be the concrete proxy class.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004391 out->SetDeclaringClass(klass.Get());
Alex Lighte9dd04f2016-03-16 16:09:45 -07004392 // Clear the abstract, default and conflict flags to ensure that defaults aren't picked in
4393 // preference to the invocation handler.
4394 const uint32_t kRemoveFlags = kAccAbstract | kAccDefault | kAccDefaultConflict;
4395 // Make the method final.
4396 const uint32_t kAddFlags = kAccFinal;
4397 out->SetAccessFlags((out->GetAccessFlags() & ~kRemoveFlags) | kAddFlags);
4398
4399 // Clear the dex_code_item_offset_. It needs to be 0 since proxy methods have no CodeItems but the
4400 // method they copy might (if it's a default method).
4401 out->SetCodeItemOffset(0);
Jesse Wilson95caa792011-10-12 18:14:17 -04004402
Ian Rogers466bb252011-10-14 03:29:56 -07004403 // At runtime the method looks like a reference and argument saving method, clone the code
4404 // related parameters from this method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004405 out->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler());
Ian Rogersc2b44472011-12-14 21:17:17 -08004406}
Jesse Wilson95caa792011-10-12 18:14:17 -04004407
Mathieu Chartiere401d142015-04-22 13:56:20 -07004408void ClassLinker::CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const {
Ian Rogers466bb252011-10-14 03:29:56 -07004409 // Basic sanity
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004410 CHECK(!prototype->IsFinal());
4411 CHECK(method->IsFinal());
Alex Light9139e002015-10-09 15:59:48 -07004412 CHECK(method->IsInvokable());
Ian Rogers19846512012-02-24 11:42:47 -08004413
4414 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its
4415 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself.
Vladimir Marko05792b92015-08-03 11:56:49 +01004416 CHECK(prototype->HasSameDexCacheResolvedMethods(method, image_pointer_size_));
4417 CHECK(prototype->HasSameDexCacheResolvedTypes(method, image_pointer_size_));
Mathieu Chartiere401d142015-04-22 13:56:20 -07004418 auto* np = method->GetInterfaceMethodIfProxy(image_pointer_size_);
4419 CHECK_EQ(prototype->GetDeclaringClass()->GetDexCache(), np->GetDexCache());
Ian Rogers19846512012-02-24 11:42:47 -08004420 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex());
4421
Mathieu Chartiere401d142015-04-22 13:56:20 -07004422 CHECK_STREQ(np->GetName(), prototype->GetName());
4423 CHECK_STREQ(np->GetShorty(), prototype->GetShorty());
Ian Rogers466bb252011-10-14 03:29:56 -07004424 // More complex sanity - via dex cache
Vladimir Marko05792b92015-08-03 11:56:49 +01004425 CHECK_EQ(np->GetReturnType(true /* resolve */, image_pointer_size_),
4426 prototype->GetReturnType(true /* resolve */, image_pointer_size_));
Jesse Wilson95caa792011-10-12 18:14:17 -04004427}
4428
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004429bool ClassLinker::CanWeInitializeClass(ObjPtr<mirror::Class> klass, bool can_init_statics,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004430 bool can_init_parents) {
Brian Carlstrom610e49f2013-11-04 17:07:22 -08004431 if (can_init_statics && can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004432 return true;
4433 }
4434 if (!can_init_statics) {
4435 // Check if there's a class initializer.
Mathieu Chartiere401d142015-04-22 13:56:20 -07004436 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004437 if (clinit != nullptr) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004438 return false;
4439 }
4440 // Check if there are encoded static values needing initialization.
4441 if (klass->NumStaticFields() != 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004442 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004443 DCHECK(dex_class_def != nullptr);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004444 if (dex_class_def->static_values_off_ != 0) {
4445 return false;
4446 }
4447 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004448 // If we are a class we need to initialize all interfaces with default methods when we are
4449 // initialized. Check all of them.
4450 if (!klass->IsInterface()) {
4451 size_t num_interfaces = klass->GetIfTableCount();
4452 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004453 ObjPtr<mirror::Class> iface = klass->GetIfTable()->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07004454 if (iface->HasDefaultMethods() &&
4455 !CanWeInitializeClass(iface, can_init_statics, can_init_parents)) {
4456 return false;
4457 }
4458 }
4459 }
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004460 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07004461 if (klass->IsInterface() || !klass->HasSuperClass()) {
4462 return true;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004463 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004464 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Mathieu Chartiere401d142015-04-22 13:56:20 -07004465 if (!can_init_parents && !super_class->IsInitialized()) {
4466 return false;
4467 }
4468 return CanWeInitializeClass(super_class, can_init_statics, can_init_parents);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004469}
4470
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004471bool ClassLinker::InitializeClass(Thread* self, Handle<mirror::Class> klass,
4472 bool can_init_statics, bool can_init_parents) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004473 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
4474
4475 // Are we already initialized and therefore done?
4476 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
4477 // an initialized class will never change its state.
4478 if (klass->IsInitialized()) {
4479 return true;
4480 }
4481
4482 // Fast fail if initialization requires a full runtime. Not part of the JLS.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004483 if (!CanWeInitializeClass(klass.Get(), can_init_statics, can_init_parents)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004484 return false;
4485 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004486
Ian Rogers7b078e82014-09-10 14:44:24 -07004487 self->AllowThreadSuspension();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004488 uint64_t t0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004489 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004490 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004491
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004492 // Re-check under the lock in case another thread initialized ahead of us.
4493 if (klass->IsInitialized()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004494 return true;
4495 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004496
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004497 // Was the class already found to be erroneous? Done under the lock to match the JLS.
Brian Carlstromd1422f82011-09-28 11:37:09 -07004498 if (klass->IsErroneous()) {
Andreas Gampecb086952015-11-02 16:20:00 -08004499 ThrowEarlierClassFailure(klass.Get(), true);
Brian Carlstromb23eab12014-10-08 17:55:21 -07004500 VlogClassInitializationFailure(klass);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004501 return false;
4502 }
4503
David Sehr709b0702016-10-13 09:12:37 -07004504 CHECK(klass->IsResolved()) << klass->PrettyClass() << ": state=" << klass->GetStatus();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004505
4506 if (!klass->IsVerified()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004507 VerifyClass(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004508 if (!klass->IsVerified()) {
4509 // We failed to verify, expect either the klass to be erroneous or verification failed at
4510 // compile time.
4511 if (klass->IsErroneous()) {
Andreas Gampefc49fa02016-04-21 12:21:55 -07004512 // The class is erroneous. This may be a verifier error, or another thread attempted
4513 // verification and/or initialization and failed. We can distinguish those cases by
4514 // whether an exception is already pending.
4515 if (self->IsExceptionPending()) {
4516 // Check that it's a VerifyError.
4517 DCHECK_EQ("java.lang.Class<java.lang.VerifyError>",
David Sehr709b0702016-10-13 09:12:37 -07004518 mirror::Class::PrettyClass(self->GetException()->GetClass()));
Andreas Gampefc49fa02016-04-21 12:21:55 -07004519 } else {
4520 // Check that another thread attempted initialization.
4521 DCHECK_NE(0, klass->GetClinitThreadId());
4522 DCHECK_NE(self->GetTid(), klass->GetClinitThreadId());
4523 // Need to rethrow the previous failure now.
4524 ThrowEarlierClassFailure(klass.Get(), true);
4525 }
Brian Carlstromb23eab12014-10-08 17:55:21 -07004526 VlogClassInitializationFailure(klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004527 } else {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004528 CHECK(Runtime::Current()->IsAotCompiler());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004529 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
jeffhaoa9b3bf42012-06-06 17:18:39 -07004530 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004531 return false;
Mathieu Chartier524507a2014-08-27 15:28:28 -07004532 } else {
4533 self->AssertNoPendingException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004534 }
Andreas Gampefc49fa02016-04-21 12:21:55 -07004535
4536 // A separate thread could have moved us all the way to initialized. A "simple" example
4537 // involves a subclass of the current class being initialized at the same time (which
4538 // will implicitly initialize the superclass, if scheduled that way). b/28254258
4539 DCHECK_NE(mirror::Class::kStatusError, klass->GetStatus());
4540 if (klass->IsInitialized()) {
4541 return true;
4542 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004543 }
4544
Brian Carlstromd1422f82011-09-28 11:37:09 -07004545 // If the class is kStatusInitializing, either this thread is
4546 // initializing higher up the stack or another thread has beat us
4547 // to initializing and we need to wait. Either way, this
4548 // invocation of InitializeClass will not be responsible for
4549 // running <clinit> and will return.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004550 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Mathieu Chartier524507a2014-08-27 15:28:28 -07004551 // Could have got an exception during verification.
4552 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004553 VlogClassInitializationFailure(klass);
Mathieu Chartier524507a2014-08-27 15:28:28 -07004554 return false;
4555 }
Elliott Hughes005ab2e2011-09-11 17:15:31 -07004556 // We caught somebody else in the act; was it us?
Elliott Hughesdcc24742011-09-07 14:02:44 -07004557 if (klass->GetClinitThreadId() == self->GetTid()) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004558 // Yes. That's fine. Return so we can continue initializing.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004559 return true;
4560 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07004561 // No. That's fine. Wait for another thread to finish initializing.
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004562 return WaitForInitializeClass(klass, self, lock);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004563 }
4564
4565 if (!ValidateSuperClassDescriptors(klass)) {
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004566 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004567 return false;
4568 }
Ian Rogers7b078e82014-09-10 14:44:24 -07004569 self->AllowThreadSuspension();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004570
David Sehr709b0702016-10-13 09:12:37 -07004571 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << klass->PrettyClass()
Andreas Gampe9510ccd2016-04-20 09:55:25 -07004572 << " self.tid=" << self->GetTid() << " clinit.tid=" << klass->GetClinitThreadId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004573
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004574 // From here out other threads may observe that we're initializing and so changes of state
4575 // require the a notification.
Elliott Hughesdcc24742011-09-07 14:02:44 -07004576 klass->SetClinitThreadId(self->GetTid());
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004577 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitializing, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004578
4579 t0 = NanoTime();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004580 }
4581
Brian Carlstrom6d3f72c2013-08-21 18:06:34 -07004582 // Initialize super classes, must be done while initializing for the JLS.
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004583 if (!klass->IsInterface() && klass->HasSuperClass()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004584 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004585 if (!super_class->IsInitialized()) {
4586 CHECK(!super_class->IsInterface());
4587 CHECK(can_init_parents);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004588 StackHandleScope<1> hs(self);
4589 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class));
Ian Rogers7b078e82014-09-10 14:44:24 -07004590 bool super_initialized = InitializeClass(self, handle_scope_super, can_init_statics, true);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004591 if (!super_initialized) {
4592 // The super class was verified ahead of entering initializing, we should only be here if
4593 // the super class became erroneous due to initialization.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004594 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending())
Brian Carlstromf3632832014-05-20 15:36:53 -07004595 << "Super class initialization failed for "
David Sehr709b0702016-10-13 09:12:37 -07004596 << handle_scope_super->PrettyDescriptor()
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004597 << " that has unexpected status " << handle_scope_super->GetStatus()
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004598 << "\nPending exception:\n"
Nicolas Geoffray14691c52015-03-05 10:40:17 +00004599 << (self->GetException() != nullptr ? self->GetException()->Dump() : "");
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004600 ObjectLock<mirror::Class> lock(self, klass);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004601 // Initialization failed because the super-class is erroneous.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004602 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004603 return false;
4604 }
Ian Rogers1bddec32012-02-04 12:27:34 -08004605 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004606 }
4607
Alex Lighteb7c1442015-08-31 13:17:42 -07004608 if (!klass->IsInterface()) {
4609 // Initialize interfaces with default methods for the JLS.
4610 size_t num_direct_interfaces = klass->NumDirectInterfaces();
Alex Light56a40f52015-10-14 11:07:41 -07004611 // Only setup the (expensive) handle scope if we actually need to.
4612 if (UNLIKELY(num_direct_interfaces > 0)) {
Alex Lighteb7c1442015-08-31 13:17:42 -07004613 StackHandleScope<1> hs_iface(self);
Alex Light56a40f52015-10-14 11:07:41 -07004614 MutableHandle<mirror::Class> handle_scope_iface(hs_iface.NewHandle<mirror::Class>(nullptr));
4615 for (size_t i = 0; i < num_direct_interfaces; i++) {
4616 handle_scope_iface.Assign(mirror::Class::GetDirectInterface(self, klass, i));
4617 CHECK(handle_scope_iface.Get() != nullptr);
4618 CHECK(handle_scope_iface->IsInterface());
4619 if (handle_scope_iface->HasBeenRecursivelyInitialized()) {
4620 // We have already done this for this interface. Skip it.
4621 continue;
4622 }
4623 // We cannot just call initialize class directly because we need to ensure that ALL
4624 // interfaces with default methods are initialized. Non-default interface initialization
4625 // will not affect other non-default super-interfaces.
4626 bool iface_initialized = InitializeDefaultInterfaceRecursive(self,
4627 handle_scope_iface,
4628 can_init_statics,
4629 can_init_parents);
4630 if (!iface_initialized) {
4631 ObjectLock<mirror::Class> lock(self, klass);
4632 // Initialization failed because one of our interfaces with default methods is erroneous.
4633 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
4634 return false;
4635 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004636 }
4637 }
4638 }
4639
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004640 const size_t num_static_fields = klass->NumStaticFields();
4641 if (num_static_fields > 0) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07004642 const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07004643 CHECK(dex_class_def != nullptr);
Mathieu Chartierf8322842014-05-16 10:59:25 -07004644 const DexFile& dex_file = klass->GetDexFile();
Hiroshi Yamauchi67ef46a2014-08-21 15:59:43 -07004645 StackHandleScope<3> hs(self);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004646 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
Mathieu Chartierf8322842014-05-16 10:59:25 -07004647 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache()));
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004648
4649 // Eagerly fill in static fields so that the we don't have to do as many expensive
4650 // Class::FindStaticField in ResolveField.
4651 for (size_t i = 0; i < num_static_fields; ++i) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004652 ArtField* field = klass->GetStaticField(i);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004653 const uint32_t field_idx = field->GetDexFieldIndex();
Mathieu Chartierc7853442015-03-27 14:35:38 -07004654 ArtField* resolved_field = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004655 if (resolved_field == nullptr) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004656 dex_cache->SetResolvedField(field_idx, field, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07004657 } else {
4658 DCHECK_EQ(field, resolved_field);
Mathieu Chartier05d89ee2014-10-28 13:57:04 -07004659 }
4660 }
4661
David Sehr9323e6e2016-09-13 08:58:35 -07004662 annotations::RuntimeEncodedStaticFieldValueIterator value_it(dex_file,
4663 &dex_cache,
4664 &class_loader,
4665 this,
4666 *dex_class_def);
Ian Rogers13735952014-10-08 12:43:28 -07004667 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004668 ClassDataItemIterator field_it(dex_file, class_data);
4669 if (value_it.HasNext()) {
4670 DCHECK(field_it.HasNextStaticField());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004671 CHECK(can_init_statics);
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004672 for ( ; value_it.HasNext(); value_it.Next(), field_it.Next()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07004673 ArtField* field = ResolveField(
4674 dex_file, field_it.GetMemberIndex(), dex_cache, class_loader, true);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004675 if (Runtime::Current()->IsActiveTransaction()) {
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004676 value_it.ReadValueToField<true>(field);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004677 } else {
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004678 value_it.ReadValueToField<false>(field);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01004679 }
Mathieu Chartierda595be2016-08-10 13:57:39 -07004680 if (self->IsExceptionPending()) {
4681 break;
4682 }
Hiroshi Yamauchi88500112014-08-22 12:12:56 -07004683 DCHECK(!value_it.HasNext() || field_it.HasNextStaticField());
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004684 }
4685 }
4686 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004687
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004688
Mathieu Chartierda595be2016-08-10 13:57:39 -07004689 if (!self->IsExceptionPending()) {
4690 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_);
4691 if (clinit != nullptr) {
4692 CHECK(can_init_statics);
4693 JValue result;
4694 clinit->Invoke(self, nullptr, 0, &result, "V");
4695 }
4696 }
Ian Rogers7b078e82014-09-10 14:44:24 -07004697 self->AllowThreadSuspension();
Elliott Hughes83df2ac2011-10-11 16:37:54 -07004698 uint64_t t1 = NanoTime();
4699
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004700 bool success = true;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004701 {
Mathieu Chartierdb2633c2014-05-16 09:59:29 -07004702 ObjectLock<mirror::Class> lock(self, klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004703
4704 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004705 WrapExceptionInInitializer(klass);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004706 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004707 success = false;
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01004708 } else if (Runtime::Current()->IsTransactionAborted()) {
4709 // The exception thrown when the transaction aborted has been caught and cleared
4710 // so we need to throw it again now.
David Sehr709b0702016-10-13 09:12:37 -07004711 VLOG(compiler) << "Return from class initializer of "
4712 << mirror::Class::PrettyDescriptor(klass.Get())
Sebastien Hertzbd9cf9f2015-03-03 12:16:13 +01004713 << " without exception while transaction was aborted: re-throw it now.";
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02004714 Runtime::Current()->ThrowTransactionAbortError(self);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004715 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01004716 success = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004717 } else {
Elliott Hughes83df2ac2011-10-11 16:37:54 -07004718 RuntimeStats* global_stats = Runtime::Current()->GetStats();
4719 RuntimeStats* thread_stats = self->GetStats();
4720 ++global_stats->class_init_count;
4721 ++thread_stats->class_init_count;
4722 global_stats->class_init_time_ns += (t1 - t0);
4723 thread_stats->class_init_time_ns += (t1 - t0);
Ian Rogerse6bb3b22013-08-19 21:51:45 -07004724 // Set the class as initialized except if failed to initialize static fields.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004725 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004726 if (VLOG_IS_ON(class_linker)) {
Ian Rogers1ff3c982014-08-12 02:30:58 -07004727 std::string temp;
4728 LOG(INFO) << "Initialized class " << klass->GetDescriptor(&temp) << " from " <<
Mathieu Chartierf8322842014-05-16 10:59:25 -07004729 klass->GetLocation();
Brian Carlstromae826982011-11-09 01:33:42 -08004730 }
Brian Carlstrom073278c2014-02-19 15:21:21 -08004731 // Opportunistically set static method trampolines to their destination.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004732 FixupStaticTrampolines(klass.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004733 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004734 }
Ian Rogersbdfb1a52012-01-12 14:05:22 -08004735 return success;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004736}
4737
Alex Lighteb7c1442015-08-31 13:17:42 -07004738// We recursively run down the tree of interfaces. We need to do this in the order they are declared
4739// and perform the initialization only on those interfaces that contain default methods.
4740bool ClassLinker::InitializeDefaultInterfaceRecursive(Thread* self,
4741 Handle<mirror::Class> iface,
4742 bool can_init_statics,
4743 bool can_init_parents) {
4744 CHECK(iface->IsInterface());
4745 size_t num_direct_ifaces = iface->NumDirectInterfaces();
Alex Light56a40f52015-10-14 11:07:41 -07004746 // Only create the (expensive) handle scope if we need it.
4747 if (UNLIKELY(num_direct_ifaces > 0)) {
4748 StackHandleScope<1> hs(self);
4749 MutableHandle<mirror::Class> handle_super_iface(hs.NewHandle<mirror::Class>(nullptr));
4750 // First we initialize all of iface's super-interfaces recursively.
4751 for (size_t i = 0; i < num_direct_ifaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07004752 ObjPtr<mirror::Class> super_iface = mirror::Class::GetDirectInterface(self, iface, i);
Alex Light56a40f52015-10-14 11:07:41 -07004753 if (!super_iface->HasBeenRecursivelyInitialized()) {
4754 // Recursive step
4755 handle_super_iface.Assign(super_iface);
4756 if (!InitializeDefaultInterfaceRecursive(self,
4757 handle_super_iface,
4758 can_init_statics,
4759 can_init_parents)) {
4760 return false;
4761 }
Alex Lighteb7c1442015-08-31 13:17:42 -07004762 }
4763 }
4764 }
4765
4766 bool result = true;
4767 // Then we initialize 'iface' if it has default methods. We do not need to (and in fact must not)
4768 // initialize if we don't have default methods.
4769 if (iface->HasDefaultMethods()) {
4770 result = EnsureInitialized(self, iface, can_init_statics, can_init_parents);
4771 }
4772
4773 // Mark that this interface has undergone recursive default interface initialization so we know we
4774 // can skip it on any later class initializations. We do this even if we are not a default
4775 // interface since we can still avoid the traversal. This is purely a performance optimization.
4776 if (result) {
4777 // TODO This should be done in a better way
4778 ObjectLock<mirror::Class> lock(self, iface);
4779 iface->SetRecursivelyInitialized();
4780 }
4781 return result;
4782}
4783
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004784bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass,
4785 Thread* self,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004786 ObjectLock<mirror::Class>& lock)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004787 REQUIRES_SHARED(Locks::mutator_lock_) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004788 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004789 self->AssertNoPendingException();
Ian Rogers8f3c9ae2013-08-20 17:26:41 -07004790 CHECK(!klass->IsInitialized());
Igor Murashkinb1d8c312015-08-04 11:18:43 -07004791 lock.WaitIgnoringInterrupts();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004792
4793 // When we wake up, repeat the test for init-in-progress. If
4794 // there's an exception pending (only possible if
Brian Carlstromb23eab12014-10-08 17:55:21 -07004795 // we were not using WaitIgnoringInterrupts), bail out.
Brian Carlstromd1422f82011-09-28 11:37:09 -07004796 if (self->IsExceptionPending()) {
Brian Carlstromb23eab12014-10-08 17:55:21 -07004797 WrapExceptionInInitializer(klass);
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07004798 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004799 return false;
4800 }
4801 // Spurious wakeup? Go back to waiting.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004802 if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
Brian Carlstromd1422f82011-09-28 11:37:09 -07004803 continue;
4804 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08004805 if (klass->GetStatus() == mirror::Class::kStatusVerified &&
4806 Runtime::Current()->IsAotCompiler()) {
Ian Rogers3d1548d2012-09-24 14:08:03 -07004807 // Compile time initialization failed.
4808 return false;
4809 }
Brian Carlstromd1422f82011-09-28 11:37:09 -07004810 if (klass->IsErroneous()) {
4811 // The caller wants an exception, but it was thrown in a
4812 // different thread. Synthesize one here.
Brian Carlstromdf143242011-10-10 18:05:34 -07004813 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread",
David Sehr709b0702016-10-13 09:12:37 -07004814 klass->PrettyDescriptor().c_str());
Brian Carlstromb23eab12014-10-08 17:55:21 -07004815 VlogClassInitializationFailure(klass);
Brian Carlstromd1422f82011-09-28 11:37:09 -07004816 return false;
4817 }
4818 if (klass->IsInitialized()) {
4819 return true;
4820 }
David Sehr709b0702016-10-13 09:12:37 -07004821 LOG(FATAL) << "Unexpected class status. " << klass->PrettyClass() << " is "
Mathieu Chartierc528dba2013-11-26 12:00:11 -08004822 << klass->GetStatus();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004823 }
Ian Rogers07140832014-09-30 15:43:59 -07004824 UNREACHABLE();
Brian Carlstromd1422f82011-09-28 11:37:09 -07004825}
4826
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004827static void ThrowSignatureCheckResolveReturnTypeException(Handle<mirror::Class> klass,
4828 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004829 ArtMethod* method,
4830 ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004831 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004832 DCHECK(Thread::Current()->IsExceptionPending());
4833 DCHECK(!m->IsProxyMethod());
4834 const DexFile* dex_file = m->GetDexFile();
4835 const DexFile::MethodId& method_id = dex_file->GetMethodId(m->GetDexMethodIndex());
4836 const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
Andreas Gampea5b09a62016-11-17 15:21:22 -08004837 dex::TypeIndex return_type_idx = proto_id.return_type_idx_;
David Sehr709b0702016-10-13 09:12:37 -07004838 std::string return_type = dex_file->PrettyType(return_type_idx);
4839 std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004840 ThrowWrappedLinkageError(klass.Get(),
4841 "While checking class %s method %s signature against %s %s: "
4842 "Failed to resolve return type %s with %s",
David Sehr709b0702016-10-13 09:12:37 -07004843 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
4844 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004845 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07004846 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004847 return_type.c_str(), class_loader.c_str());
4848}
4849
4850static void ThrowSignatureCheckResolveArgException(Handle<mirror::Class> klass,
4851 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004852 ArtMethod* method,
4853 ArtMethod* m,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07004854 uint32_t index,
Andreas Gampea5b09a62016-11-17 15:21:22 -08004855 dex::TypeIndex arg_type_idx)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004856 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004857 DCHECK(Thread::Current()->IsExceptionPending());
4858 DCHECK(!m->IsProxyMethod());
4859 const DexFile* dex_file = m->GetDexFile();
David Sehr709b0702016-10-13 09:12:37 -07004860 std::string arg_type = dex_file->PrettyType(arg_type_idx);
4861 std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004862 ThrowWrappedLinkageError(klass.Get(),
4863 "While checking class %s method %s signature against %s %s: "
4864 "Failed to resolve arg %u type %s with %s",
David Sehr709b0702016-10-13 09:12:37 -07004865 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
4866 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004867 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07004868 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004869 index, arg_type.c_str(), class_loader.c_str());
4870}
4871
4872static void ThrowSignatureMismatch(Handle<mirror::Class> klass,
4873 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004874 ArtMethod* method,
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004875 const std::string& error_msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004876 REQUIRES_SHARED(Locks::mutator_lock_) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004877 ThrowLinkageError(klass.Get(),
4878 "Class %s method %s resolves differently in %s %s: %s",
David Sehr709b0702016-10-13 09:12:37 -07004879 mirror::Class::PrettyDescriptor(klass.Get()).c_str(),
4880 ArtMethod::PrettyMethod(method).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004881 super_klass->IsInterface() ? "interface" : "superclass",
David Sehr709b0702016-10-13 09:12:37 -07004882 mirror::Class::PrettyDescriptor(super_klass.Get()).c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004883 error_msg.c_str());
4884}
4885
Ian Rogersb5fb2072014-12-02 17:22:02 -08004886static bool HasSameSignatureWithDifferentClassLoaders(Thread* self,
Andreas Gampe542451c2016-07-26 09:02:02 -07004887 PointerSize pointer_size,
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004888 Handle<mirror::Class> klass,
4889 Handle<mirror::Class> super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004890 ArtMethod* method1,
4891 ArtMethod* method2)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004892 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersb5fb2072014-12-02 17:22:02 -08004893 {
4894 StackHandleScope<1> hs(self);
Vladimir Marko05792b92015-08-03 11:56:49 +01004895 Handle<mirror::Class> return_type(hs.NewHandle(method1->GetReturnType(true /* resolve */,
4896 pointer_size)));
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004897 if (UNLIKELY(return_type.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004898 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method1);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004899 return false;
4900 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004901 ObjPtr<mirror::Class> other_return_type = method2->GetReturnType(true /* resolve */,
Vladimir Marko05792b92015-08-03 11:56:49 +01004902 pointer_size);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004903 if (UNLIKELY(other_return_type == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004904 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method2);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004905 return false;
4906 }
Vladimir Marko862f43c2015-02-10 18:22:57 +00004907 if (UNLIKELY(other_return_type != return_type.Get())) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004908 ThrowSignatureMismatch(klass, super_klass, method1,
4909 StringPrintf("Return types mismatch: %s(%p) vs %s(%p)",
David Sehr709b0702016-10-13 09:12:37 -07004910 return_type->PrettyClassAndClassLoader().c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004911 return_type.Get(),
David Sehr709b0702016-10-13 09:12:37 -07004912 other_return_type->PrettyClassAndClassLoader().c_str(),
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004913 other_return_type.Ptr()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08004914 return false;
4915 }
4916 }
4917 const DexFile::TypeList* types1 = method1->GetParameterTypeList();
4918 const DexFile::TypeList* types2 = method2->GetParameterTypeList();
4919 if (types1 == nullptr) {
Andreas Gamped8ca52e2015-02-13 15:23:18 -08004920 if (types2 != nullptr && types2->Size() != 0) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004921 ThrowSignatureMismatch(klass, super_klass, method1,
4922 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07004923 method2->PrettyMethod(true).c_str()));
Andreas Gamped8ca52e2015-02-13 15:23:18 -08004924 return false;
4925 }
4926 return true;
Ian Rogersb5fb2072014-12-02 17:22:02 -08004927 } else if (UNLIKELY(types2 == nullptr)) {
Andreas Gamped8ca52e2015-02-13 15:23:18 -08004928 if (types1->Size() != 0) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004929 ThrowSignatureMismatch(klass, super_klass, method1,
4930 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07004931 method2->PrettyMethod(true).c_str()));
Andreas Gamped8ca52e2015-02-13 15:23:18 -08004932 return false;
4933 }
4934 return true;
Ian Rogersb5fb2072014-12-02 17:22:02 -08004935 }
4936 uint32_t num_types = types1->Size();
4937 if (UNLIKELY(num_types != types2->Size())) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004938 ThrowSignatureMismatch(klass, super_klass, method1,
4939 StringPrintf("Type list mismatch with %s",
David Sehr709b0702016-10-13 09:12:37 -07004940 method2->PrettyMethod(true).c_str()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08004941 return false;
4942 }
4943 for (uint32_t i = 0; i < num_types; ++i) {
Vladimir Marko862f43c2015-02-10 18:22:57 +00004944 StackHandleScope<1> hs(self);
Andreas Gampea5b09a62016-11-17 15:21:22 -08004945 dex::TypeIndex param_type_idx = types1->GetTypeItem(i).type_idx_;
Vladimir Marko862f43c2015-02-10 18:22:57 +00004946 Handle<mirror::Class> param_type(hs.NewHandle(
Vladimir Marko05792b92015-08-03 11:56:49 +01004947 method1->GetClassFromTypeIndex(param_type_idx, true /* resolve */, pointer_size)));
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004948 if (UNLIKELY(param_type.Get() == nullptr)) {
4949 ThrowSignatureCheckResolveArgException(klass, super_klass, method1,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004950 method1, i, param_type_idx);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004951 return false;
4952 }
Andreas Gampea5b09a62016-11-17 15:21:22 -08004953 dex::TypeIndex other_param_type_idx = types2->GetTypeItem(i).type_idx_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004954 ObjPtr<mirror::Class> other_param_type =
Vladimir Marko05792b92015-08-03 11:56:49 +01004955 method2->GetClassFromTypeIndex(other_param_type_idx, true /* resolve */, pointer_size);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004956 if (UNLIKELY(other_param_type == nullptr)) {
4957 ThrowSignatureCheckResolveArgException(klass, super_klass, method1,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004958 method2, i, other_param_type_idx);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004959 return false;
4960 }
Vladimir Marko862f43c2015-02-10 18:22:57 +00004961 if (UNLIKELY(param_type.Get() != other_param_type)) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004962 ThrowSignatureMismatch(klass, super_klass, method1,
4963 StringPrintf("Parameter %u type mismatch: %s(%p) vs %s(%p)",
4964 i,
David Sehr709b0702016-10-13 09:12:37 -07004965 param_type->PrettyClassAndClassLoader().c_str(),
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004966 param_type.Get(),
David Sehr709b0702016-10-13 09:12:37 -07004967 other_param_type->PrettyClassAndClassLoader().c_str(),
Mathieu Chartier28357fa2016-10-18 16:27:40 -07004968 other_param_type.Ptr()));
Ian Rogersb5fb2072014-12-02 17:22:02 -08004969 return false;
4970 }
4971 }
4972 return true;
4973}
4974
4975
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07004976bool ClassLinker::ValidateSuperClassDescriptors(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004977 if (klass->IsInterface()) {
4978 return true;
4979 }
Ian Rogers151f2212014-05-06 11:27:27 -07004980 // Begin with the methods local to the superclass.
Ian Rogersded66a02014-10-28 18:12:55 -07004981 Thread* self = Thread::Current();
Mathieu Chartiere401d142015-04-22 13:56:20 -07004982 StackHandleScope<1> hs(self);
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004983 MutableHandle<mirror::Class> super_klass(hs.NewHandle<mirror::Class>(nullptr));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004984 if (klass->HasSuperClass() &&
4985 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004986 super_klass.Assign(klass->GetSuperClass());
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004987 for (int i = klass->GetSuperClass()->GetVTableLength() - 1; i >= 0; --i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004988 auto* m = klass->GetVTableEntry(i, image_pointer_size_);
4989 auto* super_m = klass->GetSuperClass()->GetVTableEntry(i, image_pointer_size_);
4990 if (m != super_m) {
Vladimir Marko05792b92015-08-03 11:56:49 +01004991 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self, image_pointer_size_,
4992 klass, super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07004993 m, super_m))) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01004994 self->AssertPendingException();
Andreas Gamped8ca52e2015-02-13 15:23:18 -08004995 return false;
4996 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004997 }
4998 }
4999 }
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07005000 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005001 super_klass.Assign(klass->GetIfTable()->GetInterface(i));
5002 if (klass->GetClassLoader() != super_klass->GetClassLoader()) {
5003 uint32_t num_methods = super_klass->NumVirtualMethods();
Ian Rogers151f2212014-05-06 11:27:27 -07005004 for (uint32_t j = 0; j < num_methods; ++j) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005005 auto* m = klass->GetIfTable()->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>(
5006 j, image_pointer_size_);
5007 auto* super_m = super_klass->GetVirtualMethod(j, image_pointer_size_);
5008 if (m != super_m) {
Vladimir Marko05792b92015-08-03 11:56:49 +01005009 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self, image_pointer_size_,
5010 klass, super_klass,
Mathieu Chartiere401d142015-04-22 13:56:20 -07005011 m, super_m))) {
Vladimir Markod5e5a0e2015-05-08 12:26:59 +01005012 self->AssertPendingException();
Andreas Gamped8ca52e2015-02-13 15:23:18 -08005013 return false;
5014 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005015 }
5016 }
5017 }
5018 }
5019 return true;
5020}
5021
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005022bool ClassLinker::EnsureInitialized(Thread* self,
5023 Handle<mirror::Class> c,
5024 bool can_init_fields,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005025 bool can_init_parents) {
Mathieu Chartier0cd81352014-05-22 16:48:55 -07005026 DCHECK(c.Get() != nullptr);
Mathieu Chartier524507a2014-08-27 15:28:28 -07005027 if (c->IsInitialized()) {
Igor Murashkindf707e42016-02-02 16:56:50 -08005028 EnsureSkipAccessChecksMethods(c);
Mathieu Chartier8502f722016-06-08 15:09:08 -07005029 self->AssertNoPendingException();
Mathieu Chartier524507a2014-08-27 15:28:28 -07005030 return true;
5031 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005032 const bool success = InitializeClass(self, c, can_init_fields, can_init_parents);
Mathieu Chartier524507a2014-08-27 15:28:28 -07005033 if (!success) {
5034 if (can_init_fields && can_init_parents) {
David Sehr709b0702016-10-13 09:12:37 -07005035 CHECK(self->IsExceptionPending()) << c->PrettyClass();
Mathieu Chartier524507a2014-08-27 15:28:28 -07005036 }
5037 } else {
5038 self->AssertNoPendingException();
Ian Rogers595799e2012-01-11 17:32:51 -08005039 }
5040 return success;
Elliott Hughesf4c21c92011-08-19 17:31:31 -07005041}
5042
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005043void ClassLinker::FixupTemporaryDeclaringClass(ObjPtr<mirror::Class> temp_class,
5044 ObjPtr<mirror::Class> new_class) {
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005045 DCHECK_EQ(temp_class->NumInstanceFields(), 0u);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005046 for (ArtField& field : new_class->GetIFields()) {
5047 if (field.GetDeclaringClass() == temp_class) {
5048 field.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005049 }
5050 }
5051
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005052 DCHECK_EQ(temp_class->NumStaticFields(), 0u);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005053 for (ArtField& field : new_class->GetSFields()) {
5054 if (field.GetDeclaringClass() == temp_class) {
5055 field.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005056 }
5057 }
5058
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005059 DCHECK_EQ(temp_class->NumDirectMethods(), 0u);
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005060 DCHECK_EQ(temp_class->NumVirtualMethods(), 0u);
Alex Lighte64300b2015-12-15 15:02:47 -08005061 for (auto& method : new_class->GetMethods(image_pointer_size_)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005062 if (method.GetDeclaringClass() == temp_class) {
5063 method.SetDeclaringClass(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005064 }
5065 }
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005066
5067 // Make sure the remembered set and mod-union tables know that we updated some of the native
5068 // roots.
5069 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(new_class);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005070}
5071
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005072void ClassLinker::RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08005073 CHECK(class_loader->GetAllocator() == nullptr);
5074 CHECK(class_loader->GetClassTable() == nullptr);
5075 Thread* const self = Thread::Current();
5076 ClassLoaderData data;
5077 data.weak_root = self->GetJniEnv()->vm->AddWeakGlobalRef(self, class_loader);
5078 // Create and set the class table.
5079 data.class_table = new ClassTable;
5080 class_loader->SetClassTable(data.class_table);
5081 // Create and set the linear allocator.
5082 data.allocator = Runtime::Current()->CreateLinearAlloc();
5083 class_loader->SetAllocator(data.allocator);
5084 // Add to the list so that we know to free the data later.
5085 class_loaders_.push_back(data);
5086}
5087
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005088ClassTable* ClassLinker::InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07005089 if (class_loader == nullptr) {
5090 return &boot_class_table_;
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005091 }
Mathieu Chartier6b069532015-08-05 15:08:12 -07005092 ClassTable* class_table = class_loader->GetClassTable();
5093 if (class_table == nullptr) {
Mathieu Chartier5b830502016-03-02 10:30:23 -08005094 RegisterClassLoader(class_loader);
5095 class_table = class_loader->GetClassTable();
5096 DCHECK(class_table != nullptr);
Mathieu Chartier6b069532015-08-05 15:08:12 -07005097 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005098 return class_table;
5099}
5100
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005101ClassTable* ClassLinker::ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07005102 return class_loader == nullptr ? &boot_class_table_ : class_loader->GetClassTable();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005103}
5104
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005105static ImTable* FindSuperImt(ObjPtr<mirror::Class> klass, PointerSize pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005106 REQUIRES_SHARED(Locks::mutator_lock_) {
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005107 while (klass->HasSuperClass()) {
5108 klass = klass->GetSuperClass();
5109 if (klass->ShouldHaveImt()) {
5110 return klass->GetImt(pointer_size);
5111 }
5112 }
5113 return nullptr;
5114}
5115
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005116bool ClassLinker::LinkClass(Thread* self,
5117 const char* descriptor,
5118 Handle<mirror::Class> klass,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005119 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005120 MutableHandle<mirror::Class>* h_new_class_out) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005121 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005122
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005123 if (!LinkSuperClass(klass)) {
5124 return false;
5125 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005126 ArtMethod* imt_data[ImTable::kSize];
5127 // If there are any new conflicts compared to super class.
5128 bool new_conflict = false;
5129 std::fill_n(imt_data, arraysize(imt_data), Runtime::Current()->GetImtUnimplementedMethod());
5130 if (!LinkMethods(self, klass, interfaces, &new_conflict, imt_data)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005131 return false;
5132 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005133 if (!LinkInstanceFields(self, klass)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005134 return false;
5135 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005136 size_t class_size;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005137 if (!LinkStaticFields(self, klass, &class_size)) {
Brian Carlstrom4873d462011-08-21 15:23:39 -07005138 return false;
5139 }
5140 CreateReferenceInstanceOffsets(klass);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005141 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005142
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005143 ImTable* imt = nullptr;
5144 if (klass->ShouldHaveImt()) {
5145 // If there are any new conflicts compared to the super class we can not make a copy. There
5146 // can be cases where both will have a conflict method at the same slot without having the same
5147 // set of conflicts. In this case, we can not share the IMT since the conflict table slow path
5148 // will possibly create a table that is incorrect for either of the classes.
5149 // Same IMT with new_conflict does not happen very often.
5150 if (!new_conflict) {
5151 ImTable* super_imt = FindSuperImt(klass.Get(), image_pointer_size_);
5152 if (super_imt != nullptr) {
5153 bool imt_equals = true;
5154 for (size_t i = 0; i < ImTable::kSize && imt_equals; ++i) {
5155 imt_equals = imt_equals && (super_imt->Get(i, image_pointer_size_) == imt_data[i]);
5156 }
5157 if (imt_equals) {
5158 imt = super_imt;
5159 }
5160 }
5161 }
5162 if (imt == nullptr) {
5163 LinearAlloc* allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
5164 imt = reinterpret_cast<ImTable*>(
5165 allocator->Alloc(self, ImTable::SizeInBytes(image_pointer_size_)));
5166 if (imt == nullptr) {
5167 return false;
5168 }
5169 imt->Populate(imt_data, image_pointer_size_);
5170 }
5171 }
5172
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005173 if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) {
5174 // We don't need to retire this class as it has no embedded tables or it was created the
5175 // correct size during class linker initialization.
David Sehr709b0702016-10-13 09:12:37 -07005176 CHECK_EQ(klass->GetClassSize(), class_size) << klass->PrettyDescriptor();
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005177
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005178 if (klass->ShouldHaveEmbeddedVTable()) {
5179 klass->PopulateEmbeddedVTable(image_pointer_size_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005180 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005181 if (klass->ShouldHaveImt()) {
5182 klass->SetImt(imt, image_pointer_size_);
5183 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005184 // This will notify waiters on klass that saw the not yet resolved
5185 // class in the class_table_ during EnsureResolved.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005186 mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005187 h_new_class_out->Assign(klass.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005188 } else {
5189 CHECK(!klass->IsResolved());
5190 // Retire the temporary class and create the correctly sized resolved class.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005191 StackHandleScope<1> hs(self);
Mathieu Chartiere401d142015-04-22 13:56:20 -07005192 auto h_new_class = hs.NewHandle(klass->CopyOf(self, class_size, imt, image_pointer_size_));
Mathieu Chartier3ee25bb2015-08-10 10:13:02 -07005193 // Set arrays to null since we don't want to have multiple classes with the same ArtField or
5194 // ArtMethod array pointers. If this occurs, it causes bugs in remembered sets since the GC
5195 // may not see any references to the target space and clean the card for a class if another
5196 // class had the same array pointer.
Alex Lighte64300b2015-12-15 15:02:47 -08005197 klass->SetMethodsPtrUnchecked(nullptr, 0, 0);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07005198 klass->SetSFieldsPtrUnchecked(nullptr);
5199 klass->SetIFieldsPtrUnchecked(nullptr);
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005200 if (UNLIKELY(h_new_class.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005201 self->AssertPendingOOMException();
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005202 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005203 return false;
5204 }
5205
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005206 CHECK_EQ(h_new_class->GetClassSize(), class_size);
5207 ObjectLock<mirror::Class> lock(self, h_new_class);
5208 FixupTemporaryDeclaringClass(klass.Get(), h_new_class.Get());
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005209
5210 {
Mathieu Chartiereb837eb2015-07-29 17:25:41 -07005211 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005212 ObjPtr<mirror::ClassLoader> const class_loader = h_new_class.Get()->GetClassLoader();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005213 ClassTable* const table = InsertClassTableForClassLoader(class_loader);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005214 ObjPtr<mirror::Class> existing = table->UpdateClass(descriptor, h_new_class.Get(),
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005215 ComputeModifiedUtf8Hash(descriptor));
Mathieu Chartier05aa4d32015-09-19 12:44:38 -07005216 if (class_loader != nullptr) {
5217 // We updated the class in the class table, perform the write barrier so that the GC knows
5218 // about the change.
5219 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
5220 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005221 CHECK_EQ(existing, klass.Get());
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07005222 if (log_new_class_table_roots_) {
5223 new_class_roots_.push_back(GcRoot<mirror::Class>(h_new_class.Get()));
5224 }
5225 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005226
5227 // This will notify waiters on temp class that saw the not yet resolved class in the
5228 // class_table_ during EnsureResolved.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005229 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetired, self);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005230
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005231 CHECK_EQ(h_new_class->GetStatus(), mirror::Class::kStatusResolving);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005232 // This will notify waiters on new_class that saw the not yet resolved
5233 // class in the class_table_ during EnsureResolved.
Hiroshi Yamauchi679b1cf2015-05-21 12:05:27 -07005234 mirror::Class::SetStatus(h_new_class, mirror::Class::kStatusResolved, self);
5235 // Return the new class.
5236 h_new_class_out->Assign(h_new_class.Get());
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005237 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005238 return true;
5239}
5240
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005241static void CountMethodsAndFields(ClassDataItemIterator& dex_data,
5242 size_t* virtual_methods,
5243 size_t* direct_methods,
5244 size_t* static_fields,
5245 size_t* instance_fields) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005246 *virtual_methods = *direct_methods = *static_fields = *instance_fields = 0;
5247
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005248 while (dex_data.HasNextStaticField()) {
5249 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005250 (*static_fields)++;
5251 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005252 while (dex_data.HasNextInstanceField()) {
5253 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005254 (*instance_fields)++;
5255 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005256 while (dex_data.HasNextDirectMethod()) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005257 (*direct_methods)++;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005258 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005259 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005260 while (dex_data.HasNextVirtualMethod()) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005261 (*virtual_methods)++;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005262 dex_data.Next();
Andreas Gampefd9eb392014-11-06 16:52:58 -08005263 }
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005264 DCHECK(!dex_data.HasNext());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005265}
5266
5267static void DumpClass(std::ostream& os,
5268 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
5269 const char* suffix) {
5270 ClassDataItemIterator dex_data(dex_file, dex_file.GetClassData(dex_class_def));
5271 os << dex_file.GetClassDescriptor(dex_class_def) << suffix << ":\n";
5272 os << " Static fields:\n";
5273 while (dex_data.HasNextStaticField()) {
5274 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex());
5275 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n";
5276 dex_data.Next();
5277 }
5278 os << " Instance fields:\n";
5279 while (dex_data.HasNextInstanceField()) {
5280 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex());
5281 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n";
5282 dex_data.Next();
5283 }
5284 os << " Direct methods:\n";
5285 while (dex_data.HasNextDirectMethod()) {
5286 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex());
5287 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n";
5288 dex_data.Next();
5289 }
5290 os << " Virtual methods:\n";
5291 while (dex_data.HasNextVirtualMethod()) {
5292 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex());
5293 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n";
5294 dex_data.Next();
5295 }
5296}
5297
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005298static std::string DumpClasses(const DexFile& dex_file1,
5299 const DexFile::ClassDef& dex_class_def1,
5300 const DexFile& dex_file2,
5301 const DexFile::ClassDef& dex_class_def2) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005302 std::ostringstream os;
5303 DumpClass(os, dex_file1, dex_class_def1, " (Compile time)");
5304 DumpClass(os, dex_file2, dex_class_def2, " (Runtime)");
5305 return os.str();
5306}
5307
5308
5309// Very simple structural check on whether the classes match. Only compares the number of
5310// methods and fields.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005311static bool SimpleStructuralCheck(const DexFile& dex_file1,
5312 const DexFile::ClassDef& dex_class_def1,
5313 const DexFile& dex_file2,
5314 const DexFile::ClassDef& dex_class_def2,
Andreas Gampefd9eb392014-11-06 16:52:58 -08005315 std::string* error_msg) {
5316 ClassDataItemIterator dex_data1(dex_file1, dex_file1.GetClassData(dex_class_def1));
5317 ClassDataItemIterator dex_data2(dex_file2, dex_file2.GetClassData(dex_class_def2));
5318
5319 // Counters for current dex file.
5320 size_t dex_virtual_methods1, dex_direct_methods1, dex_static_fields1, dex_instance_fields1;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005321 CountMethodsAndFields(dex_data1,
5322 &dex_virtual_methods1,
5323 &dex_direct_methods1,
5324 &dex_static_fields1,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005325 &dex_instance_fields1);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005326 // Counters for compile-time dex file.
5327 size_t dex_virtual_methods2, dex_direct_methods2, dex_static_fields2, dex_instance_fields2;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005328 CountMethodsAndFields(dex_data2,
5329 &dex_virtual_methods2,
5330 &dex_direct_methods2,
5331 &dex_static_fields2,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005332 &dex_instance_fields2);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005333
5334 if (dex_virtual_methods1 != dex_virtual_methods2) {
5335 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005336 *error_msg = StringPrintf("Virtual method count off: %zu vs %zu\n%s",
5337 dex_virtual_methods1,
5338 dex_virtual_methods2,
5339 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005340 return false;
5341 }
5342 if (dex_direct_methods1 != dex_direct_methods2) {
5343 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005344 *error_msg = StringPrintf("Direct method count off: %zu vs %zu\n%s",
5345 dex_direct_methods1,
5346 dex_direct_methods2,
5347 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005348 return false;
5349 }
5350 if (dex_static_fields1 != dex_static_fields2) {
5351 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005352 *error_msg = StringPrintf("Static field count off: %zu vs %zu\n%s",
5353 dex_static_fields1,
5354 dex_static_fields2,
5355 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005356 return false;
5357 }
5358 if (dex_instance_fields1 != dex_instance_fields2) {
5359 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2);
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005360 *error_msg = StringPrintf("Instance field count off: %zu vs %zu\n%s",
5361 dex_instance_fields1,
5362 dex_instance_fields2,
5363 class_dump.c_str());
Andreas Gampefd9eb392014-11-06 16:52:58 -08005364 return false;
5365 }
5366
5367 return true;
5368}
5369
5370// Checks whether a the super-class changed from what we had at compile-time. This would
5371// invalidate quickening.
5372static bool CheckSuperClassChange(Handle<mirror::Class> klass,
5373 const DexFile& dex_file,
5374 const DexFile::ClassDef& class_def,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005375 ObjPtr<mirror::Class> super_class)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005376 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampefd9eb392014-11-06 16:52:58 -08005377 // Check for unexpected changes in the superclass.
5378 // Quick check 1) is the super_class class-loader the boot class loader? This always has
5379 // precedence.
5380 if (super_class->GetClassLoader() != nullptr &&
5381 // Quick check 2) different dex cache? Breaks can only occur for different dex files,
5382 // which is implied by different dex cache.
5383 klass->GetDexCache() != super_class->GetDexCache()) {
5384 // Now comes the expensive part: things can be broken if (a) the klass' dex file has a
5385 // definition for the super-class, and (b) the files are in separate oat files. The oat files
5386 // are referenced from the dex file, so do (b) first. Only relevant if we have oat files.
Richard Uhler07b3c232015-03-31 15:57:54 -07005387 const OatDexFile* class_oat_dex_file = dex_file.GetOatDexFile();
5388 const OatFile* class_oat_file = nullptr;
5389 if (class_oat_dex_file != nullptr) {
5390 class_oat_file = class_oat_dex_file->GetOatFile();
5391 }
5392
Andreas Gampefd9eb392014-11-06 16:52:58 -08005393 if (class_oat_file != nullptr) {
Richard Uhler07b3c232015-03-31 15:57:54 -07005394 const OatDexFile* loaded_super_oat_dex_file = super_class->GetDexFile().GetOatDexFile();
5395 const OatFile* loaded_super_oat_file = nullptr;
5396 if (loaded_super_oat_dex_file != nullptr) {
5397 loaded_super_oat_file = loaded_super_oat_dex_file->GetOatFile();
5398 }
5399
Andreas Gampefd9eb392014-11-06 16:52:58 -08005400 if (loaded_super_oat_file != nullptr && class_oat_file != loaded_super_oat_file) {
5401 // Now check (a).
5402 const DexFile::ClassDef* super_class_def = dex_file.FindClassDef(class_def.superclass_idx_);
5403 if (super_class_def != nullptr) {
5404 // Uh-oh, we found something. Do our check.
5405 std::string error_msg;
5406 if (!SimpleStructuralCheck(dex_file, *super_class_def,
5407 super_class->GetDexFile(), *super_class->GetClassDef(),
5408 &error_msg)) {
5409 // Print a warning to the log. This exception might be caught, e.g., as common in test
5410 // drivers. When the class is later tried to be used, we re-throw a new instance, as we
5411 // only save the type of the exception.
5412 LOG(WARNING) << "Incompatible structural change detected: " <<
5413 StringPrintf(
5414 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
David Sehr709b0702016-10-13 09:12:37 -07005415 dex_file.PrettyType(super_class_def->class_idx_).c_str(),
Andreas Gampefd9eb392014-11-06 16:52:58 -08005416 class_oat_file->GetLocation().c_str(),
5417 loaded_super_oat_file->GetLocation().c_str(),
5418 error_msg.c_str());
5419 ThrowIncompatibleClassChangeError(klass.Get(),
5420 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s",
David Sehr709b0702016-10-13 09:12:37 -07005421 dex_file.PrettyType(super_class_def->class_idx_).c_str(),
Andreas Gampefd9eb392014-11-06 16:52:58 -08005422 class_oat_file->GetLocation().c_str(),
5423 loaded_super_oat_file->GetLocation().c_str(),
5424 error_msg.c_str());
5425 return false;
5426 }
5427 }
5428 }
5429 }
5430 }
5431 return true;
5432}
5433
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005434bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08005435 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
Ian Rogers8b2c0b92013-09-19 02:56:49 -07005436 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
Andreas Gampea5b09a62016-11-17 15:21:22 -08005437 dex::TypeIndex super_class_idx = class_def.superclass_idx_;
5438 if (super_class_idx.IsValid()) {
Roland Levillain90328ac2016-05-18 12:25:38 +01005439 // Check that a class does not inherit from itself directly.
5440 //
5441 // TODO: This is a cheap check to detect the straightforward case
5442 // of a class extending itself (b/28685551), but we should do a
5443 // proper cycle detection on loaded classes, to detect all cases
5444 // of class circularity errors (b/28830038).
5445 if (super_class_idx == class_def.class_idx_) {
5446 ThrowClassCircularityError(klass.Get(),
5447 "Class %s extends itself",
David Sehr709b0702016-10-13 09:12:37 -07005448 klass->PrettyDescriptor().c_str());
Roland Levillain90328ac2016-05-18 12:25:38 +01005449 return false;
5450 }
5451
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005452 ObjPtr<mirror::Class> super_class = ResolveType(dex_file, super_class_idx, klass.Get());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005453 if (super_class == nullptr) {
Brian Carlstrom65ca0772011-09-24 16:03:08 -07005454 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005455 return false;
5456 }
Ian Rogersbe125a92012-01-11 15:19:49 -08005457 // Verify
5458 if (!klass->CanAccess(super_class)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005459 ThrowIllegalAccessError(klass.Get(), "Class %s extended by class %s is inaccessible",
David Sehr709b0702016-10-13 09:12:37 -07005460 super_class->PrettyDescriptor().c_str(),
5461 klass->PrettyDescriptor().c_str());
Ian Rogersbe125a92012-01-11 15:19:49 -08005462 return false;
5463 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07005464 CHECK(super_class->IsResolved());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005465 klass->SetSuperClass(super_class);
Andreas Gampefd9eb392014-11-06 16:52:58 -08005466
5467 if (!CheckSuperClassChange(klass, dex_file, class_def, super_class)) {
5468 DCHECK(Thread::Current()->IsExceptionPending());
5469 return false;
5470 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005471 }
Ian Rogers8b2c0b92013-09-19 02:56:49 -07005472 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005473 if (interfaces != nullptr) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005474 for (size_t i = 0; i < interfaces->Size(); i++) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08005475 dex::TypeIndex idx = interfaces->GetTypeItem(i).type_idx_;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005476 ObjPtr<mirror::Class> interface = ResolveType(dex_file, idx, klass.Get());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005477 if (interface == nullptr) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005478 DCHECK(Thread::Current()->IsExceptionPending());
5479 return false;
5480 }
5481 // Verify
5482 if (!klass->CanAccess(interface)) {
5483 // TODO: the RI seemed to ignore this in my testing.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005484 ThrowIllegalAccessError(klass.Get(),
5485 "Interface %s implemented by class %s is inaccessible",
David Sehr709b0702016-10-13 09:12:37 -07005486 interface->PrettyDescriptor().c_str(),
5487 klass->PrettyDescriptor().c_str());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08005488 return false;
5489 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005490 }
5491 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07005492 // Mark the class as loaded.
Hiroshi Yamauchi5b783e62015-03-18 17:20:11 -07005493 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, nullptr);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005494 return true;
5495}
5496
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07005497bool ClassLinker::LinkSuperClass(Handle<mirror::Class> klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005498 CHECK(!klass->IsPrimitive());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07005499 ObjPtr<mirror::Class> super = klass->GetSuperClass();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005500 if (klass.Get() == GetClassRoot(kJavaLangObject)) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005501 if (super != nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005502 ThrowClassFormatError(klass.Get(), "java.lang.Object must not have a superclass");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005503 return false;
5504 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005505 return true;
5506 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005507 if (super == nullptr) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005508 ThrowLinkageError(klass.Get(), "No superclass defined for class %s",
David Sehr709b0702016-10-13 09:12:37 -07005509 klass->PrettyDescriptor().c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005510 return false;
5511 }
5512 // Verify
Elliott Hughes4a2b4172011-09-20 17:08:25 -07005513 if (super->IsFinal() || super->IsInterface()) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005514 ThrowIncompatibleClassChangeError(klass.Get(),
5515 "Superclass %s of %s is %s",
David Sehr709b0702016-10-13 09:12:37 -07005516 super->PrettyDescriptor().c_str(),
5517 klass->PrettyDescriptor().c_str(),
Ian Rogers62d6c772013-02-27 08:32:07 -08005518 super->IsFinal() ? "declared final" : "an interface");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005519 return false;
5520 }
5521 if (!klass->CanAccess(super)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005522 ThrowIllegalAccessError(klass.Get(), "Superclass %s is inaccessible to class %s",
David Sehr709b0702016-10-13 09:12:37 -07005523 super->PrettyDescriptor().c_str(),
5524 klass->PrettyDescriptor().c_str());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005525 return false;
5526 }
Elliott Hughes20cde902011-10-04 17:37:27 -07005527
Brian Carlstromf3632832014-05-20 15:36:53 -07005528 // Inherit kAccClassIsFinalizable from the superclass in case this
5529 // class doesn't override finalize.
Elliott Hughes20cde902011-10-04 17:37:27 -07005530 if (super->IsFinalizable()) {
5531 klass->SetFinalizable();
5532 }
5533
Mathieu Chartiere4275c02015-08-06 15:34:15 -07005534 // Inherit class loader flag form super class.
5535 if (super->IsClassLoaderClass()) {
5536 klass->SetClassLoaderClass();
5537 }
5538
Elliott Hughes2da50362011-10-10 16:57:08 -07005539 // Inherit reference flags (if any) from the superclass.
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07005540 uint32_t reference_flags = (super->GetClassFlags() & mirror::kClassFlagReference);
Elliott Hughes2da50362011-10-10 16:57:08 -07005541 if (reference_flags != 0) {
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07005542 CHECK_EQ(klass->GetClassFlags(), 0u);
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07005543 klass->SetClassFlags(klass->GetClassFlags() | reference_flags);
Elliott Hughes2da50362011-10-10 16:57:08 -07005544 }
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07005545 // Disallow custom direct subclasses of java.lang.ref.Reference.
Elliott Hughesbf61ba32011-10-11 10:53:09 -07005546 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005547 ThrowLinkageError(klass.Get(),
Ian Rogers62d6c772013-02-27 08:32:07 -08005548 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed",
David Sehr709b0702016-10-13 09:12:37 -07005549 klass->PrettyDescriptor().c_str());
Elliott Hughes72ee0ae2011-10-10 17:31:28 -07005550 return false;
5551 }
Elliott Hughes2da50362011-10-10 16:57:08 -07005552
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005553 if (kIsDebugBuild) {
5554 // Ensure super classes are fully resolved prior to resolving fields..
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005555 while (super != nullptr) {
Ian Rogers7dfb28c2013-08-22 08:18:36 -07005556 CHECK(super->IsResolved());
5557 super = super->GetSuperClass();
5558 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005559 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005560 return true;
5561}
5562
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005563// Populate the class vtable and itable. Compute return type indices.
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005564bool ClassLinker::LinkMethods(Thread* self,
5565 Handle<mirror::Class> klass,
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005566 Handle<mirror::ObjectArray<mirror::Class>> interfaces,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005567 bool* out_new_conflict,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07005568 ArtMethod** out_imt) {
Ian Rogers7b078e82014-09-10 14:44:24 -07005569 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07005570 // A map from vtable indexes to the method they need to be updated to point to. Used because we
5571 // need to have default methods be in the virtuals array of each class but we don't set that up
5572 // until LinkInterfaceMethods.
Alex Light9139e002015-10-09 15:59:48 -07005573 std::unordered_map<size_t, ClassLinker::MethodTranslation> default_translations;
Alex Lighteb7c1442015-08-31 13:17:42 -07005574 // Link virtual methods then interface methods.
5575 // We set up the interface lookup table first because we need it to determine if we need to update
5576 // any vtable entries with new default method implementations.
5577 return SetupInterfaceLookupTable(self, klass, interfaces)
5578 && LinkVirtualMethods(self, klass, /*out*/ &default_translations)
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005579 && LinkInterfaceMethods(self, klass, default_translations, out_new_conflict, out_imt);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005580}
5581
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005582// Comparator for name and signature of a method, used in finding overriding methods. Implementation
5583// avoids the use of handles, if it didn't then rather than compare dex files we could compare dex
5584// caches in the implementation below.
5585class MethodNameAndSignatureComparator FINAL : public ValueObject {
5586 public:
Mathieu Chartiere401d142015-04-22 13:56:20 -07005587 explicit MethodNameAndSignatureComparator(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005588 REQUIRES_SHARED(Locks::mutator_lock_) :
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005589 dex_file_(method->GetDexFile()), mid_(&dex_file_->GetMethodId(method->GetDexMethodIndex())),
5590 name_(nullptr), name_len_(0) {
David Sehr709b0702016-10-13 09:12:37 -07005591 DCHECK(!method->IsProxyMethod()) << method->PrettyMethod();
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005592 }
5593
5594 const char* GetName() {
5595 if (name_ == nullptr) {
5596 name_ = dex_file_->StringDataAndUtf16LengthByIdx(mid_->name_idx_, &name_len_);
5597 }
5598 return name_;
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005599 }
5600
Mathieu Chartiere401d142015-04-22 13:56:20 -07005601 bool HasSameNameAndSignature(ArtMethod* other)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005602 REQUIRES_SHARED(Locks::mutator_lock_) {
David Sehr709b0702016-10-13 09:12:37 -07005603 DCHECK(!other->IsProxyMethod()) << other->PrettyMethod();
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005604 const DexFile* other_dex_file = other->GetDexFile();
5605 const DexFile::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex());
5606 if (dex_file_ == other_dex_file) {
5607 return mid_->name_idx_ == other_mid.name_idx_ && mid_->proto_idx_ == other_mid.proto_idx_;
5608 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005609 GetName(); // Only used to make sure its calculated.
Ian Rogers03b6eaf2014-10-28 09:34:57 -07005610 uint32_t other_name_len;
5611 const char* other_name = other_dex_file->StringDataAndUtf16LengthByIdx(other_mid.name_idx_,
5612 &other_name_len);
5613 if (name_len_ != other_name_len || strcmp(name_, other_name) != 0) {
5614 return false;
5615 }
5616 return dex_file_->GetMethodSignature(*mid_) == other_dex_file->GetMethodSignature(other_mid);
5617 }
5618
5619 private:
5620 // Dex file for the method to compare against.
5621 const DexFile* const dex_file_;
5622 // MethodId for the method to compare against.
5623 const DexFile::MethodId* const mid_;
5624 // Lazily computed name from the dex file's strings.
5625 const char* name_;
5626 // Lazily computed name length.
5627 uint32_t name_len_;
5628};
5629
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005630class LinkVirtualHashTable {
5631 public:
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005632 LinkVirtualHashTable(Handle<mirror::Class> klass,
5633 size_t hash_size,
5634 uint32_t* hash_table,
Andreas Gampe542451c2016-07-26 09:02:02 -07005635 PointerSize image_pointer_size)
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005636 : klass_(klass),
5637 hash_size_(hash_size),
5638 hash_table_(hash_table),
Mathieu Chartiere401d142015-04-22 13:56:20 -07005639 image_pointer_size_(image_pointer_size) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005640 std::fill(hash_table_, hash_table_ + hash_size_, invalid_index_);
5641 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005642
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005643 void Add(uint32_t virtual_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005644 ArtMethod* local_method = klass_->GetVirtualMethodDuringLinking(
5645 virtual_method_index, image_pointer_size_);
5646 const char* name = local_method->GetInterfaceMethodIfProxy(image_pointer_size_)->GetName();
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08005647 uint32_t hash = ComputeModifiedUtf8Hash(name);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005648 uint32_t index = hash % hash_size_;
5649 // Linear probe until we have an empty slot.
5650 while (hash_table_[index] != invalid_index_) {
5651 if (++index == hash_size_) {
5652 index = 0;
5653 }
5654 }
5655 hash_table_[index] = virtual_method_index;
5656 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005657
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005658 uint32_t FindAndRemove(MethodNameAndSignatureComparator* comparator)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005659 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005660 const char* name = comparator->GetName();
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -08005661 uint32_t hash = ComputeModifiedUtf8Hash(name);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005662 size_t index = hash % hash_size_;
5663 while (true) {
5664 const uint32_t value = hash_table_[index];
5665 // Since linear probe makes continuous blocks, hitting an invalid index means we are done
5666 // the block and can safely assume not found.
5667 if (value == invalid_index_) {
5668 break;
5669 }
5670 if (value != removed_index_) { // This signifies not already overriden.
Mathieu Chartiere401d142015-04-22 13:56:20 -07005671 ArtMethod* virtual_method =
5672 klass_->GetVirtualMethodDuringLinking(value, image_pointer_size_);
5673 if (comparator->HasSameNameAndSignature(
5674 virtual_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005675 hash_table_[index] = removed_index_;
5676 return value;
5677 }
5678 }
5679 if (++index == hash_size_) {
5680 index = 0;
5681 }
5682 }
5683 return GetNotFoundIndex();
5684 }
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07005685
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005686 static uint32_t GetNotFoundIndex() {
5687 return invalid_index_;
5688 }
5689
5690 private:
5691 static const uint32_t invalid_index_;
5692 static const uint32_t removed_index_;
5693
5694 Handle<mirror::Class> klass_;
5695 const size_t hash_size_;
5696 uint32_t* const hash_table_;
Andreas Gampe542451c2016-07-26 09:02:02 -07005697 const PointerSize image_pointer_size_;
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005698};
5699
5700const uint32_t LinkVirtualHashTable::invalid_index_ = std::numeric_limits<uint32_t>::max();
5701const uint32_t LinkVirtualHashTable::removed_index_ = std::numeric_limits<uint32_t>::max() - 1;
5702
Andreas Gampe542451c2016-07-26 09:02:02 -07005703// b/30419309
5704#if defined(__i386__)
5705#define X86_OPTNONE __attribute__((optnone))
5706#else
5707#define X86_OPTNONE
5708#endif
5709
5710X86_OPTNONE bool ClassLinker::LinkVirtualMethods(
Alex Lighteb7c1442015-08-31 13:17:42 -07005711 Thread* self,
5712 Handle<mirror::Class> klass,
Alex Light9139e002015-10-09 15:59:48 -07005713 /*out*/std::unordered_map<size_t, ClassLinker::MethodTranslation>* default_translations) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005714 const size_t num_virtual_methods = klass->NumVirtualMethods();
Alex Lighteb7c1442015-08-31 13:17:42 -07005715 if (klass->IsInterface()) {
5716 // No vtable.
5717 if (!IsUint<16>(num_virtual_methods)) {
5718 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zu", num_virtual_methods);
5719 return false;
5720 }
5721 bool has_defaults = false;
Alex Lighteb7c1442015-08-31 13:17:42 -07005722 // Assign each method an IMT index and set the default flag.
5723 for (size_t i = 0; i < num_virtual_methods; ++i) {
5724 ArtMethod* m = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
5725 m->SetMethodIndex(i);
5726 if (!m->IsAbstract()) {
5727 m->SetAccessFlags(m->GetAccessFlags() | kAccDefault);
5728 has_defaults = true;
5729 }
5730 }
5731 // Mark that we have default methods so that we won't need to scan the virtual_methods_ array
5732 // during initialization. This is a performance optimization. We could simply traverse the
5733 // virtual_methods_ array again during initialization.
5734 if (has_defaults) {
5735 klass->SetHasDefaultMethods();
5736 }
5737 return true;
5738 } else if (klass->HasSuperClass()) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005739 const size_t super_vtable_length = klass->GetSuperClass()->GetVTableLength();
5740 const size_t max_count = num_virtual_methods + super_vtable_length;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005741 StackHandleScope<2> hs(self);
Mingyao Yang38eecb02014-08-13 14:51:03 -07005742 Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass()));
Mathieu Chartiere401d142015-04-22 13:56:20 -07005743 MutableHandle<mirror::PointerArray> vtable;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00005744 if (super_class->ShouldHaveEmbeddedVTable()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005745 vtable = hs.NewHandle(AllocPointerArray(self, max_count));
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005746 if (UNLIKELY(vtable.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005747 self->AssertPendingOOMException();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005748 return false;
5749 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005750 for (size_t i = 0; i < super_vtable_length; i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005751 vtable->SetElementPtrSize(
5752 i, super_class->GetEmbeddedVTableEntry(i, image_pointer_size_), image_pointer_size_);
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005753 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005754 // We might need to change vtable if we have new virtual methods or new interfaces (since that
5755 // might give us new default methods). If no new interfaces then we can skip the rest since
5756 // the class cannot override any of the super-class's methods. This is required for
5757 // correctness since without it we might not update overridden default method vtable entries
5758 // correctly.
5759 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005760 klass->SetVTable(vtable.Get());
5761 return true;
5762 }
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005763 } else {
Alex Lighteb7c1442015-08-31 13:17:42 -07005764 DCHECK(super_class->IsAbstract() && !super_class->IsArrayClass());
Mathieu Chartiere401d142015-04-22 13:56:20 -07005765 auto* super_vtable = super_class->GetVTable();
David Sehr709b0702016-10-13 09:12:37 -07005766 CHECK(super_vtable != nullptr) << super_class->PrettyClass();
Alex Lighteb7c1442015-08-31 13:17:42 -07005767 // We might need to change vtable if we have new virtual methods or new interfaces (since that
5768 // might give us new default methods). See comment above.
5769 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005770 klass->SetVTable(super_vtable);
5771 return true;
5772 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005773 vtable = hs.NewHandle(down_cast<mirror::PointerArray*>(
5774 super_vtable->CopyOf(self, max_count)));
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005775 if (UNLIKELY(vtable.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005776 self->AssertPendingOOMException();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07005777 return false;
5778 }
Ian Rogersa436fde2013-08-27 23:34:06 -07005779 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005780 // How the algorithm works:
5781 // 1. Populate hash table by adding num_virtual_methods from klass. The values in the hash
5782 // table are: invalid_index for unused slots, index super_vtable_length + i for a virtual
5783 // method which has not been matched to a vtable method, and j if the virtual method at the
5784 // index overrode the super virtual method at index j.
5785 // 2. Loop through super virtual methods, if they overwrite, update hash table to j
5786 // (j < super_vtable_length) to avoid redundant checks. (TODO maybe use this info for reducing
5787 // the need for the initial vtable which we later shrink back down).
5788 // 3. Add non overridden methods to the end of the vtable.
5789 static constexpr size_t kMaxStackHash = 250;
Alex Lighteb7c1442015-08-31 13:17:42 -07005790 // + 1 so that even if we only have new default methods we will still be able to use this hash
5791 // table (i.e. it will never have 0 size).
5792 const size_t hash_table_size = num_virtual_methods * 3 + 1;
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005793 uint32_t* hash_table_ptr;
5794 std::unique_ptr<uint32_t[]> hash_heap_storage;
5795 if (hash_table_size <= kMaxStackHash) {
5796 hash_table_ptr = reinterpret_cast<uint32_t*>(
5797 alloca(hash_table_size * sizeof(*hash_table_ptr)));
5798 } else {
5799 hash_heap_storage.reset(new uint32_t[hash_table_size]);
5800 hash_table_ptr = hash_heap_storage.get();
5801 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005802 LinkVirtualHashTable hash_table(klass, hash_table_size, hash_table_ptr, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005803 // Add virtual methods to the hash table.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005804 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005805 DCHECK(klass->GetVirtualMethodDuringLinking(
5806 i, image_pointer_size_)->GetDeclaringClass() != nullptr);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005807 hash_table.Add(i);
5808 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005809 // 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 -07005810 // the hash table.
5811 for (size_t j = 0; j < super_vtable_length; ++j) {
Alex Lighteb7c1442015-08-31 13:17:42 -07005812 // Search the hash table to see if we are overridden by any method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07005813 ArtMethod* super_method = vtable->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
Alex Lightc7a420c2016-10-18 14:33:18 -07005814 if (!klass->CanAccessMember(super_method->GetDeclaringClass(),
5815 super_method->GetAccessFlags())) {
5816 // Continue on to the next method since this one is package private and canot be overridden.
5817 // Before Android 4.1, the package-private method super_method might have been incorrectly
5818 // overridden.
5819 continue;
5820 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005821 MethodNameAndSignatureComparator super_method_name_comparator(
Mathieu Chartiere401d142015-04-22 13:56:20 -07005822 super_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Lightc7a420c2016-10-18 14:33:18 -07005823 // We remove the method so that subsequent lookups will be faster by making the hash-map
5824 // smaller as we go on.
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005825 uint32_t hash_index = hash_table.FindAndRemove(&super_method_name_comparator);
5826 if (hash_index != hash_table.GetNotFoundIndex()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005827 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(
5828 hash_index, image_pointer_size_);
Alex Lightc7a420c2016-10-18 14:33:18 -07005829 if (super_method->IsFinal()) {
5830 ThrowLinkageError(klass.Get(), "Method %s overrides final method in class %s",
5831 virtual_method->PrettyMethod().c_str(),
5832 super_method->GetDeclaringClassDescriptor());
5833 return false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005834 }
Alex Lightc7a420c2016-10-18 14:33:18 -07005835 vtable->SetElementPtrSize(j, virtual_method, image_pointer_size_);
5836 virtual_method->SetMethodIndex(j);
Alex Light9139e002015-10-09 15:59:48 -07005837 } else if (super_method->IsOverridableByDefaultMethod()) {
Alex Lighteb7c1442015-08-31 13:17:42 -07005838 // We didn't directly override this method but we might through default methods...
5839 // Check for default method update.
5840 ArtMethod* default_method = nullptr;
Alex Light9139e002015-10-09 15:59:48 -07005841 switch (FindDefaultMethodImplementation(self,
5842 super_method,
5843 klass,
5844 /*out*/&default_method)) {
5845 case DefaultMethodSearchResult::kDefaultConflict: {
5846 // A conflict was found looking for default methods. Note this (assuming it wasn't
5847 // pre-existing) in the translations map.
5848 if (UNLIKELY(!super_method->IsDefaultConflicting())) {
5849 // Don't generate another conflict method to reduce memory use as an optimization.
5850 default_translations->insert(
5851 {j, ClassLinker::MethodTranslation::CreateConflictingMethod()});
5852 }
5853 break;
5854 }
5855 case DefaultMethodSearchResult::kAbstractFound: {
5856 // No conflict but method is abstract.
5857 // We note that this vtable entry must be made abstract.
5858 if (UNLIKELY(!super_method->IsAbstract())) {
5859 default_translations->insert(
5860 {j, ClassLinker::MethodTranslation::CreateAbstractMethod()});
5861 }
5862 break;
5863 }
5864 case DefaultMethodSearchResult::kDefaultFound: {
5865 if (UNLIKELY(super_method->IsDefaultConflicting() ||
5866 default_method->GetDeclaringClass() != super_method->GetDeclaringClass())) {
5867 // Found a default method implementation that is new.
5868 // TODO Refactor this add default methods to virtuals here and not in
5869 // LinkInterfaceMethods maybe.
5870 // The problem is default methods might override previously present
5871 // default-method or miranda-method vtable entries from the superclass.
5872 // Unfortunately we need these to be entries in this class's virtuals. We do not
5873 // give these entries there until LinkInterfaceMethods so we pass this map around
5874 // to let it know which vtable entries need to be updated.
5875 // Make a note that vtable entry j must be updated, store what it needs to be updated
5876 // to. We will allocate a virtual method slot in LinkInterfaceMethods and fix it up
5877 // then.
5878 default_translations->insert(
5879 {j, ClassLinker::MethodTranslation::CreateTranslatedMethod(default_method)});
David Sehr709b0702016-10-13 09:12:37 -07005880 VLOG(class_linker) << "Method " << super_method->PrettyMethod()
5881 << " overridden by default "
5882 << default_method->PrettyMethod()
5883 << " in " << mirror::Class::PrettyClass(klass.Get());
Alex Light9139e002015-10-09 15:59:48 -07005884 }
5885 break;
5886 }
Alex Lighteb7c1442015-08-31 13:17:42 -07005887 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005888 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005889 }
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005890 size_t actual_count = super_vtable_length;
Alex Lighteb7c1442015-08-31 13:17:42 -07005891 // Add the non-overridden methods at the end.
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005892 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005893 ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005894 size_t method_idx = local_method->GetMethodIndexDuringLinking();
5895 if (method_idx < super_vtable_length &&
Mathieu Chartiere401d142015-04-22 13:56:20 -07005896 local_method == vtable->GetElementPtrSize<ArtMethod*>(method_idx, image_pointer_size_)) {
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005897 continue;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005898 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005899 vtable->SetElementPtrSize(actual_count, local_method, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07005900 local_method->SetMethodIndex(actual_count);
5901 ++actual_count;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005902 }
Andreas Gampeab1eb0d2015-02-13 19:23:55 -08005903 if (!IsUint<16>(actual_count)) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005904 ThrowClassFormatError(klass.Get(), "Too many methods defined on class: %zd", actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005905 return false;
5906 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005907 // Shrink vtable if possible
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005908 CHECK_LE(actual_count, max_count);
5909 if (actual_count < max_count) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005910 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, actual_count)));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07005911 if (UNLIKELY(vtable.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005912 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07005913 return false;
5914 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005915 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07005916 klass->SetVTable(vtable.Get());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005917 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07005918 CHECK_EQ(klass.Get(), GetClassRoot(kJavaLangObject));
Andreas Gampeab1eb0d2015-02-13 19:23:55 -08005919 if (!IsUint<16>(num_virtual_methods)) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005920 ThrowClassFormatError(klass.Get(), "Too many methods: %d",
5921 static_cast<int>(num_virtual_methods));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005922 return false;
5923 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07005924 auto* vtable = AllocPointerArray(self, num_virtual_methods);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005925 if (UNLIKELY(vtable == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005926 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07005927 return false;
5928 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07005929 for (size_t i = 0; i < num_virtual_methods; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005930 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_);
5931 vtable->SetElementPtrSize(i, virtual_method, image_pointer_size_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07005932 virtual_method->SetMethodIndex(i & 0xFFFF);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005933 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07005934 klass->SetVTable(vtable);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005935 }
5936 return true;
5937}
5938
Alex Light9139e002015-10-09 15:59:48 -07005939// Determine if the given iface has any subinterface in the given list that declares the method
5940// specified by 'target'.
5941//
5942// Arguments
5943// - self: The thread we are running on
5944// - target: A comparator that will match any method that overrides the method we are checking for
5945// - iftable: The iftable we are searching for an overriding method on.
5946// - ifstart: The index of the interface we are checking to see if anything overrides
5947// - iface: The interface we are checking to see if anything overrides.
5948// - image_pointer_size:
5949// The image pointer size.
5950//
5951// Returns
5952// - True: There is some method that matches the target comparator defined in an interface that
5953// is a subtype of iface.
5954// - False: There is no method that matches the target comparator in any interface that is a subtype
5955// of iface.
5956static bool ContainsOverridingMethodOf(Thread* self,
5957 MethodNameAndSignatureComparator& target,
5958 Handle<mirror::IfTable> iftable,
5959 size_t ifstart,
5960 Handle<mirror::Class> iface,
Andreas Gampe542451c2016-07-26 09:02:02 -07005961 PointerSize image_pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07005962 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light9139e002015-10-09 15:59:48 -07005963 DCHECK(self != nullptr);
5964 DCHECK(iface.Get() != nullptr);
5965 DCHECK(iftable.Get() != nullptr);
5966 DCHECK_GE(ifstart, 0u);
5967 DCHECK_LT(ifstart, iftable->Count());
5968 DCHECK_EQ(iface.Get(), iftable->GetInterface(ifstart));
5969 DCHECK(iface->IsInterface());
5970
5971 size_t iftable_count = iftable->Count();
5972 StackHandleScope<1> hs(self);
5973 MutableHandle<mirror::Class> current_iface(hs.NewHandle<mirror::Class>(nullptr));
5974 for (size_t k = ifstart + 1; k < iftable_count; k++) {
5975 // Skip ifstart since our current interface obviously cannot override itself.
5976 current_iface.Assign(iftable->GetInterface(k));
Alex Lighte64300b2015-12-15 15:02:47 -08005977 // Iterate through every method on this interface. The order does not matter.
5978 for (ArtMethod& current_method : current_iface->GetDeclaredVirtualMethods(image_pointer_size)) {
Alex Light9139e002015-10-09 15:59:48 -07005979 if (UNLIKELY(target.HasSameNameAndSignature(
Alex Lighte64300b2015-12-15 15:02:47 -08005980 current_method.GetInterfaceMethodIfProxy(image_pointer_size)))) {
Alex Light9139e002015-10-09 15:59:48 -07005981 // Check if the i'th interface is a subtype of this one.
5982 if (iface->IsAssignableFrom(current_iface.Get())) {
5983 return true;
5984 }
5985 break;
5986 }
5987 }
5988 }
5989 return false;
5990}
5991
Alex Lighteb7c1442015-08-31 13:17:42 -07005992// Find the default method implementation for 'interface_method' in 'klass'. Stores it into
Alex Light9139e002015-10-09 15:59:48 -07005993// out_default_method and returns kDefaultFound on success. If no default method was found return
5994// kAbstractFound and store nullptr into out_default_method. If an error occurs (such as a
5995// default_method conflict) it will return kDefaultConflict.
5996ClassLinker::DefaultMethodSearchResult ClassLinker::FindDefaultMethodImplementation(
5997 Thread* self,
5998 ArtMethod* target_method,
5999 Handle<mirror::Class> klass,
6000 /*out*/ArtMethod** out_default_method) const {
Alex Lighteb7c1442015-08-31 13:17:42 -07006001 DCHECK(self != nullptr);
6002 DCHECK(target_method != nullptr);
6003 DCHECK(out_default_method != nullptr);
Alex Lighteb7c1442015-08-31 13:17:42 -07006004
6005 *out_default_method = nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006006
6007 // We organize the interface table so that, for interface I any subinterfaces J follow it in the
6008 // table. This lets us walk the table backwards when searching for default methods. The first one
6009 // we encounter is the best candidate since it is the most specific. Once we have found it we keep
6010 // track of it and then continue checking all other interfaces, since we need to throw an error if
6011 // we encounter conflicting default method implementations (one is not a subtype of the other).
6012 //
6013 // The order of unrelated interfaces does not matter and is not defined.
6014 size_t iftable_count = klass->GetIfTableCount();
6015 if (iftable_count == 0) {
Alex Light9139e002015-10-09 15:59:48 -07006016 // No interfaces. We have already reset out to null so just return kAbstractFound.
6017 return DefaultMethodSearchResult::kAbstractFound;
Alex Lighteb7c1442015-08-31 13:17:42 -07006018 }
6019
Alex Light9139e002015-10-09 15:59:48 -07006020 StackHandleScope<3> hs(self);
6021 MutableHandle<mirror::Class> chosen_iface(hs.NewHandle<mirror::Class>(nullptr));
Alex Lighteb7c1442015-08-31 13:17:42 -07006022 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable()));
Alex Light9139e002015-10-09 15:59:48 -07006023 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
Alex Lighteb7c1442015-08-31 13:17:42 -07006024 MethodNameAndSignatureComparator target_name_comparator(
6025 target_method->GetInterfaceMethodIfProxy(image_pointer_size_));
6026 // Iterates over the klass's iftable in reverse
Alex Light9139e002015-10-09 15:59:48 -07006027 for (size_t k = iftable_count; k != 0; ) {
6028 --k;
6029
Alex Lighteb7c1442015-08-31 13:17:42 -07006030 DCHECK_LT(k, iftable->Count());
Alex Light9139e002015-10-09 15:59:48 -07006031
6032 iface.Assign(iftable->GetInterface(k));
Alex Lighte64300b2015-12-15 15:02:47 -08006033 // Iterate through every declared method on this interface. The order does not matter.
6034 for (auto& method_iter : iface->GetDeclaredVirtualMethods(image_pointer_size_)) {
6035 ArtMethod* current_method = &method_iter;
Alex Lighteb7c1442015-08-31 13:17:42 -07006036 // Skip abstract methods and methods with different names.
6037 if (current_method->IsAbstract() ||
6038 !target_name_comparator.HasSameNameAndSignature(
6039 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
6040 continue;
Alex Lightd7c10c22016-03-31 10:03:07 -07006041 } else if (!current_method->IsPublic()) {
6042 // The verifier should have caught the non-public method for dex version 37. Just warn and
6043 // skip it since this is from before default-methods so we don't really need to care that it
6044 // has code.
David Sehr709b0702016-10-13 09:12:37 -07006045 LOG(WARNING) << "Interface method " << current_method->PrettyMethod()
6046 << " is not public! "
Alex Lightd7c10c22016-03-31 10:03:07 -07006047 << "This will be a fatal error in subsequent versions of android. "
6048 << "Continuing anyway.";
Alex Lighteb7c1442015-08-31 13:17:42 -07006049 }
Alex Light9139e002015-10-09 15:59:48 -07006050 if (UNLIKELY(chosen_iface.Get() != nullptr)) {
6051 // We have multiple default impls of the same method. This is a potential default conflict.
6052 // We need to check if this possibly conflicting method is either a superclass of the chosen
6053 // default implementation or is overridden by a non-default interface method. In either case
6054 // there is no conflict.
6055 if (!iface->IsAssignableFrom(chosen_iface.Get()) &&
6056 !ContainsOverridingMethodOf(self,
6057 target_name_comparator,
6058 iftable,
6059 k,
6060 iface,
6061 image_pointer_size_)) {
Nicolas Geoffray7f3e0db2016-01-28 09:29:31 +00006062 VLOG(class_linker) << "Conflicting default method implementations found: "
David Sehr709b0702016-10-13 09:12:37 -07006063 << current_method->PrettyMethod() << " and "
6064 << ArtMethod::PrettyMethod(*out_default_method) << " in class "
6065 << klass->PrettyClass() << " conflict.";
Alex Light9139e002015-10-09 15:59:48 -07006066 *out_default_method = nullptr;
6067 return DefaultMethodSearchResult::kDefaultConflict;
Alex Lighteb7c1442015-08-31 13:17:42 -07006068 } else {
6069 break; // Continue checking at the next interface.
6070 }
6071 } else {
Alex Light9139e002015-10-09 15:59:48 -07006072 // chosen_iface == null
6073 if (!ContainsOverridingMethodOf(self,
6074 target_name_comparator,
6075 iftable,
6076 k,
6077 iface,
6078 image_pointer_size_)) {
6079 // Don't set this as the chosen interface if something else is overriding it (because that
6080 // other interface would be potentially chosen instead if it was default). If the other
6081 // interface was abstract then we wouldn't select this interface as chosen anyway since
6082 // the abstract method masks it.
6083 *out_default_method = current_method;
6084 chosen_iface.Assign(iface.Get());
6085 // We should now finish traversing the graph to find if we have default methods that
6086 // conflict.
6087 } else {
David Sehr709b0702016-10-13 09:12:37 -07006088 VLOG(class_linker) << "A default method '" << current_method->PrettyMethod()
6089 << "' was "
6090 << "skipped because it was overridden by an abstract method in a "
6091 << "subinterface on class '" << klass->PrettyClass() << "'";
Alex Light9139e002015-10-09 15:59:48 -07006092 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006093 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006094 break;
6095 }
6096 }
Alex Light9139e002015-10-09 15:59:48 -07006097 if (*out_default_method != nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07006098 VLOG(class_linker) << "Default method '" << (*out_default_method)->PrettyMethod()
6099 << "' selected "
6100 << "as the implementation for '" << target_method->PrettyMethod()
6101 << "' in '" << klass->PrettyClass() << "'";
Alex Light9139e002015-10-09 15:59:48 -07006102 return DefaultMethodSearchResult::kDefaultFound;
6103 } else {
6104 return DefaultMethodSearchResult::kAbstractFound;
6105 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006106}
6107
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006108ArtMethod* ClassLinker::AddMethodToConflictTable(ObjPtr<mirror::Class> klass,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006109 ArtMethod* conflict_method,
6110 ArtMethod* interface_method,
6111 ArtMethod* method,
6112 bool force_new_conflict_method) {
Andreas Gampe542451c2016-07-26 09:02:02 -07006113 ImtConflictTable* current_table = conflict_method->GetImtConflictTable(kRuntimePointerSize);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006114 Runtime* const runtime = Runtime::Current();
6115 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
6116 bool new_entry = conflict_method == runtime->GetImtConflictMethod() || force_new_conflict_method;
6117
6118 // Create a new entry if the existing one is the shared conflict method.
6119 ArtMethod* new_conflict_method = new_entry
6120 ? runtime->CreateImtConflictMethod(linear_alloc)
6121 : conflict_method;
6122
6123 // Allocate a new table. Note that we will leak this table at the next conflict,
6124 // but that's a tradeoff compared to making the table fixed size.
6125 void* data = linear_alloc->Alloc(
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006126 Thread::Current(), ImtConflictTable::ComputeSizeWithOneMoreEntry(current_table,
6127 image_pointer_size_));
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006128 if (data == nullptr) {
6129 LOG(ERROR) << "Failed to allocate conflict table";
6130 return conflict_method;
6131 }
6132 ImtConflictTable* new_table = new (data) ImtConflictTable(current_table,
6133 interface_method,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006134 method,
6135 image_pointer_size_);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006136
6137 // Do a fence to ensure threads see the data in the table before it is assigned
6138 // to the conflict method.
6139 // Note that there is a race in the presence of multiple threads and we may leak
6140 // memory from the LinearAlloc, but that's a tradeoff compared to using
6141 // atomic operations.
6142 QuasiAtomic::ThreadFenceRelease();
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006143 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006144 return new_conflict_method;
6145}
6146
6147void ClassLinker::SetIMTRef(ArtMethod* unimplemented_method,
6148 ArtMethod* imt_conflict_method,
6149 ArtMethod* current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006150 /*out*/bool* new_conflict,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006151 /*out*/ArtMethod** imt_ref) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006152 // Place method in imt if entry is empty, place conflict otherwise.
6153 if (*imt_ref == unimplemented_method) {
6154 *imt_ref = current_method;
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006155 } else if (!(*imt_ref)->IsRuntimeMethod()) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006156 // If we are not a conflict and we have the same signature and name as the imt
6157 // entry, it must be that we overwrote a superclass vtable entry.
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006158 // Note that we have checked IsRuntimeMethod, as there may be multiple different
6159 // conflict methods.
Alex Lighteb7c1442015-08-31 13:17:42 -07006160 MethodNameAndSignatureComparator imt_comparator(
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006161 (*imt_ref)->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Lighteb7c1442015-08-31 13:17:42 -07006162 if (imt_comparator.HasSameNameAndSignature(
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006163 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006164 *imt_ref = current_method;
6165 } else {
Alex Light9139e002015-10-09 15:59:48 -07006166 *imt_ref = imt_conflict_method;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006167 *new_conflict = true;
Alex Lighteb7c1442015-08-31 13:17:42 -07006168 }
Nicolas Geoffray796d6302016-03-13 22:22:31 +00006169 } else {
6170 // Place the default conflict method. Note that there may be an existing conflict
6171 // method in the IMT, but it could be one tailored to the super class, with a
6172 // specific ImtConflictTable.
6173 *imt_ref = imt_conflict_method;
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006174 *new_conflict = true;
Alex Lighteb7c1442015-08-31 13:17:42 -07006175 }
6176}
6177
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006178void ClassLinker::FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) {
David Sehr709b0702016-10-13 09:12:37 -07006179 DCHECK(klass->ShouldHaveImt()) << klass->PrettyClass();
6180 DCHECK(!klass->IsTemp()) << klass->PrettyClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006181 ArtMethod* imt_data[ImTable::kSize];
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006182 Runtime* const runtime = Runtime::Current();
6183 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
6184 ArtMethod* const conflict_method = runtime->GetImtConflictMethod();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006185 std::fill_n(imt_data, arraysize(imt_data), unimplemented_method);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006186 if (klass->GetIfTable() != nullptr) {
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006187 bool new_conflict = false;
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006188 FillIMTFromIfTable(klass->GetIfTable(),
6189 unimplemented_method,
6190 conflict_method,
6191 klass,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006192 /*create_conflict_tables*/true,
6193 /*ignore_copied_methods*/false,
6194 &new_conflict,
6195 &imt_data[0]);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006196 }
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006197 if (!klass->ShouldHaveImt()) {
6198 return;
6199 }
6200 // Compare the IMT with the super class including the conflict methods. If they are equivalent,
6201 // we can just use the same pointer.
6202 ImTable* imt = nullptr;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006203 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006204 if (super_class != nullptr && super_class->ShouldHaveImt()) {
6205 ImTable* super_imt = super_class->GetImt(image_pointer_size_);
6206 bool same = true;
6207 for (size_t i = 0; same && i < ImTable::kSize; ++i) {
6208 ArtMethod* method = imt_data[i];
6209 ArtMethod* super_method = super_imt->Get(i, image_pointer_size_);
6210 if (method != super_method) {
6211 bool is_conflict_table = method->IsRuntimeMethod() &&
6212 method != unimplemented_method &&
6213 method != conflict_method;
6214 // Verify conflict contents.
6215 bool super_conflict_table = super_method->IsRuntimeMethod() &&
6216 super_method != unimplemented_method &&
6217 super_method != conflict_method;
6218 if (!is_conflict_table || !super_conflict_table) {
6219 same = false;
6220 } else {
6221 ImtConflictTable* table1 = method->GetImtConflictTable(image_pointer_size_);
6222 ImtConflictTable* table2 = super_method->GetImtConflictTable(image_pointer_size_);
6223 same = same && table1->Equals(table2, image_pointer_size_);
6224 }
6225 }
6226 }
6227 if (same) {
6228 imt = super_imt;
6229 }
6230 }
6231 if (imt == nullptr) {
6232 imt = klass->GetImt(image_pointer_size_);
6233 DCHECK(imt != nullptr);
6234 imt->Populate(imt_data, image_pointer_size_);
6235 } else {
6236 klass->SetImt(imt, image_pointer_size_);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006237 }
6238}
6239
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006240ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count,
6241 LinearAlloc* linear_alloc,
Andreas Gampe542451c2016-07-26 09:02:02 -07006242 PointerSize image_pointer_size) {
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006243 void* data = linear_alloc->Alloc(Thread::Current(),
6244 ImtConflictTable::ComputeSize(count,
6245 image_pointer_size));
6246 return (data != nullptr) ? new (data) ImtConflictTable(count, image_pointer_size) : nullptr;
6247}
6248
6249ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc) {
6250 return CreateImtConflictTable(count, linear_alloc, image_pointer_size_);
6251}
6252
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006253void ClassLinker::FillIMTFromIfTable(ObjPtr<mirror::IfTable> if_table,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006254 ArtMethod* unimplemented_method,
6255 ArtMethod* imt_conflict_method,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006256 ObjPtr<mirror::Class> klass,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006257 bool create_conflict_tables,
6258 bool ignore_copied_methods,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006259 /*out*/bool* new_conflict,
6260 /*out*/ArtMethod** imt) {
6261 uint32_t conflict_counts[ImTable::kSize] = {};
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006262 for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006263 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006264 const size_t num_virtuals = interface->NumVirtualMethods();
6265 const size_t method_array_count = if_table->GetMethodArrayCount(i);
6266 // Virtual methods can be larger than the if table methods if there are default methods.
6267 DCHECK_GE(num_virtuals, method_array_count);
6268 if (kIsDebugBuild) {
6269 if (klass->IsInterface()) {
6270 DCHECK_EQ(method_array_count, 0u);
6271 } else {
6272 DCHECK_EQ(interface->NumDeclaredVirtualMethods(), method_array_count);
6273 }
6274 }
6275 if (method_array_count == 0) {
6276 continue;
6277 }
6278 auto* method_array = if_table->GetMethodArray(i);
6279 for (size_t j = 0; j < method_array_count; ++j) {
6280 ArtMethod* implementation_method =
6281 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6282 if (ignore_copied_methods && implementation_method->IsCopied()) {
6283 continue;
6284 }
6285 DCHECK(implementation_method != nullptr);
6286 // Miranda methods cannot be used to implement an interface method, but they are safe to put
6287 // in the IMT since their entrypoint is the interface trampoline. If we put any copied methods
6288 // or interface methods in the IMT here they will not create extra conflicts since we compare
6289 // names and signatures in SetIMTRef.
6290 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
Andreas Gampe75a7db62016-09-26 12:04:26 -07006291 const uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006292
6293 // There is only any conflicts if all of the interface methods for an IMT slot don't have
6294 // the same implementation method, keep track of this to avoid creating a conflict table in
6295 // this case.
6296
6297 // Conflict table size for each IMT slot.
6298 ++conflict_counts[imt_index];
6299
6300 SetIMTRef(unimplemented_method,
6301 imt_conflict_method,
6302 implementation_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006303 /*out*/new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006304 /*out*/&imt[imt_index]);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006305 }
6306 }
6307
6308 if (create_conflict_tables) {
6309 // Create the conflict tables.
6310 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006311 for (size_t i = 0; i < ImTable::kSize; ++i) {
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006312 size_t conflicts = conflict_counts[i];
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006313 if (imt[i] == imt_conflict_method) {
6314 ImtConflictTable* new_table = CreateImtConflictTable(conflicts, linear_alloc);
6315 if (new_table != nullptr) {
6316 ArtMethod* new_conflict_method =
6317 Runtime::Current()->CreateImtConflictMethod(linear_alloc);
6318 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_);
6319 imt[i] = new_conflict_method;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006320 } else {
6321 LOG(ERROR) << "Failed to allocate conflict table";
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006322 imt[i] = imt_conflict_method;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006323 }
6324 } else {
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006325 DCHECK_NE(imt[i], imt_conflict_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006326 }
6327 }
6328
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006329 for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006330 ObjPtr<mirror::Class> interface = if_table->GetInterface(i);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006331 const size_t method_array_count = if_table->GetMethodArrayCount(i);
6332 // Virtual methods can be larger than the if table methods if there are default methods.
6333 if (method_array_count == 0) {
6334 continue;
6335 }
6336 auto* method_array = if_table->GetMethodArray(i);
6337 for (size_t j = 0; j < method_array_count; ++j) {
6338 ArtMethod* implementation_method =
6339 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6340 if (ignore_copied_methods && implementation_method->IsCopied()) {
6341 continue;
6342 }
6343 DCHECK(implementation_method != nullptr);
6344 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_);
Andreas Gampe75a7db62016-09-26 12:04:26 -07006345 const uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006346 if (!imt[imt_index]->IsRuntimeMethod() ||
6347 imt[imt_index] == unimplemented_method ||
6348 imt[imt_index] == imt_conflict_method) {
6349 continue;
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006350 }
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006351 ImtConflictTable* table = imt[imt_index]->GetImtConflictTable(image_pointer_size_);
6352 const size_t num_entries = table->NumEntries(image_pointer_size_);
6353 table->SetInterfaceMethod(num_entries, image_pointer_size_, interface_method);
6354 table->SetImplementationMethod(num_entries, image_pointer_size_, implementation_method);
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006355 }
6356 }
6357 }
6358}
6359
Alex Lighteb7c1442015-08-31 13:17:42 -07006360// Simple helper function that checks that no subtypes of 'val' are contained within the 'classes'
6361// set.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006362static bool NotSubinterfaceOfAny(
6363 const std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr>& classes,
6364 ObjPtr<mirror::Class> val)
Alex Lighteb7c1442015-08-31 13:17:42 -07006365 REQUIRES(Roles::uninterruptible_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006366 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006367 DCHECK(val != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006368 for (ObjPtr<mirror::Class> c : classes) {
6369 if (val->IsAssignableFrom(c)) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006370 return false;
6371 }
6372 }
6373 return true;
6374}
6375
6376// Fills in and flattens the interface inheritance hierarchy.
6377//
6378// By the end of this function all interfaces in the transitive closure of to_process are added to
6379// the iftable and every interface precedes all of its sub-interfaces in this list.
6380//
6381// all I, J: Interface | I <: J implies J precedes I
6382//
6383// (note A <: B means that A is a subtype of B)
6384//
6385// This returns the total number of items in the iftable. The iftable might be resized down after
6386// this call.
6387//
6388// We order this backwards so that we do not need to reorder superclass interfaces when new
6389// interfaces are added in subclass's interface tables.
6390//
6391// Upon entry into this function iftable is a copy of the superclass's iftable with the first
6392// super_ifcount entries filled in with the transitive closure of the interfaces of the superclass.
6393// The other entries are uninitialized. We will fill in the remaining entries in this function. The
6394// iftable must be large enough to hold all interfaces without changing its size.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006395static size_t FillIfTable(ObjPtr<mirror::IfTable> iftable,
Alex Lighteb7c1442015-08-31 13:17:42 -07006396 size_t super_ifcount,
6397 std::vector<mirror::Class*> to_process)
6398 REQUIRES(Roles::uninterruptible_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006399 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006400 // This is the set of all class's already in the iftable. Used to make checking if a class has
6401 // already been added quicker.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006402 std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr> classes_in_iftable;
Alex Lighteb7c1442015-08-31 13:17:42 -07006403 // The first super_ifcount elements are from the superclass. We note that they are already added.
6404 for (size_t i = 0; i < super_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006405 ObjPtr<mirror::Class> iface = iftable->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07006406 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, iface)) << "Bad ordering.";
6407 classes_in_iftable.insert(iface);
6408 }
6409 size_t filled_ifcount = super_ifcount;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006410 for (ObjPtr<mirror::Class> interface : to_process) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006411 // Let us call the first filled_ifcount elements of iftable the current-iface-list.
6412 // At this point in the loop current-iface-list has the invariant that:
6413 // for every pair of interfaces I,J within it:
6414 // if index_of(I) < index_of(J) then I is not a subtype of J
6415
6416 // If we have already seen this element then all of its super-interfaces must already be in the
6417 // current-iface-list so we can skip adding it.
6418 if (!ContainsElement(classes_in_iftable, interface)) {
6419 // We haven't seen this interface so add all of its super-interfaces onto the
6420 // current-iface-list, skipping those already on it.
6421 int32_t ifcount = interface->GetIfTableCount();
6422 for (int32_t j = 0; j < ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006423 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006424 if (!ContainsElement(classes_in_iftable, super_interface)) {
6425 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, super_interface)) << "Bad ordering.";
6426 classes_in_iftable.insert(super_interface);
6427 iftable->SetInterface(filled_ifcount, super_interface);
6428 filled_ifcount++;
6429 }
6430 }
6431 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, interface)) << "Bad ordering";
6432 // Place this interface onto the current-iface-list after all of its super-interfaces.
6433 classes_in_iftable.insert(interface);
6434 iftable->SetInterface(filled_ifcount, interface);
6435 filled_ifcount++;
6436 } else if (kIsDebugBuild) {
6437 // Check all super-interfaces are already in the list.
6438 int32_t ifcount = interface->GetIfTableCount();
6439 for (int32_t j = 0; j < ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006440 ObjPtr<mirror::Class> super_interface = interface->GetIfTable()->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006441 DCHECK(ContainsElement(classes_in_iftable, super_interface))
David Sehr709b0702016-10-13 09:12:37 -07006442 << "Iftable does not contain " << mirror::Class::PrettyClass(super_interface)
6443 << ", a superinterface of " << interface->PrettyClass();
Alex Lighteb7c1442015-08-31 13:17:42 -07006444 }
6445 }
6446 }
6447 if (kIsDebugBuild) {
6448 // Check that the iftable is ordered correctly.
6449 for (size_t i = 0; i < filled_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006450 ObjPtr<mirror::Class> if_a = iftable->GetInterface(i);
Alex Lighteb7c1442015-08-31 13:17:42 -07006451 for (size_t j = i + 1; j < filled_ifcount; j++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006452 ObjPtr<mirror::Class> if_b = iftable->GetInterface(j);
Alex Lighteb7c1442015-08-31 13:17:42 -07006453 // !(if_a <: if_b)
6454 CHECK(!if_b->IsAssignableFrom(if_a))
David Sehr709b0702016-10-13 09:12:37 -07006455 << "Bad interface order: " << mirror::Class::PrettyClass(if_a) << " (index " << i
6456 << ") extends "
6457 << if_b->PrettyClass() << " (index " << j << ") and so should be after it in the "
Alex Lighteb7c1442015-08-31 13:17:42 -07006458 << "interface list.";
6459 }
6460 }
6461 }
6462 return filled_ifcount;
6463}
6464
6465bool ClassLinker::SetupInterfaceLookupTable(Thread* self, Handle<mirror::Class> klass,
6466 Handle<mirror::ObjectArray<mirror::Class>> interfaces) {
6467 StackHandleScope<1> hs(self);
Mathieu Chartier6beced42016-11-15 15:51:31 -08006468 const bool has_superclass = klass->HasSuperClass();
6469 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006470 const bool have_interfaces = interfaces.Get() != nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006471 const size_t num_interfaces =
6472 have_interfaces ? interfaces->GetLength() : klass->NumDirectInterfaces();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006473 if (num_interfaces == 0) {
6474 if (super_ifcount == 0) {
Mathieu Chartier6beced42016-11-15 15:51:31 -08006475 if (LIKELY(has_superclass)) {
6476 klass->SetIfTable(klass->GetSuperClass()->GetIfTable());
6477 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006478 // Class implements no interfaces.
6479 DCHECK_EQ(klass->GetIfTableCount(), 0);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006480 return true;
6481 }
Ian Rogers9bc81912012-10-11 21:43:36 -07006482 // Class implements same interfaces as parent, are any of these not marker interfaces?
6483 bool has_non_marker_interface = false;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006484 ObjPtr<mirror::IfTable> super_iftable = klass->GetSuperClass()->GetIfTable();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006485 for (size_t i = 0; i < super_ifcount; ++i) {
Ian Rogers9bc81912012-10-11 21:43:36 -07006486 if (super_iftable->GetMethodArrayCount(i) > 0) {
6487 has_non_marker_interface = true;
6488 break;
6489 }
6490 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006491 // Class just inherits marker interfaces from parent so recycle parent's iftable.
Ian Rogers9bc81912012-10-11 21:43:36 -07006492 if (!has_non_marker_interface) {
Ian Rogers9bc81912012-10-11 21:43:36 -07006493 klass->SetIfTable(super_iftable);
6494 return true;
6495 }
6496 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006497 size_t ifcount = super_ifcount + num_interfaces;
Alex Lighteb7c1442015-08-31 13:17:42 -07006498 // Check that every class being implemented is an interface.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006499 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006500 ObjPtr<mirror::Class> interface = have_interfaces
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006501 ? interfaces->GetWithoutChecks(i)
6502 : mirror::Class::GetDirectInterface(self, klass, i);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006503 DCHECK(interface != nullptr);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006504 if (UNLIKELY(!interface->IsInterface())) {
6505 std::string temp;
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006506 ThrowIncompatibleClassChangeError(klass.Get(),
6507 "Class %s implements non-interface class %s",
David Sehr709b0702016-10-13 09:12:37 -07006508 klass->PrettyDescriptor().c_str(),
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006509 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str());
6510 return false;
6511 }
6512 ifcount += interface->GetIfTableCount();
6513 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006514 // Create the interface function table.
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07006515 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount)));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07006516 if (UNLIKELY(iftable.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006517 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006518 return false;
6519 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006520 // Fill in table with superclass's iftable.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006521 if (super_ifcount != 0) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006522 ObjPtr<mirror::IfTable> super_iftable = klass->GetSuperClass()->GetIfTable();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07006523 for (size_t i = 0; i < super_ifcount; i++) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006524 ObjPtr<mirror::Class> super_interface = super_iftable->GetInterface(i);
Ian Rogers9bc81912012-10-11 21:43:36 -07006525 iftable->SetInterface(i, super_interface);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -07006526 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006527 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006528
6529 // Note that AllowThreadSuspension is to thread suspension as pthread_testcancel is to pthread
6530 // cancellation. That is it will suspend if one has a pending suspend request but otherwise
6531 // doesn't really do anything.
Ian Rogers7b078e82014-09-10 14:44:24 -07006532 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07006533
6534 size_t new_ifcount;
6535 {
Mathieu Chartier268764d2016-09-13 12:09:38 -07006536 ScopedAssertNoThreadSuspension nts("Copying mirror::Class*'s for FillIfTable");
Alex Lighteb7c1442015-08-31 13:17:42 -07006537 std::vector<mirror::Class*> to_add;
6538 for (size_t i = 0; i < num_interfaces; i++) {
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006539 ObjPtr<mirror::Class> interface = have_interfaces ? interfaces->Get(i) :
Alex Lighteb7c1442015-08-31 13:17:42 -07006540 mirror::Class::GetDirectInterface(self, klass, i);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07006541 to_add.push_back(interface.Ptr());
Ian Rogersb52b01a2012-01-12 17:01:38 -08006542 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006543
6544 new_ifcount = FillIfTable(iftable.Get(), super_ifcount, std::move(to_add));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07006545 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006546
Ian Rogers7b078e82014-09-10 14:44:24 -07006547 self->AllowThreadSuspension();
Alex Lighteb7c1442015-08-31 13:17:42 -07006548
Ian Rogersb52b01a2012-01-12 17:01:38 -08006549 // Shrink iftable in case duplicates were found
Alex Lighteb7c1442015-08-31 13:17:42 -07006550 if (new_ifcount < ifcount) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006551 DCHECK_NE(num_interfaces, 0U);
Mathieu Chartiere401d142015-04-22 13:56:20 -07006552 iftable.Assign(down_cast<mirror::IfTable*>(
Alex Lighteb7c1442015-08-31 13:17:42 -07006553 iftable->CopyOf(self, new_ifcount * mirror::IfTable::kMax)));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07006554 if (UNLIKELY(iftable.Get() == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07006555 self->AssertPendingOOMException();
Ian Rogersa436fde2013-08-27 23:34:06 -07006556 return false;
6557 }
Alex Lighteb7c1442015-08-31 13:17:42 -07006558 ifcount = new_ifcount;
Ian Rogersb52b01a2012-01-12 17:01:38 -08006559 } else {
Alex Lighteb7c1442015-08-31 13:17:42 -07006560 DCHECK_EQ(new_ifcount, ifcount);
Ian Rogersb52b01a2012-01-12 17:01:38 -08006561 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07006562 klass->SetIfTable(iftable.Get());
Alex Lighteb7c1442015-08-31 13:17:42 -07006563 return true;
6564}
6565
Alex Light1f3925d2016-09-07 12:04:20 -07006566// Finds the method with a name/signature that matches cmp in the given lists of methods. The list
6567// of methods must be unique.
6568static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp ATTRIBUTE_UNUSED) {
6569 return nullptr;
6570}
6571
6572template <typename ... Types>
Alex Light9139e002015-10-09 15:59:48 -07006573static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp,
Alex Light1f3925d2016-09-07 12:04:20 -07006574 const ScopedArenaVector<ArtMethod*>& list,
6575 const Types& ... rest)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006576 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light9139e002015-10-09 15:59:48 -07006577 for (ArtMethod* method : list) {
6578 if (cmp.HasSameNameAndSignature(method)) {
6579 return method;
6580 }
6581 }
Alex Light1f3925d2016-09-07 12:04:20 -07006582 return FindSameNameAndSignature(cmp, rest...);
Alex Light9139e002015-10-09 15:59:48 -07006583}
6584
Alex Light1f3925d2016-09-07 12:04:20 -07006585// Check that all vtable entries are present in this class's virtuals or are the same as a
6586// superclasses vtable entry.
6587static void CheckClassOwnsVTableEntries(Thread* self,
6588 Handle<mirror::Class> klass,
6589 PointerSize pointer_size)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07006590 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light1f3925d2016-09-07 12:04:20 -07006591 StackHandleScope<2> hs(self);
6592 Handle<mirror::PointerArray> check_vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006593 ObjPtr<mirror::Class> super_temp = (klass->HasSuperClass()) ? klass->GetSuperClass() : nullptr;
Alex Light1f3925d2016-09-07 12:04:20 -07006594 Handle<mirror::Class> superclass(hs.NewHandle(super_temp));
6595 int32_t super_vtable_length = (superclass.Get() != nullptr) ? superclass->GetVTableLength() : 0;
Alex Lighte64300b2015-12-15 15:02:47 -08006596 for (int32_t i = 0; i < check_vtable->GetLength(); ++i) {
6597 ArtMethod* m = check_vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
6598 CHECK(m != nullptr);
6599
Alex Light1f3925d2016-09-07 12:04:20 -07006600 CHECK_EQ(m->GetMethodIndexDuringLinking(), i)
David Sehr709b0702016-10-13 09:12:37 -07006601 << m->PrettyMethod()
6602 << " has an unexpected method index for its spot in the vtable for class"
6603 << klass->PrettyClass();
Alex Lighte64300b2015-12-15 15:02:47 -08006604 ArraySlice<ArtMethod> virtuals = klass->GetVirtualMethodsSliceUnchecked(pointer_size);
6605 auto is_same_method = [m] (const ArtMethod& meth) {
6606 return &meth == m;
6607 };
6608 CHECK((super_vtable_length > i && superclass->GetVTableEntry(i, pointer_size) == m) ||
6609 std::find_if(virtuals.begin(), virtuals.end(), is_same_method) != virtuals.end())
David Sehr709b0702016-10-13 09:12:37 -07006610 << m->PrettyMethod() << " does not seem to be owned by current class "
6611 << klass->PrettyClass() << " or any of its superclasses!";
Alex Lighte64300b2015-12-15 15:02:47 -08006612 }
6613}
6614
Alex Light1f3925d2016-09-07 12:04:20 -07006615// Check to make sure the vtable does not have duplicates. Duplicates could cause problems when a
6616// method is overridden in a subclass.
6617static void CheckVTableHasNoDuplicates(Thread* self,
6618 Handle<mirror::Class> klass,
6619 PointerSize pointer_size)
6620 REQUIRES_SHARED(Locks::mutator_lock_) {
6621 StackHandleScope<1> hs(self);
6622 Handle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
6623 int32_t num_entries = vtable->GetLength();
6624 for (int32_t i = 0; i < num_entries; i++) {
6625 ArtMethod* vtable_entry = vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
6626 // Don't bother if we cannot 'see' the vtable entry (i.e. it is a package-private member maybe).
6627 if (!klass->CanAccessMember(vtable_entry->GetDeclaringClass(),
6628 vtable_entry->GetAccessFlags())) {
6629 continue;
6630 }
6631 MethodNameAndSignatureComparator name_comparator(
6632 vtable_entry->GetInterfaceMethodIfProxy(pointer_size));
Alex Lightc7a420c2016-10-18 14:33:18 -07006633 for (int32_t j = i + 1; j < num_entries; j++) {
Alex Light1f3925d2016-09-07 12:04:20 -07006634 ArtMethod* other_entry = vtable->GetElementPtrSize<ArtMethod*>(j, pointer_size);
Alex Lightc7a420c2016-10-18 14:33:18 -07006635 if (!klass->CanAccessMember(other_entry->GetDeclaringClass(),
6636 other_entry->GetAccessFlags())) {
6637 continue;
6638 }
Alex Light1f3925d2016-09-07 12:04:20 -07006639 CHECK(vtable_entry != other_entry &&
6640 !name_comparator.HasSameNameAndSignature(
6641 other_entry->GetInterfaceMethodIfProxy(pointer_size)))
6642 << "vtable entries " << i << " and " << j << " are identical for "
Alex Lightc7a420c2016-10-18 14:33:18 -07006643 << klass->PrettyClass() << " in method " << vtable_entry->PrettyMethod() << " (0x"
6644 << std::hex << reinterpret_cast<uintptr_t>(vtable_entry) << ") and "
6645 << other_entry->PrettyMethod() << " (0x" << std::hex
6646 << reinterpret_cast<uintptr_t>(other_entry) << ")";
Alex Light1f3925d2016-09-07 12:04:20 -07006647 }
6648 }
6649}
6650
6651static void SanityCheckVTable(Thread* self, Handle<mirror::Class> klass, PointerSize pointer_size)
6652 REQUIRES_SHARED(Locks::mutator_lock_) {
6653 CheckClassOwnsVTableEntries(self, klass, pointer_size);
6654 CheckVTableHasNoDuplicates(self, klass, pointer_size);
6655}
6656
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006657void ClassLinker::FillImtFromSuperClass(Handle<mirror::Class> klass,
6658 ArtMethod* unimplemented_method,
6659 ArtMethod* imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006660 bool* new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006661 ArtMethod** imt) {
Alex Light705ad492015-09-21 11:36:30 -07006662 DCHECK(klass->HasSuperClass());
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006663 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006664 if (super_class->ShouldHaveImt()) {
6665 ImTable* super_imt = super_class->GetImt(image_pointer_size_);
6666 for (size_t i = 0; i < ImTable::kSize; ++i) {
6667 imt[i] = super_imt->Get(i, image_pointer_size_);
Alex Light705ad492015-09-21 11:36:30 -07006668 }
6669 } else {
6670 // No imt in the super class, need to reconstruct from the iftable.
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006671 ObjPtr<mirror::IfTable> if_table = super_class->GetIfTable();
Mathieu Chartier6beced42016-11-15 15:51:31 -08006672 if (if_table->Count() != 0) {
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006673 // Ignore copied methods since we will handle these in LinkInterfaceMethods.
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006674 FillIMTFromIfTable(if_table,
6675 unimplemented_method,
6676 imt_conflict_method,
6677 klass.Get(),
6678 /*create_conflict_table*/false,
6679 /*ignore_copied_methods*/true,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006680 /*out*/new_conflict,
Mathieu Chartiercdca4762016-04-28 09:44:54 -07006681 /*out*/imt);
Alex Light705ad492015-09-21 11:36:30 -07006682 }
6683 }
6684}
6685
6686// TODO This method needs to be split up into several smaller methods.
Alex Lighteb7c1442015-08-31 13:17:42 -07006687bool ClassLinker::LinkInterfaceMethods(
6688 Thread* self,
6689 Handle<mirror::Class> klass,
Alex Light9139e002015-10-09 15:59:48 -07006690 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006691 bool* out_new_conflict,
Alex Lighteb7c1442015-08-31 13:17:42 -07006692 ArtMethod** out_imt) {
6693 StackHandleScope<3> hs(self);
6694 Runtime* const runtime = Runtime::Current();
Alex Light705ad492015-09-21 11:36:30 -07006695
6696 const bool is_interface = klass->IsInterface();
Alex Lighteb7c1442015-08-31 13:17:42 -07006697 const bool has_superclass = klass->HasSuperClass();
Alex Light705ad492015-09-21 11:36:30 -07006698 const bool fill_tables = !is_interface;
Alex Lighteb7c1442015-08-31 13:17:42 -07006699 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U;
6700 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_);
6701 const size_t method_size = ArtMethod::Size(image_pointer_size_);
6702 const size_t ifcount = klass->GetIfTableCount();
6703
6704 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable()));
6705
Mathieu Chartiere401d142015-04-22 13:56:20 -07006706 // These are allocated on the heap to begin, we then transfer to linear alloc when we re-create
6707 // the virtual methods array.
6708 // Need to use low 4GB arenas for compiler or else the pointers wont fit in 32 bit method array
6709 // during cross compilation.
6710 // Use the linear alloc pool since this one is in the low 4gb for the compiler.
6711 ArenaStack stack(runtime->GetLinearAlloc()->GetArenaPool());
6712 ScopedArenaAllocator allocator(&stack);
Alex Light9139e002015-10-09 15:59:48 -07006713
6714 ScopedArenaVector<ArtMethod*> default_conflict_methods(allocator.Adapter());
Alex Light1f3925d2016-09-07 12:04:20 -07006715 ScopedArenaVector<ArtMethod*> overriding_default_conflict_methods(allocator.Adapter());
Mathieu Chartiere401d142015-04-22 13:56:20 -07006716 ScopedArenaVector<ArtMethod*> miranda_methods(allocator.Adapter());
Alex Lighteb7c1442015-08-31 13:17:42 -07006717 ScopedArenaVector<ArtMethod*> default_methods(allocator.Adapter());
Alex Light1f3925d2016-09-07 12:04:20 -07006718 ScopedArenaVector<ArtMethod*> overriding_default_methods(allocator.Adapter());
Mathieu Chartiere401d142015-04-22 13:56:20 -07006719
6720 MutableHandle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking()));
6721 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
Alex Light9139e002015-10-09 15:59:48 -07006722 ArtMethod* const imt_conflict_method = runtime->GetImtConflictMethod();
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006723 // Copy the IMT from the super class if possible.
Alex Light705ad492015-09-21 11:36:30 -07006724 const bool extend_super_iftable = has_superclass;
6725 if (has_superclass && fill_tables) {
6726 FillImtFromSuperClass(klass,
Alex Light705ad492015-09-21 11:36:30 -07006727 unimplemented_method,
6728 imt_conflict_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006729 out_new_conflict,
Mathieu Chartier49b5ced2016-04-14 10:49:19 -07006730 out_imt);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006731 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07006732 // Allocate method arrays before since we don't want miss visiting miranda method roots due to
6733 // thread suspension.
Alex Light705ad492015-09-21 11:36:30 -07006734 if (fill_tables) {
6735 for (size_t i = 0; i < ifcount; ++i) {
6736 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods();
6737 if (num_methods > 0) {
6738 const bool is_super = i < super_ifcount;
6739 // This is an interface implemented by a super-class. Therefore we can just copy the method
6740 // array from the superclass.
6741 const bool super_interface = is_super && extend_super_iftable;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006742 ObjPtr<mirror::PointerArray> method_array;
Alex Light705ad492015-09-21 11:36:30 -07006743 if (super_interface) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07006744 ObjPtr<mirror::IfTable> if_table = klass->GetSuperClass()->GetIfTable();
Alex Light705ad492015-09-21 11:36:30 -07006745 DCHECK(if_table != nullptr);
6746 DCHECK(if_table->GetMethodArray(i) != nullptr);
6747 // If we are working on a super interface, try extending the existing method array.
6748 method_array = down_cast<mirror::PointerArray*>(if_table->GetMethodArray(i)->Clone(self));
6749 } else {
6750 method_array = AllocPointerArray(self, num_methods);
6751 }
6752 if (UNLIKELY(method_array == nullptr)) {
6753 self->AssertPendingOOMException();
6754 return false;
6755 }
6756 iftable->SetMethodArray(i, method_array);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006757 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07006758 }
6759 }
6760
Igor Murashkinb1d8c312015-08-04 11:18:43 -07006761 auto* old_cause = self->StartAssertNoThreadSuspension(
Mathieu Chartiere401d142015-04-22 13:56:20 -07006762 "Copying ArtMethods for LinkInterfaceMethods");
Alex Light9139e002015-10-09 15:59:48 -07006763 // Going in reverse to ensure that we will hit abstract methods that override defaults before the
6764 // defaults. This means we don't need to do any trickery when creating the Miranda methods, since
6765 // they will already be null. This has the additional benefit that the declarer of a miranda
6766 // method will actually declare an abstract method.
6767 for (size_t i = ifcount; i != 0; ) {
6768 --i;
6769
6770 DCHECK_GE(i, 0u);
6771 DCHECK_LT(i, ifcount);
6772
Alex Light705ad492015-09-21 11:36:30 -07006773 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods();
Mathieu Chartiere401d142015-04-22 13:56:20 -07006774 if (num_methods > 0) {
6775 StackHandleScope<2> hs2(self);
6776 const bool is_super = i < super_ifcount;
6777 const bool super_interface = is_super && extend_super_iftable;
Alex Light705ad492015-09-21 11:36:30 -07006778 // We don't actually create or fill these tables for interfaces, we just copy some methods for
6779 // conflict methods. Just set this as nullptr in those cases.
6780 Handle<mirror::PointerArray> method_array(fill_tables
6781 ? hs2.NewHandle(iftable->GetMethodArray(i))
6782 : hs2.NewHandle<mirror::PointerArray>(nullptr));
Mathieu Chartiere401d142015-04-22 13:56:20 -07006783
Alex Lighte64300b2015-12-15 15:02:47 -08006784 ArraySlice<ArtMethod> input_virtual_methods;
Mathieu Chartier9865bde2015-12-21 09:58:16 -08006785 ScopedNullHandle<mirror::PointerArray> null_handle;
6786 Handle<mirror::PointerArray> input_vtable_array(null_handle);
Mathieu Chartiere401d142015-04-22 13:56:20 -07006787 int32_t input_array_length = 0;
Alex Lighte64300b2015-12-15 15:02:47 -08006788
Alex Light9139e002015-10-09 15:59:48 -07006789 // TODO Cleanup Needed: In the presence of default methods this optimization is rather dirty
6790 // and confusing. Default methods should always look through all the superclasses
6791 // because they are the last choice of an implementation. We get around this by looking
6792 // at the super-classes iftable methods (copied into method_array previously) when we are
6793 // looking for the implementation of a super-interface method but that is rather dirty.
Alex Lighte64300b2015-12-15 15:02:47 -08006794 bool using_virtuals;
Alex Light705ad492015-09-21 11:36:30 -07006795 if (super_interface || is_interface) {
Alex Lighte64300b2015-12-15 15:02:47 -08006796 // If we are overwriting a super class interface, try to only virtual methods instead of the
Mathieu Chartiere401d142015-04-22 13:56:20 -07006797 // whole vtable.
Alex Lighte64300b2015-12-15 15:02:47 -08006798 using_virtuals = true;
6799 input_virtual_methods = klass->GetDeclaredMethodsSlice(image_pointer_size_);
6800 input_array_length = input_virtual_methods.size();
Mathieu Chartiere401d142015-04-22 13:56:20 -07006801 } else {
Alex Lighte64300b2015-12-15 15:02:47 -08006802 // For a new interface, however, we need the whole vtable in case a new
6803 // interface method is implemented in the whole superclass.
6804 using_virtuals = false;
Alex Light705ad492015-09-21 11:36:30 -07006805 DCHECK(vtable.Get() != nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07006806 input_vtable_array = vtable;
6807 input_array_length = input_vtable_array->GetLength();
6808 }
Alex Lighte64300b2015-12-15 15:02:47 -08006809
Alex Lighteb7c1442015-08-31 13:17:42 -07006810 // For each method in interface
Ian Rogers62d6c772013-02-27 08:32:07 -08006811 for (size_t j = 0; j < num_methods; ++j) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07006812 auto* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j, image_pointer_size_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006813 MethodNameAndSignatureComparator interface_name_comparator(
Mathieu Chartiere401d142015-04-22 13:56:20 -07006814 interface_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Andreas Gampe75a7db62016-09-26 12:04:26 -07006815 uint32_t imt_index = ImTable::GetImtIndex(interface_method);
Alex Lighteb7c1442015-08-31 13:17:42 -07006816 ArtMethod** imt_ptr = &out_imt[imt_index];
Ian Rogers9bc81912012-10-11 21:43:36 -07006817 // For each method listed in the interface's method list, find the
6818 // matching method in our class's method list. We want to favor the
6819 // subclass over the superclass, which just requires walking
6820 // back from the end of the vtable. (This only matters if the
6821 // superclass defines a private method and this class redefines
6822 // it -- otherwise it would use the same vtable slot. In .dex files
6823 // those don't end up in the virtual method table, so it shouldn't
6824 // matter which direction we go. We walk it backward anyway.)
Alex Lighteb7c1442015-08-31 13:17:42 -07006825 //
6826 // To find defaults we need to do the same but also go over interfaces.
6827 bool found_impl = false;
Alex Light9139e002015-10-09 15:59:48 -07006828 ArtMethod* vtable_impl = nullptr;
Alex Lighteb7c1442015-08-31 13:17:42 -07006829 for (int32_t k = input_array_length - 1; k >= 0; --k) {
Alex Lighte64300b2015-12-15 15:02:47 -08006830 ArtMethod* vtable_method = using_virtuals ?
6831 &input_virtual_methods[k] :
Mathieu Chartiere401d142015-04-22 13:56:20 -07006832 input_vtable_array->GetElementPtrSize<ArtMethod*>(k, image_pointer_size_);
6833 ArtMethod* vtable_method_for_name_comparison =
6834 vtable_method->GetInterfaceMethodIfProxy(image_pointer_size_);
Ian Rogers03b6eaf2014-10-28 09:34:57 -07006835 if (interface_name_comparator.HasSameNameAndSignature(
Mathieu Chartier9f3629d2014-10-28 18:23:02 -07006836 vtable_method_for_name_comparison)) {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07006837 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
Mathieu Chartier4d122c12015-06-17 14:14:36 -07006838 // Must do EndAssertNoThreadSuspension before throw since the throw can cause
6839 // allocations.
6840 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartiere401d142015-04-22 13:56:20 -07006841 ThrowIllegalAccessError(klass.Get(),
Brian Carlstromf3632832014-05-20 15:36:53 -07006842 "Method '%s' implementing interface method '%s' is not public",
David Sehr709b0702016-10-13 09:12:37 -07006843 vtable_method->PrettyMethod().c_str(),
6844 interface_method->PrettyMethod().c_str());
Ian Rogers9bc81912012-10-11 21:43:36 -07006845 return false;
Alex Light9139e002015-10-09 15:59:48 -07006846 } else if (UNLIKELY(vtable_method->IsOverridableByDefaultMethod())) {
Alex Lighteb7c1442015-08-31 13:17:42 -07006847 // We might have a newer, better, default method for this, so we just skip it. If we
6848 // are still using this we will select it again when scanning for default methods. To
6849 // obviate the need to copy the method again we will make a note that we already found
6850 // a default here.
6851 // TODO This should be much cleaner.
Alex Light9139e002015-10-09 15:59:48 -07006852 vtable_impl = vtable_method;
Alex Lighteb7c1442015-08-31 13:17:42 -07006853 break;
6854 } else {
6855 found_impl = true;
Alex Light705ad492015-09-21 11:36:30 -07006856 if (LIKELY(fill_tables)) {
6857 method_array->SetElementPtrSize(j, vtable_method, image_pointer_size_);
6858 // Place method in imt if entry is empty, place conflict otherwise.
6859 SetIMTRef(unimplemented_method,
6860 imt_conflict_method,
Alex Light705ad492015-09-21 11:36:30 -07006861 vtable_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00006862 /*out*/out_new_conflict,
Alex Light705ad492015-09-21 11:36:30 -07006863 /*out*/imt_ptr);
6864 }
Ian Rogers9bc81912012-10-11 21:43:36 -07006865 break;
6866 }
6867 }
Alex Light9139e002015-10-09 15:59:48 -07006868 }
6869 // Continue on to the next method if we are done.
6870 if (LIKELY(found_impl)) {
6871 continue;
6872 } else if (LIKELY(super_interface)) {
6873 // Don't look for a default implementation when the super-method is implemented directly
6874 // by the class.
6875 //
6876 // See if we can use the superclasses method and skip searching everything else.
6877 // Note: !found_impl && super_interface
6878 CHECK(extend_super_iftable);
6879 // If this is a super_interface method it is possible we shouldn't override it because a
6880 // superclass could have implemented it directly. We get the method the superclass used
6881 // to implement this to know if we can override it with a default method. Doing this is
6882 // safe since we know that the super_iftable is filled in so we can simply pull it from
6883 // there. We don't bother if this is not a super-classes interface since in that case we
6884 // have scanned the entire vtable anyway and would have found it.
6885 // TODO This is rather dirty but it is faster than searching through the entire vtable
6886 // every time.
6887 ArtMethod* supers_method =
6888 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
6889 DCHECK(supers_method != nullptr);
6890 DCHECK(interface_name_comparator.HasSameNameAndSignature(supers_method));
Alex Light705ad492015-09-21 11:36:30 -07006891 if (LIKELY(!supers_method->IsOverridableByDefaultMethod())) {
Alex Light9139e002015-10-09 15:59:48 -07006892 // The method is not overridable by a default method (i.e. it is directly implemented
6893 // in some class). Therefore move onto the next interface method.
6894 continue;
Alex Lightd6c2bfa2016-05-02 18:51:34 -07006895 } else {
6896 // If the super-classes method is override-able by a default method we need to keep
6897 // track of it since though it is override-able it is not guaranteed to be 'overridden'.
6898 // 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 -07006899 // to the vtable twice, causing corruption (vtable entries having inconsistent and
6900 // illegal states, incorrect vtable size, and incorrect or inconsistent iftable entries)
6901 // in this class and any subclasses.
Alex Lightd6c2bfa2016-05-02 18:51:34 -07006902 DCHECK(vtable_impl == nullptr || vtable_impl == supers_method)
David Sehr709b0702016-10-13 09:12:37 -07006903 << "vtable_impl was " << ArtMethod::PrettyMethod(vtable_impl)
6904 << " and not 'nullptr' or "
6905 << supers_method->PrettyMethod()
6906 << " as expected. IFTable appears to be corrupt!";
Alex Lightd6c2bfa2016-05-02 18:51:34 -07006907 vtable_impl = supers_method;
Alex Light9139e002015-10-09 15:59:48 -07006908 }
6909 }
6910 // If we haven't found it yet we should search through the interfaces for default methods.
6911 ArtMethod* current_method = nullptr;
6912 switch (FindDefaultMethodImplementation(self,
6913 interface_method,
6914 klass,
6915 /*out*/&current_method)) {
6916 case DefaultMethodSearchResult::kDefaultConflict: {
6917 // Default method conflict.
6918 DCHECK(current_method == nullptr);
6919 ArtMethod* default_conflict_method = nullptr;
6920 if (vtable_impl != nullptr && vtable_impl->IsDefaultConflicting()) {
6921 // We can reuse the method from the superclass, don't bother adding it to virtuals.
6922 default_conflict_method = vtable_impl;
6923 } else {
6924 // See if we already have a conflict method for this method.
Alex Light1f3925d2016-09-07 12:04:20 -07006925 ArtMethod* preexisting_conflict = FindSameNameAndSignature(
6926 interface_name_comparator,
6927 default_conflict_methods,
6928 overriding_default_conflict_methods);
Alex Light9139e002015-10-09 15:59:48 -07006929 if (LIKELY(preexisting_conflict != nullptr)) {
6930 // We already have another conflict we can reuse.
6931 default_conflict_method = preexisting_conflict;
6932 } else {
Alex Light705ad492015-09-21 11:36:30 -07006933 // Note that we do this even if we are an interface since we need to create this and
6934 // cannot reuse another classes.
Alex Light9139e002015-10-09 15:59:48 -07006935 // Create a new conflict method for this to use.
6936 default_conflict_method =
6937 reinterpret_cast<ArtMethod*>(allocator.Alloc(method_size));
6938 new(default_conflict_method) ArtMethod(interface_method, image_pointer_size_);
Alex Light1f3925d2016-09-07 12:04:20 -07006939 if (vtable_impl == nullptr) {
6940 // Save the conflict method. We need to add it to the vtable.
6941 default_conflict_methods.push_back(default_conflict_method);
6942 } else {
6943 // Save the conflict method but it is already in the vtable.
6944 overriding_default_conflict_methods.push_back(default_conflict_method);
6945 }
Alex Light9139e002015-10-09 15:59:48 -07006946 }
6947 }
6948 current_method = default_conflict_method;
6949 break;
Alex Light705ad492015-09-21 11:36:30 -07006950 } // case kDefaultConflict
Alex Light9139e002015-10-09 15:59:48 -07006951 case DefaultMethodSearchResult::kDefaultFound: {
6952 DCHECK(current_method != nullptr);
6953 // Found a default method.
6954 if (vtable_impl != nullptr &&
6955 current_method->GetDeclaringClass() == vtable_impl->GetDeclaringClass()) {
6956 // We found a default method but it was the same one we already have from our
6957 // superclass. Don't bother adding it to our vtable again.
6958 current_method = vtable_impl;
Alex Light705ad492015-09-21 11:36:30 -07006959 } else if (LIKELY(fill_tables)) {
6960 // Interfaces don't need to copy default methods since they don't have vtables.
Alex Light9139e002015-10-09 15:59:48 -07006961 // Only record this default method if it is new to save space.
Alex Light705ad492015-09-21 11:36:30 -07006962 // TODO It might be worthwhile to copy default methods on interfaces anyway since it
6963 // would make lookup for interface super much faster. (We would only need to scan
6964 // the iftable to find if there is a NSME or AME.)
Alex Light1f3925d2016-09-07 12:04:20 -07006965 ArtMethod* old = FindSameNameAndSignature(interface_name_comparator,
6966 default_methods,
6967 overriding_default_methods);
Alex Light9139e002015-10-09 15:59:48 -07006968 if (old == nullptr) {
6969 // We found a default method implementation and there were no conflicts.
Alex Light1f3925d2016-09-07 12:04:20 -07006970 if (vtable_impl == nullptr) {
6971 // Save the default method. We need to add it to the vtable.
6972 default_methods.push_back(current_method);
6973 } else {
6974 // Save the default method but it is already in the vtable.
6975 overriding_default_methods.push_back(current_method);
6976 }
Alex Light9139e002015-10-09 15:59:48 -07006977 } else {
6978 CHECK(old == current_method) << "Multiple default implementations selected!";
6979 }
6980 }
6981 break;
Alex Light705ad492015-09-21 11:36:30 -07006982 } // case kDefaultFound
Alex Light9139e002015-10-09 15:59:48 -07006983 case DefaultMethodSearchResult::kAbstractFound: {
6984 DCHECK(current_method == nullptr);
6985 // Abstract method masks all defaults.
6986 if (vtable_impl != nullptr &&
6987 vtable_impl->IsAbstract() &&
6988 !vtable_impl->IsDefaultConflicting()) {
6989 // We need to make this an abstract method but the version in the vtable already is so
6990 // don't do anything.
6991 current_method = vtable_impl;
6992 }
6993 break;
Alex Light705ad492015-09-21 11:36:30 -07006994 } // case kAbstractFound
6995 }
6996 if (LIKELY(fill_tables)) {
Alex Light12771082016-01-26 16:07:41 -08006997 if (current_method == nullptr && !super_interface) {
Alex Light705ad492015-09-21 11:36:30 -07006998 // We could not find an implementation for this method and since it is a brand new
6999 // interface we searched the entire vtable (and all default methods) for an
7000 // implementation but couldn't find one. We therefore need to make a miranda method.
7001 //
7002 // Find out if there is already a miranda method we can use.
7003 ArtMethod* miranda_method = FindSameNameAndSignature(interface_name_comparator,
7004 miranda_methods);
7005 if (miranda_method == nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07007006 DCHECK(interface_method->IsAbstract()) << interface_method->PrettyMethod();
Alex Light705ad492015-09-21 11:36:30 -07007007 miranda_method = reinterpret_cast<ArtMethod*>(allocator.Alloc(method_size));
7008 CHECK(miranda_method != nullptr);
7009 // Point the interface table at a phantom slot.
7010 new(miranda_method) ArtMethod(interface_method, image_pointer_size_);
7011 miranda_methods.push_back(miranda_method);
7012 }
Alex Light12771082016-01-26 16:07:41 -08007013 current_method = miranda_method;
7014 }
7015
7016 if (current_method != nullptr) {
7017 // We found a default method implementation. Record it in the iftable and IMT.
7018 method_array->SetElementPtrSize(j, current_method, image_pointer_size_);
7019 SetIMTRef(unimplemented_method,
7020 imt_conflict_method,
Alex Light12771082016-01-26 16:07:41 -08007021 current_method,
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007022 /*out*/out_new_conflict,
Alex Light12771082016-01-26 16:07:41 -08007023 /*out*/imt_ptr);
Alex Light9139e002015-10-09 15:59:48 -07007024 }
7025 }
Alex Light705ad492015-09-21 11:36:30 -07007026 } // For each method in interface end.
7027 } // if (num_methods > 0)
7028 } // For each interface.
7029 const bool has_new_virtuals = !(miranda_methods.empty() &&
7030 default_methods.empty() &&
Alex Light1f3925d2016-09-07 12:04:20 -07007031 overriding_default_methods.empty() &&
7032 overriding_default_conflict_methods.empty() &&
Alex Light705ad492015-09-21 11:36:30 -07007033 default_conflict_methods.empty());
7034 // TODO don't extend virtuals of interface unless necessary (when is it?).
7035 if (has_new_virtuals) {
7036 DCHECK(!is_interface || (default_methods.empty() && miranda_methods.empty()))
7037 << "Interfaces should only have default-conflict methods appended to them.";
David Sehr709b0702016-10-13 09:12:37 -07007038 VLOG(class_linker) << mirror::Class::PrettyClass(klass.Get()) << ": miranda_methods="
7039 << miranda_methods.size()
Alex Light9139e002015-10-09 15:59:48 -07007040 << " default_methods=" << default_methods.size()
Alex Light1f3925d2016-09-07 12:04:20 -07007041 << " overriding_default_methods=" << overriding_default_methods.size()
7042 << " default_conflict_methods=" << default_conflict_methods.size()
7043 << " overriding_default_conflict_methods="
7044 << overriding_default_conflict_methods.size();
Alex Lighte64300b2015-12-15 15:02:47 -08007045 const size_t old_method_count = klass->NumMethods();
Alex Light9139e002015-10-09 15:59:48 -07007046 const size_t new_method_count = old_method_count +
7047 miranda_methods.size() +
7048 default_methods.size() +
Alex Light1f3925d2016-09-07 12:04:20 -07007049 overriding_default_conflict_methods.size() +
7050 overriding_default_methods.size() +
Alex Light9139e002015-10-09 15:59:48 -07007051 default_conflict_methods.size();
Mathieu Chartiere401d142015-04-22 13:56:20 -07007052 // Attempt to realloc to save RAM if possible.
Alex Lighte64300b2015-12-15 15:02:47 -08007053 LengthPrefixedArray<ArtMethod>* old_methods = klass->GetMethodsPtr();
7054 // The Realloced virtual methods aren't visible from the class roots, so there is no issue
Mathieu Chartiere401d142015-04-22 13:56:20 -07007055 // where GCs could attempt to mark stale pointers due to memcpy. And since we overwrite the
7056 // realloced memory with out->CopyFrom, we are guaranteed to have objects in the to space since
7057 // CopyFrom has internal read barriers.
Alex Lighte64300b2015-12-15 15:02:47 -08007058 //
7059 // TODO We should maybe move some of this into mirror::Class or at least into another method.
7060 const size_t old_size = LengthPrefixedArray<ArtMethod>::ComputeSize(old_method_count,
7061 method_size,
7062 method_alignment);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007063 const size_t new_size = LengthPrefixedArray<ArtMethod>::ComputeSize(new_method_count,
Vladimir Markocf36d492015-08-12 19:27:26 +01007064 method_size,
7065 method_alignment);
Alex Lighte64300b2015-12-15 15:02:47 -08007066 const size_t old_methods_ptr_size = (old_methods != nullptr) ? old_size : 0;
7067 auto* methods = reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
7068 runtime->GetLinearAlloc()->Realloc(self, old_methods, old_methods_ptr_size, new_size));
7069 if (UNLIKELY(methods == nullptr)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007070 self->AssertPendingOOMException();
Mathieu Chartier4e2cb092015-07-22 16:17:51 -07007071 self->EndAssertNoThreadSuspension(old_cause);
Ian Rogersa436fde2013-08-27 23:34:06 -07007072 return false;
7073 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07007074 ScopedArenaUnorderedMap<ArtMethod*, ArtMethod*> move_table(allocator.Adapter());
Alex Lighte64300b2015-12-15 15:02:47 -08007075 if (methods != old_methods) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007076 // Maps from heap allocated miranda method to linear alloc miranda method.
Alex Lighte64300b2015-12-15 15:02:47 -08007077 StrideIterator<ArtMethod> out = methods->begin(method_size, method_alignment);
7078 // Copy over the old methods.
7079 for (auto& m : klass->GetMethods(image_pointer_size_)) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007080 move_table.emplace(&m, &*out);
7081 // The CopyFrom is only necessary to not miss read barriers since Realloc won't do read
7082 // barriers when it copies.
7083 out->CopyFrom(&m, image_pointer_size_);
7084 ++out;
7085 }
7086 }
Alex Lighte64300b2015-12-15 15:02:47 -08007087 StrideIterator<ArtMethod> out(methods->begin(method_size, method_alignment) + old_method_count);
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007088 // Copy over miranda methods before copying vtable since CopyOf may cause thread suspension and
7089 // we want the roots of the miranda methods to get visited.
7090 for (ArtMethod* mir_method : miranda_methods) {
Alex Lighteb7c1442015-08-31 13:17:42 -07007091 ArtMethod& new_method = *out;
7092 new_method.CopyFrom(mir_method, image_pointer_size_);
Alex Light36121492016-02-22 13:43:29 -08007093 new_method.SetAccessFlags(new_method.GetAccessFlags() | kAccMiranda | kAccCopied);
Alex Lighteb7c1442015-08-31 13:17:42 -07007094 DCHECK_NE(new_method.GetAccessFlags() & kAccAbstract, 0u)
7095 << "Miranda method should be abstract!";
7096 move_table.emplace(mir_method, &new_method);
7097 ++out;
7098 }
Alex Lighte64300b2015-12-15 15:02:47 -08007099 // We need to copy the default methods into our own method table since the runtime requires that
7100 // every method on a class's vtable be in that respective class's virtual method table.
Alex Lighteb7c1442015-08-31 13:17:42 -07007101 // NOTE This means that two classes might have the same implementation of a method from the same
7102 // interface but will have different ArtMethod*s for them. This also means we cannot compare a
7103 // default method found on a class with one found on the declaring interface directly and must
7104 // look at the declaring class to determine if they are the same.
Alex Light1f3925d2016-09-07 12:04:20 -07007105 for (const ScopedArenaVector<ArtMethod*>& methods_vec : {default_methods,
7106 overriding_default_methods}) {
7107 for (ArtMethod* def_method : methods_vec) {
7108 ArtMethod& new_method = *out;
7109 new_method.CopyFrom(def_method, image_pointer_size_);
7110 // Clear the kAccSkipAccessChecks flag if it is present. Since this class hasn't been
7111 // verified yet it shouldn't have methods that are skipping access checks.
7112 // TODO This is rather arbitrary. We should maybe support classes where only some of its
7113 // methods are skip_access_checks.
7114 constexpr uint32_t kSetFlags = kAccDefault | kAccCopied;
7115 constexpr uint32_t kMaskFlags = ~kAccSkipAccessChecks;
7116 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags);
7117 move_table.emplace(def_method, &new_method);
7118 ++out;
7119 }
Mathieu Chartiercf3b1a32015-06-01 14:30:06 -07007120 }
Alex Light1f3925d2016-09-07 12:04:20 -07007121 for (const ScopedArenaVector<ArtMethod*>& methods_vec : {default_conflict_methods,
7122 overriding_default_conflict_methods}) {
7123 for (ArtMethod* conf_method : methods_vec) {
7124 ArtMethod& new_method = *out;
7125 new_method.CopyFrom(conf_method, image_pointer_size_);
7126 // This is a type of default method (there are default method impls, just a conflict) so
7127 // mark this as a default, non-abstract method, since thats what it is. Also clear the
7128 // kAccSkipAccessChecks bit since this class hasn't been verified yet it shouldn't have
7129 // methods that are skipping access checks.
7130 constexpr uint32_t kSetFlags = kAccDefault | kAccDefaultConflict | kAccCopied;
7131 constexpr uint32_t kMaskFlags = ~(kAccAbstract | kAccSkipAccessChecks);
7132 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags);
7133 DCHECK(new_method.IsDefaultConflicting());
7134 // The actual method might or might not be marked abstract since we just copied it from a
7135 // (possibly default) interface method. We need to set it entry point to be the bridge so
7136 // that the compiler will not invoke the implementation of whatever method we copied from.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +01007137 EnsureThrowsInvocationError(this, &new_method);
Alex Light1f3925d2016-09-07 12:04:20 -07007138 move_table.emplace(conf_method, &new_method);
7139 ++out;
7140 }
Alex Light9139e002015-10-09 15:59:48 -07007141 }
Alex Lighte64300b2015-12-15 15:02:47 -08007142 methods->SetSize(new_method_count);
7143 UpdateClassMethods(klass.Get(), methods);
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007144 // 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 -07007145 // suspension assert.
7146 self->EndAssertNoThreadSuspension(old_cause);
Mathieu Chartierd4d83b82015-06-19 20:24:45 -07007147
Alex Light705ad492015-09-21 11:36:30 -07007148 if (fill_tables) {
7149 // Update the vtable to the new method structures. We can skip this for interfaces since they
7150 // do not have vtables.
7151 const size_t old_vtable_count = vtable->GetLength();
7152 const size_t new_vtable_count = old_vtable_count +
7153 miranda_methods.size() +
7154 default_methods.size() +
7155 default_conflict_methods.size();
Alex Light1f3925d2016-09-07 12:04:20 -07007156
Alex Light705ad492015-09-21 11:36:30 -07007157 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, new_vtable_count)));
7158 if (UNLIKELY(vtable.Get() == nullptr)) {
7159 self->AssertPendingOOMException();
7160 return false;
7161 }
Alex Light705ad492015-09-21 11:36:30 -07007162 size_t vtable_pos = old_vtable_count;
7163 // Update all the newly copied method's indexes so they denote their placement in the vtable.
Alex Light1f3925d2016-09-07 12:04:20 -07007164 for (const ScopedArenaVector<ArtMethod*>& methods_vec : {default_methods,
7165 default_conflict_methods,
7166 miranda_methods}) {
7167 // These are the functions that are not already in the vtable!
7168 for (ArtMethod* new_method : methods_vec) {
7169 auto translated_method_it = move_table.find(new_method);
7170 CHECK(translated_method_it != move_table.end())
7171 << "We must have a translation for methods added to the classes methods_ array! We "
David Sehr709b0702016-10-13 09:12:37 -07007172 << "could not find the ArtMethod added for " << ArtMethod::PrettyMethod(new_method);
Alex Light1f3925d2016-09-07 12:04:20 -07007173 ArtMethod* new_vtable_method = translated_method_it->second;
7174 // Leave the declaring class alone the method's dex_code_item_offset_ and dex_method_index_
7175 // fields are references into the dex file the method was defined in. Since the ArtMethod
7176 // does not store that information it uses declaring_class_->dex_cache_.
7177 new_vtable_method->SetMethodIndex(0xFFFF & vtable_pos);
7178 vtable->SetElementPtrSize(vtable_pos, new_vtable_method, image_pointer_size_);
7179 ++vtable_pos;
7180 }
Alex Light705ad492015-09-21 11:36:30 -07007181 }
7182 CHECK_EQ(vtable_pos, new_vtable_count);
7183 // Update old vtable methods. We use the default_translations map to figure out what each
7184 // vtable entry should be updated to, if they need to be at all.
7185 for (size_t i = 0; i < old_vtable_count; ++i) {
7186 ArtMethod* translated_method = vtable->GetElementPtrSize<ArtMethod*>(
7187 i, image_pointer_size_);
7188 // Try and find what we need to change this method to.
7189 auto translation_it = default_translations.find(i);
7190 bool found_translation = false;
7191 if (translation_it != default_translations.end()) {
7192 if (translation_it->second.IsInConflict()) {
7193 // Find which conflict method we are to use for this method.
7194 MethodNameAndSignatureComparator old_method_comparator(
7195 translated_method->GetInterfaceMethodIfProxy(image_pointer_size_));
Alex Light1f3925d2016-09-07 12:04:20 -07007196 // We only need to look through overriding_default_conflict_methods since this is an
7197 // overridden method we are fixing up here.
7198 ArtMethod* new_conflict_method = FindSameNameAndSignature(
7199 old_method_comparator, overriding_default_conflict_methods);
Alex Light705ad492015-09-21 11:36:30 -07007200 CHECK(new_conflict_method != nullptr) << "Expected a conflict method!";
7201 translated_method = new_conflict_method;
7202 } else if (translation_it->second.IsAbstract()) {
7203 // Find which miranda method we are to use for this method.
7204 MethodNameAndSignatureComparator old_method_comparator(
7205 translated_method->GetInterfaceMethodIfProxy(image_pointer_size_));
7206 ArtMethod* miranda_method = FindSameNameAndSignature(old_method_comparator,
Alex Light1f3925d2016-09-07 12:04:20 -07007207 miranda_methods);
Alex Light705ad492015-09-21 11:36:30 -07007208 DCHECK(miranda_method != nullptr);
7209 translated_method = miranda_method;
7210 } else {
7211 // Normal default method (changed from an older default or abstract interface method).
7212 DCHECK(translation_it->second.IsTranslation());
7213 translated_method = translation_it->second.GetTranslation();
7214 }
7215 found_translation = true;
Alex Light9139e002015-10-09 15:59:48 -07007216 }
Alex Light705ad492015-09-21 11:36:30 -07007217 DCHECK(translated_method != nullptr);
7218 auto it = move_table.find(translated_method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007219 if (it != move_table.end()) {
Alex Light705ad492015-09-21 11:36:30 -07007220 auto* new_method = it->second;
7221 DCHECK(new_method != nullptr);
Alex Light1f3925d2016-09-07 12:04:20 -07007222 // Make sure the new_methods index is set.
7223 if (new_method->GetMethodIndexDuringLinking() != i) {
7224 DCHECK_LE(reinterpret_cast<uintptr_t>(&*methods->begin(method_size, method_alignment)),
7225 reinterpret_cast<uintptr_t>(new_method));
7226 DCHECK_LT(reinterpret_cast<uintptr_t>(new_method),
7227 reinterpret_cast<uintptr_t>(&*methods->end(method_size, method_alignment)));
7228 new_method->SetMethodIndex(0xFFFF & i);
7229 }
Alex Light705ad492015-09-21 11:36:30 -07007230 vtable->SetElementPtrSize(i, new_method, image_pointer_size_);
7231 } else {
7232 // If it was not going to be updated we wouldn't have put it into the default_translations
7233 // map.
7234 CHECK(!found_translation) << "We were asked to update this vtable entry. Must not fail.";
7235 }
7236 }
7237 klass->SetVTable(vtable.Get());
7238
7239 // Go fix up all the stale iftable pointers.
7240 for (size_t i = 0; i < ifcount; ++i) {
7241 for (size_t j = 0, count = iftable->GetMethodArrayCount(i); j < count; ++j) {
7242 auto* method_array = iftable->GetMethodArray(i);
7243 auto* m = method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_);
David Sehr709b0702016-10-13 09:12:37 -07007244 DCHECK(m != nullptr) << klass->PrettyClass();
Alex Light705ad492015-09-21 11:36:30 -07007245 auto it = move_table.find(m);
7246 if (it != move_table.end()) {
7247 auto* new_m = it->second;
David Sehr709b0702016-10-13 09:12:37 -07007248 DCHECK(new_m != nullptr) << klass->PrettyClass();
Alex Light705ad492015-09-21 11:36:30 -07007249 method_array->SetElementPtrSize(j, new_m, image_pointer_size_);
7250 }
7251 }
7252 }
7253
7254 // Fix up IMT next
Artem Udovichenkoa62cb9b2016-06-30 09:18:25 +00007255 for (size_t i = 0; i < ImTable::kSize; ++i) {
Alex Light705ad492015-09-21 11:36:30 -07007256 auto it = move_table.find(out_imt[i]);
7257 if (it != move_table.end()) {
7258 out_imt[i] = it->second;
Mathieu Chartiere401d142015-04-22 13:56:20 -07007259 }
7260 }
7261 }
Alex Light705ad492015-09-21 11:36:30 -07007262
Mathieu Chartiere401d142015-04-22 13:56:20 -07007263 // Check that there are no stale methods are in the dex cache array.
7264 if (kIsDebugBuild) {
7265 auto* resolved_methods = klass->GetDexCache()->GetResolvedMethods();
Vladimir Marko05792b92015-08-03 11:56:49 +01007266 for (size_t i = 0, count = klass->GetDexCache()->NumResolvedMethods(); i < count; ++i) {
7267 auto* m = mirror::DexCache::GetElementPtrSize(resolved_methods, i, image_pointer_size_);
Alex Lighte64300b2015-12-15 15:02:47 -08007268 CHECK(move_table.find(m) == move_table.end() ||
7269 // The original versions of copied methods will still be present so allow those too.
7270 // Note that if the first check passes this might fail to GetDeclaringClass().
7271 std::find_if(m->GetDeclaringClass()->GetMethods(image_pointer_size_).begin(),
7272 m->GetDeclaringClass()->GetMethods(image_pointer_size_).end(),
7273 [m] (ArtMethod& meth) {
7274 return &meth == m;
7275 }) != m->GetDeclaringClass()->GetMethods(image_pointer_size_).end())
David Sehr709b0702016-10-13 09:12:37 -07007276 << "Obsolete methods " << m->PrettyMethod() << " is in dex cache!";
Mathieu Chartiere401d142015-04-22 13:56:20 -07007277 }
7278 }
Alex Lighte64300b2015-12-15 15:02:47 -08007279 // Put some random garbage in old methods to help find stale pointers.
Mathieu Chartier1b1e31f2016-05-19 10:13:04 -07007280 if (methods != old_methods && old_methods != nullptr && kIsDebugBuild) {
7281 // Need to make sure the GC is not running since it could be scanning the methods we are
7282 // about to overwrite.
7283 ScopedThreadStateChange tsc(self, kSuspended);
7284 gc::ScopedGCCriticalSection gcs(self,
7285 gc::kGcCauseClassLinker,
7286 gc::kCollectorTypeClassLinker);
Alex Lighte64300b2015-12-15 15:02:47 -08007287 memset(old_methods, 0xFEu, old_size);
Mathieu Chartiere401d142015-04-22 13:56:20 -07007288 }
7289 } else {
7290 self->EndAssertNoThreadSuspension(old_cause);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007291 }
Alex Light705ad492015-09-21 11:36:30 -07007292 if (kIsDebugBuild && !is_interface) {
Alex Light1f3925d2016-09-07 12:04:20 -07007293 SanityCheckVTable(self, klass, image_pointer_size_);
Elliott Hughes4681c802011-09-25 18:04:37 -07007294 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007295 return true;
7296}
7297
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007298bool ClassLinker::LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007299 CHECK(klass.Get() != nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007300 return LinkFields(self, klass, false, nullptr);
Brian Carlstrom4873d462011-08-21 15:23:39 -07007301}
7302
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007303bool ClassLinker::LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007304 CHECK(klass.Get() != nullptr);
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007305 return LinkFields(self, klass, true, class_size);
Brian Carlstrom4873d462011-08-21 15:23:39 -07007306}
7307
Brian Carlstromdbc05252011-09-09 01:59:59 -07007308struct LinkFieldsComparator {
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07007309 explicit LinkFieldsComparator() REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier590fee92013-09-13 13:46:47 -07007310 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07007311 // No thread safety analysis as will be called from STL. Checked lock held in constructor.
Mathieu Chartierc7853442015-03-27 14:35:38 -07007312 bool operator()(ArtField* field1, ArtField* field2)
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08007313 NO_THREAD_SAFETY_ANALYSIS {
Fred Shih37f05ef2014-07-16 18:38:08 -07007314 // 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 -07007315 Primitive::Type type1 = field1->GetTypeAsPrimitiveType();
7316 Primitive::Type type2 = field2->GetTypeAsPrimitiveType();
Ian Rogersef7d42f2014-01-06 12:55:46 -08007317 if (type1 != type2) {
Vladimir Markod5777482014-11-12 17:02:02 +00007318 if (type1 == Primitive::kPrimNot) {
7319 // Reference always goes first.
7320 return true;
Ian Rogersef7d42f2014-01-06 12:55:46 -08007321 }
Vladimir Markod5777482014-11-12 17:02:02 +00007322 if (type2 == Primitive::kPrimNot) {
7323 // Reference always goes first.
7324 return false;
7325 }
7326 size_t size1 = Primitive::ComponentSize(type1);
7327 size_t size2 = Primitive::ComponentSize(type2);
7328 if (size1 != size2) {
7329 // Larger primitive types go first.
7330 return size1 > size2;
7331 }
7332 // Primitive types differ but sizes match. Arbitrarily order by primitive type.
7333 return type1 < type2;
Brian Carlstromdbc05252011-09-09 01:59:59 -07007334 }
Vladimir Marko7a7c1db2014-11-17 15:13:34 +00007335 // Same basic group? Then sort by dex field index. This is guaranteed to be sorted
7336 // by name and for equal names by type id index.
7337 // NOTE: This works also for proxies. Their static fields are assigned appropriate indexes.
7338 return field1->GetDexFieldIndex() < field2->GetDexFieldIndex();
Brian Carlstromdbc05252011-09-09 01:59:59 -07007339 }
7340};
7341
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007342bool ClassLinker::LinkFields(Thread* self,
7343 Handle<mirror::Class> klass,
7344 bool is_static,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07007345 size_t* class_size) {
Ian Rogers7b078e82014-09-10 14:44:24 -07007346 self->AllowThreadSuspension();
Mathieu Chartierc7853442015-03-27 14:35:38 -07007347 const size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007348 LengthPrefixedArray<ArtField>* const fields = is_static ? klass->GetSFieldsPtr() :
7349 klass->GetIFieldsPtr();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007350
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007351 // Initialize field_offset
Brian Carlstrom693267a2011-09-06 09:25:34 -07007352 MemberOffset field_offset(0);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007353 if (is_static) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007354 field_offset = klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007355 } else {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007356 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007357 if (super_class != nullptr) {
Brian Carlstromf3632832014-05-20 15:36:53 -07007358 CHECK(super_class->IsResolved())
David Sehr709b0702016-10-13 09:12:37 -07007359 << klass->PrettyClass() << " " << super_class->PrettyClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007360 field_offset = MemberOffset(super_class->GetObjectSize());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007361 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007362 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007363
David Sehr709b0702016-10-13 09:12:37 -07007364 CHECK_EQ(num_fields == 0, fields == nullptr) << klass->PrettyClass();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007365
Brian Carlstromdbc05252011-09-09 01:59:59 -07007366 // we want a relatively stable order so that adding new fields
Elliott Hughesadb460d2011-10-05 17:02:34 -07007367 // minimizes disruption of C++ version such as Class and Method.
Alex Lighte64300b2015-12-15 15:02:47 -08007368 //
7369 // The overall sort order order is:
7370 // 1) All object reference fields, sorted alphabetically.
7371 // 2) All java long (64-bit) integer fields, sorted alphabetically.
7372 // 3) All java double (64-bit) floating point fields, sorted alphabetically.
7373 // 4) All java int (32-bit) integer fields, sorted alphabetically.
7374 // 5) All java float (32-bit) floating point fields, sorted alphabetically.
7375 // 6) All java char (16-bit) integer fields, sorted alphabetically.
7376 // 7) All java short (16-bit) integer fields, sorted alphabetically.
7377 // 8) All java boolean (8-bit) integer fields, sorted alphabetically.
7378 // 9) All java byte (8-bit) integer fields, sorted alphabetically.
7379 //
7380 // Once the fields are sorted in this order we will attempt to fill any gaps that might be present
7381 // in the memory layout of the structure. See ShuffleForward for how this is done.
Mathieu Chartierc7853442015-03-27 14:35:38 -07007382 std::deque<ArtField*> grouped_and_sorted_fields;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07007383 const char* old_no_suspend_cause = self->StartAssertNoThreadSuspension(
Fred Shih37f05ef2014-07-16 18:38:08 -07007384 "Naked ArtField references in deque");
Brian Carlstromdbc05252011-09-09 01:59:59 -07007385 for (size_t i = 0; i < num_fields; i++) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007386 grouped_and_sorted_fields.push_back(&fields->At(i));
Brian Carlstromdbc05252011-09-09 01:59:59 -07007387 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07007388 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(),
7389 LinkFieldsComparator());
Brian Carlstromdbc05252011-09-09 01:59:59 -07007390
Fred Shih381e4ca2014-08-25 17:24:27 -07007391 // References should be at the front.
Brian Carlstromdbc05252011-09-09 01:59:59 -07007392 size_t current_field = 0;
7393 size_t num_reference_fields = 0;
Fred Shih381e4ca2014-08-25 17:24:27 -07007394 FieldGaps gaps;
7395
Brian Carlstromdbc05252011-09-09 01:59:59 -07007396 for (; current_field < num_fields; current_field++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07007397 ArtField* field = grouped_and_sorted_fields.front();
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07007398 Primitive::Type type = field->GetTypeAsPrimitiveType();
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07007399 bool isPrimitive = type != Primitive::kPrimNot;
Brian Carlstromdbc05252011-09-09 01:59:59 -07007400 if (isPrimitive) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07007401 break; // past last reference, move on to the next phase
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007402 }
Vladimir Marko76649e82014-11-10 18:32:59 +00007403 if (UNLIKELY(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(
7404 field_offset.Uint32Value()))) {
Fred Shih381e4ca2014-08-25 17:24:27 -07007405 MemberOffset old_offset = field_offset;
7406 field_offset = MemberOffset(RoundUp(field_offset.Uint32Value(), 4));
7407 AddFieldGap(old_offset.Uint32Value(), field_offset.Uint32Value(), &gaps);
7408 }
Roland Levillain14d90572015-07-16 10:52:26 +01007409 DCHECK_ALIGNED(field_offset.Uint32Value(), sizeof(mirror::HeapReference<mirror::Object>));
Brian Carlstromdbc05252011-09-09 01:59:59 -07007410 grouped_and_sorted_fields.pop_front();
7411 num_reference_fields++;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007412 field->SetOffset(field_offset);
Vladimir Marko76649e82014-11-10 18:32:59 +00007413 field_offset = MemberOffset(field_offset.Uint32Value() +
7414 sizeof(mirror::HeapReference<mirror::Object>));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007415 }
Fred Shih381e4ca2014-08-25 17:24:27 -07007416 // Gaps are stored as a max heap which means that we must shuffle from largest to smallest
7417 // otherwise we could end up with suboptimal gap fills.
Vladimir Marko76649e82014-11-10 18:32:59 +00007418 ShuffleForward<8>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7419 ShuffleForward<4>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7420 ShuffleForward<2>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
7421 ShuffleForward<1>(&current_field, &field_offset, &grouped_and_sorted_fields, &gaps);
Fred Shih37f05ef2014-07-16 18:38:08 -07007422 CHECK(grouped_and_sorted_fields.empty()) << "Missed " << grouped_and_sorted_fields.size() <<
7423 " fields.";
Ian Rogers7b078e82014-09-10 14:44:24 -07007424 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007425
Elliott Hughesadb460d2011-10-05 17:02:34 -07007426 // 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 -07007427 if (!is_static && klass->DescriptorEquals("Ljava/lang/ref/Reference;")) {
Elliott Hughesadb460d2011-10-05 17:02:34 -07007428 // We know there are no non-reference fields in the Reference classes, and we know
7429 // that 'referent' is alphabetically last, so this is easy...
David Sehr709b0702016-10-13 09:12:37 -07007430 CHECK_EQ(num_reference_fields, num_fields) << klass->PrettyClass();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007431 CHECK_STREQ(fields->At(num_fields - 1).GetName(), "referent")
David Sehr709b0702016-10-13 09:12:37 -07007432 << klass->PrettyClass();
Elliott Hughesadb460d2011-10-05 17:02:34 -07007433 --num_reference_fields;
7434 }
7435
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007436 size_t size = field_offset.Uint32Value();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007437 // Update klass
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007438 if (is_static) {
7439 klass->SetNumReferenceStaticFields(num_reference_fields);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07007440 *class_size = size;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07007441 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007442 klass->SetNumReferenceInstanceFields(num_reference_fields);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007443 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007444 if (num_reference_fields == 0 || super_class == nullptr) {
7445 // object has one reference field, klass, but we ignore it since we always visit the class.
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007446 // super_class is null iff the class is java.lang.Object.
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007447 if (super_class == nullptr ||
7448 (super_class->GetClassFlags() & mirror::kClassFlagNoReferenceFields) != 0) {
7449 klass->SetClassFlags(klass->GetClassFlags() | mirror::kClassFlagNoReferenceFields);
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007450 }
7451 }
7452 if (kIsDebugBuild) {
7453 DCHECK_EQ(super_class == nullptr, klass->DescriptorEquals("Ljava/lang/Object;"));
7454 size_t total_reference_instance_fields = 0;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007455 ObjPtr<mirror::Class> cur_super = klass.Get();
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007456 while (cur_super != nullptr) {
7457 total_reference_instance_fields += cur_super->NumReferenceInstanceFieldsDuringLinking();
7458 cur_super = cur_super->GetSuperClass();
7459 }
7460 if (super_class == nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07007461 CHECK_EQ(total_reference_instance_fields, 1u) << klass->PrettyDescriptor();
Mathieu Chartier66c2d2d2015-08-25 14:32:32 -07007462 } else {
7463 // Check that there is at least num_reference_fields other than Object.class.
7464 CHECK_GE(total_reference_instance_fields, 1u + num_reference_fields)
David Sehr709b0702016-10-13 09:12:37 -07007465 << klass->PrettyClass();
Mathieu Chartier52a7f5c2015-08-18 18:35:52 -07007466 }
7467 }
Brian Carlstromdbc05252011-09-09 01:59:59 -07007468 if (!klass->IsVariableSize()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007469 std::string temp;
7470 DCHECK_GE(size, sizeof(mirror::Object)) << klass->GetDescriptor(&temp);
7471 size_t previous_size = klass->GetObjectSize();
7472 if (previous_size != 0) {
7473 // Make sure that we didn't originally have an incorrect size.
7474 CHECK_EQ(previous_size, size) << klass->GetDescriptor(&temp);
Mathieu Chartier79b4f382013-10-23 15:21:37 -07007475 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07007476 klass->SetObjectSize(size);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007477 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007478 }
Vladimir Marko76649e82014-11-10 18:32:59 +00007479
7480 if (kIsDebugBuild) {
7481 // Make sure that the fields array is ordered by name but all reference
7482 // offsets are at the beginning as far as alignment allows.
7483 MemberOffset start_ref_offset = is_static
Mathieu Chartiere401d142015-04-22 13:56:20 -07007484 ? klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_)
Vladimir Marko76649e82014-11-10 18:32:59 +00007485 : klass->GetFirstReferenceInstanceFieldOffset();
7486 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() +
7487 num_reference_fields *
7488 sizeof(mirror::HeapReference<mirror::Object>));
7489 MemberOffset current_ref_offset = start_ref_offset;
7490 for (size_t i = 0; i < num_fields; i++) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007491 ArtField* field = &fields->At(i);
Mathieu Chartierc7853442015-03-27 14:35:38 -07007492 VLOG(class_linker) << "LinkFields: " << (is_static ? "static" : "instance")
David Sehr709b0702016-10-13 09:12:37 -07007493 << " class=" << klass->PrettyClass() << " field=" << field->PrettyField()
7494 << " offset=" << field->GetOffsetDuringLinking();
Vladimir Marko76649e82014-11-10 18:32:59 +00007495 if (i != 0) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007496 ArtField* const prev_field = &fields->At(i - 1);
Vladimir Marko7a7c1db2014-11-17 15:13:34 +00007497 // NOTE: The field names can be the same. This is not possible in the Java language
7498 // but it's valid Java/dex bytecode and for example proguard can generate such bytecode.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07007499 DCHECK_LE(strcmp(prev_field->GetName(), field->GetName()), 0);
Vladimir Marko76649e82014-11-10 18:32:59 +00007500 }
7501 Primitive::Type type = field->GetTypeAsPrimitiveType();
7502 bool is_primitive = type != Primitive::kPrimNot;
7503 if (klass->DescriptorEquals("Ljava/lang/ref/Reference;") &&
7504 strcmp("referent", field->GetName()) == 0) {
7505 is_primitive = true; // We lied above, so we have to expect a lie here.
7506 }
7507 MemberOffset offset = field->GetOffsetDuringLinking();
7508 if (is_primitive) {
7509 if (offset.Uint32Value() < end_ref_offset.Uint32Value()) {
7510 // Shuffled before references.
7511 size_t type_size = Primitive::ComponentSize(type);
7512 CHECK_LT(type_size, sizeof(mirror::HeapReference<mirror::Object>));
7513 CHECK_LT(offset.Uint32Value(), start_ref_offset.Uint32Value());
7514 CHECK_LE(offset.Uint32Value() + type_size, start_ref_offset.Uint32Value());
7515 CHECK(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(offset.Uint32Value()));
7516 }
7517 } else {
7518 CHECK_EQ(current_ref_offset.Uint32Value(), offset.Uint32Value());
7519 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() +
7520 sizeof(mirror::HeapReference<mirror::Object>));
7521 }
7522 }
7523 CHECK_EQ(current_ref_offset.Uint32Value(), end_ref_offset.Uint32Value());
7524 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007525 return true;
7526}
7527
Vladimir Marko76649e82014-11-10 18:32:59 +00007528// Set the bitmap of reference instance field offsets.
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007529void ClassLinker::CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007530 uint32_t reference_offsets = 0;
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007531 ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007532 // Leave the reference offsets as 0 for mirror::Object (the class field is handled specially).
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007533 if (super_class != nullptr) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007534 reference_offsets = super_class->GetReferenceInstanceOffsets();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007535 // Compute reference offsets unless our superclass overflowed.
7536 if (reference_offsets != mirror::Class::kClassWalkSuper) {
7537 size_t num_reference_fields = klass->NumReferenceInstanceFieldsDuringLinking();
Vladimir Marko76649e82014-11-10 18:32:59 +00007538 if (num_reference_fields != 0u) {
7539 // All of the fields that contain object references are guaranteed be grouped in memory
7540 // starting at an appropriately aligned address after super class object data.
7541 uint32_t start_offset = RoundUp(super_class->GetObjectSize(),
7542 sizeof(mirror::HeapReference<mirror::Object>));
7543 uint32_t start_bit = (start_offset - mirror::kObjectHeaderSize) /
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007544 sizeof(mirror::HeapReference<mirror::Object>);
Vladimir Marko76649e82014-11-10 18:32:59 +00007545 if (start_bit + num_reference_fields > 32) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007546 reference_offsets = mirror::Class::kClassWalkSuper;
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007547 } else {
Vladimir Marko76649e82014-11-10 18:32:59 +00007548 reference_offsets |= (0xffffffffu << start_bit) &
7549 (0xffffffffu >> (32 - (start_bit + num_reference_fields)));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07007550 }
7551 }
Brian Carlstrom4873d462011-08-21 15:23:39 -07007552 }
7553 }
Mingyao Yangfaff0f02014-09-10 12:03:22 -07007554 klass->SetReferenceInstanceOffsets(reference_offsets);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007555}
7556
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007557mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
7558 uint32_t string_idx,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007559 Handle<mirror::DexCache> dex_cache) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007560 DCHECK(dex_cache.Get() != nullptr);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007561 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007562 ObjPtr<mirror::String> resolved = dex_cache->GetResolvedString(string_idx);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007563 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007564 return resolved.Ptr();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007565 }
Ian Rogersdfb325e2013-10-30 01:00:44 -07007566 uint32_t utf16_length;
7567 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007568 ObjPtr<mirror::String> string = intern_table_->InternStrong(utf16_length, utf8_data);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007569 dex_cache->SetResolvedString(string_idx, string);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007570 return string.Ptr();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007571}
7572
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007573mirror::String* ClassLinker::LookupString(const DexFile& dex_file,
7574 uint32_t string_idx,
7575 Handle<mirror::DexCache> dex_cache) {
7576 DCHECK(dex_cache.Get() != nullptr);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007577 ObjPtr<mirror::String> resolved = dex_cache->GetResolvedString(string_idx);
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007578 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007579 return resolved.Ptr();
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007580 }
7581 uint32_t utf16_length;
7582 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007583 ObjPtr<mirror::String> string = intern_table_->LookupStrong(Thread::Current(), utf16_length, utf8_data);
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007584 if (string != nullptr) {
7585 dex_cache->SetResolvedString(string_idx, string);
7586 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007587 return string.Ptr();
Vladimir Markocac5a7e2016-02-22 10:39:50 +00007588}
7589
Mathieu Chartierb8901302016-09-30 10:27:43 -07007590ObjPtr<mirror::Class> ClassLinker::LookupResolvedType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007591 dex::TypeIndex type_idx,
Mathieu Chartierb8901302016-09-30 10:27:43 -07007592 ObjPtr<mirror::DexCache> dex_cache,
7593 ObjPtr<mirror::ClassLoader> class_loader) {
7594 ObjPtr<mirror::Class> type = dex_cache->GetResolvedType(type_idx);
7595 if (type == nullptr) {
7596 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
7597 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
7598 if (descriptor[1] == '\0') {
7599 // only the descriptors of primitive types should be 1 character long, also avoid class lookup
7600 // for primitive classes that aren't backed by dex files.
7601 type = FindPrimitiveClass(descriptor[0]);
7602 } else {
7603 Thread* const self = Thread::Current();
7604 DCHECK(self != nullptr);
7605 const size_t hash = ComputeModifiedUtf8Hash(descriptor);
7606 // Find the class in the loaded classes table.
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07007607 type = LookupClass(self, descriptor, hash, class_loader.Ptr());
Mathieu Chartierb8901302016-09-30 10:27:43 -07007608 }
7609 }
7610 if (type != nullptr || type->IsResolved()) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007611 return type.Ptr();
Mathieu Chartierb8901302016-09-30 10:27:43 -07007612 }
7613 return nullptr;
7614}
7615
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007616mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007617 dex::TypeIndex type_idx,
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007618 ObjPtr<mirror::Class> referrer) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007619 StackHandleScope<2> hs(Thread::Current());
7620 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
7621 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader()));
Mathieu Chartier590fee92013-09-13 13:46:47 -07007622 return ResolveType(dex_file, type_idx, dex_cache, class_loader);
7623}
7624
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007625mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -08007626 dex::TypeIndex type_idx,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -07007627 Handle<mirror::DexCache> dex_cache,
7628 Handle<mirror::ClassLoader> class_loader) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007629 DCHECK(dex_cache.Get() != nullptr);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007630 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007631 ObjPtr<mirror::Class> resolved = dex_cache->GetResolvedType(type_idx);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007632 if (resolved == nullptr) {
Ian Rogers98379392014-02-24 16:53:16 -08007633 Thread* self = Thread::Current();
Ian Rogers0571d352011-11-03 19:51:38 -07007634 const char* descriptor = dex_file.StringByTypeIdx(type_idx);
Ian Rogers98379392014-02-24 16:53:16 -08007635 resolved = FindClass(self, descriptor, class_loader);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007636 if (resolved != nullptr) {
Jesse Wilson254db0f2011-11-16 16:44:11 -05007637 // TODO: we used to throw here if resolved's class loader was not the
7638 // boot class loader. This was to permit different classes with the
7639 // same name to be loaded simultaneously by different loaders
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007640 dex_cache->SetResolvedType(type_idx, resolved);
7641 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08007642 CHECK(self->IsExceptionPending())
Ian Rogerscab01012012-01-10 17:35:46 -08007643 << "Expected pending exception for failed resolution of: " << descriptor;
Ian Rogers62d6c772013-02-27 08:32:07 -08007644 // Convert a ClassNotFoundException to a NoClassDefFoundError.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007645 StackHandleScope<1> hs(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00007646 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
Ian Rogers62d6c772013-02-27 08:32:07 -08007647 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007648 DCHECK(resolved == nullptr); // No Handle needed to preserve resolved.
Ian Rogers98379392014-02-24 16:53:16 -08007649 self->ClearException();
jeffhao8cd6dda2012-02-22 10:15:34 -08007650 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00007651 self->GetException()->SetCause(cause.Get());
jeffhao8cd6dda2012-02-22 10:15:34 -08007652 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07007653 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007654 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007655 DCHECK((resolved == nullptr) || resolved->IsResolved() || resolved->IsErroneous())
David Sehr709b0702016-10-13 09:12:37 -07007656 << resolved->PrettyDescriptor() << " " << resolved->GetStatus();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007657 return resolved.Ptr();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007658}
7659
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007660template <ClassLinker::ResolveMode kResolveMode>
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007661ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
7662 uint32_t method_idx,
Mathieu Chartiere401d142015-04-22 13:56:20 -07007663 Handle<mirror::DexCache> dex_cache,
7664 Handle<mirror::ClassLoader> class_loader,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007665 ArtMethod* referrer,
7666 InvokeType type) {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007667 DCHECK(dex_cache.Get() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07007668 // Check for hit in the dex cache.
Mathieu Chartiere401d142015-04-22 13:56:20 -07007669 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007670 Thread::PoisonObjectPointersIfDebug();
Mathieu Chartier0cd81352014-05-22 16:48:55 -07007671 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007672 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex();
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007673 if (kResolveMode == ClassLinker::kForceICCECheck) {
7674 if (resolved->CheckIncompatibleClassChange(type)) {
7675 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer);
7676 return nullptr;
7677 }
7678 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007679 return resolved;
7680 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007681 // Fail, get the declaring class.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007682 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007683 ObjPtr<mirror::Class> klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007684 if (klass == nullptr) {
Elliott Hughescc5f9a92011-09-28 19:17:29 -07007685 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007686 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007687 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007688 // Scan using method_idx, this saves string compares but will only hit for matching dex
7689 // caches/files.
7690 switch (type) {
7691 case kDirect: // Fall-through.
7692 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007693 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7694 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07007695 break;
7696 case kInterface:
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007697 // We have to check whether the method id really belongs to an interface (dex static bytecode
7698 // constraint A15). Otherwise you must not invoke-interface on it.
7699 //
7700 // This is not symmetric to A12-A14 (direct, static, virtual), as using FindInterfaceMethod
7701 // assumes that the given type is an interface, and will check the interface table if the
7702 // method isn't declared in the class. So it may find an interface method (usually by name
7703 // in the handling below, but we do the constraint check early). In that case,
7704 // CheckIncompatibleClassChange will succeed (as it is called on an interface method)
7705 // unexpectedly.
7706 // Example:
7707 // interface I {
7708 // foo()
7709 // }
7710 // class A implements I {
7711 // ...
7712 // }
7713 // class B extends A {
7714 // ...
7715 // }
7716 // invoke-interface B.foo
7717 // -> FindInterfaceMethod finds I.foo (interface method), not A.foo (miranda method)
7718 if (UNLIKELY(!klass->IsInterface())) {
7719 ThrowIncompatibleClassChangeError(klass,
7720 "Found class %s, but interface was expected",
David Sehr709b0702016-10-13 09:12:37 -07007721 klass->PrettyDescriptor().c_str());
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08007722 return nullptr;
7723 } else {
7724 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7725 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
7726 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007727 break;
Alex Light705ad492015-09-21 11:36:30 -07007728 case kSuper:
7729 if (klass->IsInterface()) {
7730 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7731 } else {
7732 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7733 }
7734 break;
Ian Rogers08f753d2012-08-24 14:35:25 -07007735 case kVirtual:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007736 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07007737 break;
7738 default:
7739 LOG(FATAL) << "Unreachable - invocation type: " << type;
Ian Rogers2c4257b2014-10-24 14:20:06 -07007740 UNREACHABLE();
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07007741 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007742 if (resolved == nullptr) {
Ian Rogers08f753d2012-08-24 14:35:25 -07007743 // Search by name, which works across dex files.
Ian Rogers7b0c5b42012-02-16 15:29:07 -08007744 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
Ian Rogersd91d6d62013-09-25 20:26:14 -07007745 const Signature signature = dex_file.GetMethodSignature(method_id);
Ian Rogers08f753d2012-08-24 14:35:25 -07007746 switch (type) {
7747 case kDirect: // Fall-through.
7748 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007749 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_);
7750 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr);
Ian Rogers08f753d2012-08-24 14:35:25 -07007751 break;
7752 case kInterface:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007753 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007754 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface());
Ian Rogers08f753d2012-08-24 14:35:25 -07007755 break;
Alex Light705ad492015-09-21 11:36:30 -07007756 case kSuper:
7757 if (klass->IsInterface()) {
7758 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
7759 } else {
7760 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
7761 }
7762 break;
Ian Rogers08f753d2012-08-24 14:35:25 -07007763 case kVirtual:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007764 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07007765 break;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08007766 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007767 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007768 // If we found a method, check for incompatible class changes.
7769 if (LIKELY(resolved != nullptr && !resolved->CheckIncompatibleClassChange(type))) {
Ian Rogers08f753d2012-08-24 14:35:25 -07007770 // Be a good citizen and update the dex cache to speed subsequent calls.
Mathieu Chartiere401d142015-04-22 13:56:20 -07007771 dex_cache->SetResolvedMethod(method_idx, resolved, image_pointer_size_);
Ian Rogers08f753d2012-08-24 14:35:25 -07007772 return resolved;
7773 } else {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007774 // If we had a method, it's an incompatible-class-change error.
7775 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007776 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007777 } else {
7778 // We failed to find the method which means either an access error, an incompatible class
7779 // change, or no such method. First try to find the method among direct and virtual methods.
7780 const char* name = dex_file.StringDataByIdx(method_id.name_idx_);
7781 const Signature signature = dex_file.GetMethodSignature(method_id);
7782 switch (type) {
7783 case kDirect:
7784 case kStatic:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007785 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007786 // Note: kDirect and kStatic are also mutually exclusive, but in that case we would
7787 // have had a resolved method before, which triggers the "true" branch above.
7788 break;
7789 case kInterface:
7790 case kVirtual:
7791 case kSuper:
Mathieu Chartiere401d142015-04-22 13:56:20 -07007792 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007793 break;
7794 }
7795
7796 // If we found something, check that it can be accessed by the referrer.
Ian Rogerse0a02da2014-12-02 14:10:53 -08007797 bool exception_generated = false;
Mathieu Chartiere401d142015-04-22 13:56:20 -07007798 if (resolved != nullptr && referrer != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007799 ObjPtr<mirror::Class> methods_class = resolved->GetDeclaringClass();
7800 ObjPtr<mirror::Class> referring_class = referrer->GetDeclaringClass();
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007801 if (!referring_class->CanAccess(methods_class)) {
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007802 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class,
7803 methods_class,
7804 resolved,
Mathieu Chartiere401d142015-04-22 13:56:20 -07007805 type);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007806 exception_generated = true;
Mathieu Chartiere401d142015-04-22 13:56:20 -07007807 } else if (!referring_class->CanAccessMember(methods_class, resolved->GetAccessFlags())) {
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007808 ThrowIllegalAccessErrorMethod(referring_class, resolved);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007809 exception_generated = true;
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007810 }
7811 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08007812 if (!exception_generated) {
7813 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check
7814 // interface methods and throw if we find the method there. If we find nothing, throw a
7815 // NoSuchMethodError.
7816 switch (type) {
7817 case kDirect:
7818 case kStatic:
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007819 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007820 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007821 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007822 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007823 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007824 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007825 } else {
7826 ThrowNoSuchMethodError(type, klass, name, signature);
7827 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007828 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08007829 break;
7830 case kInterface:
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007831 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007832 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007833 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007834 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007835 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007836 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007837 } else {
7838 ThrowNoSuchMethodError(type, klass, name, signature);
7839 }
7840 }
7841 break;
7842 case kSuper:
7843 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007844 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007845 } else {
7846 ThrowNoSuchMethodError(type, klass, name, signature);
7847 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08007848 break;
7849 case kVirtual:
7850 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007851 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007852 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007853 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007854 if (resolved != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07007855 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer);
Ian Rogerse0a02da2014-12-02 14:10:53 -08007856 } else {
7857 ThrowNoSuchMethodError(type, klass, name, signature);
7858 }
7859 }
7860 break;
7861 }
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007862 }
Ian Rogers08f753d2012-08-24 14:35:25 -07007863 }
Ian Rogerse0a02da2014-12-02 14:10:53 -08007864 Thread::Current()->AssertPendingException();
Andreas Gampeeff0f5d2014-08-13 21:49:37 -07007865 return nullptr;
Ian Rogers08f753d2012-08-24 14:35:25 -07007866 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07007867}
7868
Jeff Hao13e748b2015-08-25 20:44:19 +00007869ArtMethod* ClassLinker::ResolveMethodWithoutInvokeType(const DexFile& dex_file,
7870 uint32_t method_idx,
7871 Handle<mirror::DexCache> dex_cache,
7872 Handle<mirror::ClassLoader> class_loader) {
7873 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007874 Thread::PoisonObjectPointersIfDebug();
Jeff Hao13e748b2015-08-25 20:44:19 +00007875 if (resolved != nullptr && !resolved->IsRuntimeMethod()) {
7876 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex();
7877 return resolved;
7878 }
7879 // Fail, get the declaring class.
7880 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007881 ObjPtr<mirror::Class> klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
Jeff Hao13e748b2015-08-25 20:44:19 +00007882 if (klass == nullptr) {
7883 Thread::Current()->AssertPendingException();
7884 return nullptr;
7885 }
7886 if (klass->IsInterface()) {
David Sehr709b0702016-10-13 09:12:37 -07007887 LOG(FATAL) << "ResolveAmbiguousMethod: unexpected method in interface: "
7888 << klass->PrettyClass();
Jeff Hao13e748b2015-08-25 20:44:19 +00007889 return nullptr;
7890 }
7891
7892 // Search both direct and virtual methods
7893 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7894 if (resolved == nullptr) {
7895 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_);
7896 }
7897
7898 return resolved;
7899}
7900
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007901ArtField* ClassLinker::ResolveField(const DexFile& dex_file,
7902 uint32_t field_idx,
Mathieu Chartierc7853442015-03-27 14:35:38 -07007903 Handle<mirror::DexCache> dex_cache,
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007904 Handle<mirror::ClassLoader> class_loader,
7905 bool is_static) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007906 DCHECK(dex_cache.Get() != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07007907 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007908 Thread::PoisonObjectPointersIfDebug();
Andreas Gampe58a5af82014-07-31 16:23:49 -07007909 if (resolved != nullptr) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007910 return resolved;
7911 }
7912 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07007913 Thread* const self = Thread::Current();
7914 StackHandleScope<1> hs(self);
7915 Handle<mirror::Class> klass(
7916 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader)));
Andreas Gampe58a5af82014-07-31 16:23:49 -07007917 if (klass.Get() == nullptr) {
Ian Rogers9f1ab122011-12-12 08:52:43 -08007918 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe58a5af82014-07-31 16:23:49 -07007919 return nullptr;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007920 }
7921
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07007922 if (is_static) {
Vladimir Markobb268b12016-06-30 15:52:56 +01007923 resolved = mirror::Class::FindStaticField(self, klass.Get(), dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07007924 } else {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007925 resolved = klass->FindInstanceField(dex_cache.Get(), field_idx);
Brian Carlstrom20cfffa2011-08-26 02:31:27 -07007926 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08007927
Andreas Gampe58a5af82014-07-31 16:23:49 -07007928 if (resolved == nullptr) {
Ian Rogers7b0c5b42012-02-16 15:29:07 -08007929 const char* name = dex_file.GetFieldName(field_id);
7930 const char* type = dex_file.GetFieldTypeDescriptor(field_id);
7931 if (is_static) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07007932 resolved = mirror::Class::FindStaticField(self, klass, name, type);
Ian Rogers7b0c5b42012-02-16 15:29:07 -08007933 } else {
7934 resolved = klass->FindInstanceField(name, type);
7935 }
Andreas Gampe58a5af82014-07-31 16:23:49 -07007936 if (resolved == nullptr) {
Mathieu Chartierf8322842014-05-16 10:59:25 -07007937 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass.Get(), type, name);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007938 return nullptr;
Ian Rogers7b0c5b42012-02-16 15:29:07 -08007939 }
Ian Rogersb067ac22011-12-13 18:05:09 -08007940 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07007941 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_);
Ian Rogersb067ac22011-12-13 18:05:09 -08007942 return resolved;
7943}
7944
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07007945ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
7946 uint32_t field_idx,
Mathieu Chartierc7853442015-03-27 14:35:38 -07007947 Handle<mirror::DexCache> dex_cache,
7948 Handle<mirror::ClassLoader> class_loader) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07007949 DCHECK(dex_cache.Get() != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07007950 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_);
Mathieu Chartiera59d9b22016-09-26 18:13:17 -07007951 Thread::PoisonObjectPointersIfDebug();
Andreas Gampe58a5af82014-07-31 16:23:49 -07007952 if (resolved != nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08007953 return resolved;
7954 }
7955 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Mathieu Chartierf8322842014-05-16 10:59:25 -07007956 Thread* self = Thread::Current();
7957 StackHandleScope<1> hs(self);
7958 Handle<mirror::Class> klass(
7959 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader)));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007960 if (klass.Get() == nullptr) {
Ian Rogersb067ac22011-12-13 18:05:09 -08007961 DCHECK(Thread::Current()->IsExceptionPending());
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007962 return nullptr;
Ian Rogersb067ac22011-12-13 18:05:09 -08007963 }
7964
Ian Rogersdfb325e2013-10-30 01:00:44 -07007965 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
7966 StringPiece type(dex_file.StringDataByIdx(
Ian Rogersfc0e94b2013-09-23 23:51:32 -07007967 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
Mathieu Chartierf8322842014-05-16 10:59:25 -07007968 resolved = mirror::Class::FindField(self, klass, name, type);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07007969 if (resolved != nullptr) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07007970 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_);
Ian Rogersb067ac22011-12-13 18:05:09 -08007971 } else {
Mathieu Chartierf8322842014-05-16 10:59:25 -07007972 ThrowNoSuchFieldError("", klass.Get(), type, name);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07007973 }
7974 return resolved;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07007975}
7976
Narayan Kamath25352fc2016-08-03 12:46:58 +01007977mirror::MethodType* ClassLinker::ResolveMethodType(const DexFile& dex_file,
7978 uint32_t proto_idx,
7979 Handle<mirror::DexCache> dex_cache,
7980 Handle<mirror::ClassLoader> class_loader) {
7981 DCHECK(Runtime::Current()->IsMethodHandlesEnabled());
7982 DCHECK(dex_cache.Get() != nullptr);
7983
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007984 ObjPtr<mirror::MethodType> resolved = dex_cache->GetResolvedMethodType(proto_idx);
Narayan Kamath25352fc2016-08-03 12:46:58 +01007985 if (resolved != nullptr) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07007986 return resolved.Ptr();
Narayan Kamath25352fc2016-08-03 12:46:58 +01007987 }
7988
7989 Thread* const self = Thread::Current();
7990 StackHandleScope<4> hs(self);
7991
7992 // First resolve the return type.
7993 const DexFile::ProtoId& proto_id = dex_file.GetProtoId(proto_idx);
7994 Handle<mirror::Class> return_type(hs.NewHandle(
7995 ResolveType(dex_file, proto_id.return_type_idx_, dex_cache, class_loader)));
7996 if (return_type.Get() == nullptr) {
7997 DCHECK(self->IsExceptionPending());
7998 return nullptr;
7999 }
8000
8001 // Then resolve the argument types.
8002 //
8003 // TODO: Is there a better way to figure out the number of method arguments
8004 // other than by looking at the shorty ?
8005 const size_t num_method_args = strlen(dex_file.StringDataByIdx(proto_id.shorty_idx_)) - 1;
8006
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008007 ObjPtr<mirror::Class> class_type = mirror::Class::GetJavaLangClass();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008008 ObjPtr<mirror::Class> array_of_class = FindArrayClass(self, &class_type);
Narayan Kamath25352fc2016-08-03 12:46:58 +01008009 Handle<mirror::ObjectArray<mirror::Class>> method_params(hs.NewHandle(
8010 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, num_method_args)));
8011 if (method_params.Get() == nullptr) {
8012 DCHECK(self->IsExceptionPending());
8013 return nullptr;
8014 }
8015
8016 DexFileParameterIterator it(dex_file, proto_id);
8017 int32_t i = 0;
8018 MutableHandle<mirror::Class> param_class = hs.NewHandle<mirror::Class>(nullptr);
8019 for (; it.HasNext(); it.Next()) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08008020 const dex::TypeIndex type_idx = it.GetTypeIdx();
Narayan Kamath25352fc2016-08-03 12:46:58 +01008021 param_class.Assign(ResolveType(dex_file, type_idx, dex_cache, class_loader));
8022 if (param_class.Get() == nullptr) {
8023 DCHECK(self->IsExceptionPending());
8024 return nullptr;
8025 }
8026
8027 method_params->Set(i++, param_class.Get());
8028 }
8029
8030 DCHECK(!it.HasNext());
8031
8032 Handle<mirror::MethodType> type = hs.NewHandle(
8033 mirror::MethodType::Create(self, return_type, method_params));
8034 dex_cache->SetResolvedMethodType(proto_idx, type.Get());
8035
8036 return type.Get();
8037}
8038
Mathieu Chartierc77f3ab2015-09-03 19:41:50 -07008039const char* ClassLinker::MethodShorty(uint32_t method_idx,
8040 ArtMethod* referrer,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08008041 uint32_t* length) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008042 ObjPtr<mirror::Class> declaring_class = referrer->GetDeclaringClass();
8043 ObjPtr<mirror::DexCache> dex_cache = declaring_class->GetDexCache();
Ian Rogers4445a7e2012-10-05 17:19:13 -07008044 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogersad25ac52011-10-04 19:13:33 -07008045 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
Ian Rogers19846512012-02-24 11:42:47 -08008046 return dex_file.GetMethodShorty(method_id, length);
Ian Rogersad25ac52011-10-04 19:13:33 -07008047}
8048
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07008049class DumpClassVisitor : public ClassVisitor {
8050 public:
8051 explicit DumpClassVisitor(int flags) : flags_(flags) {}
8052
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008053 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -07008054 klass->DumpClass(LOG_STREAM(ERROR), flags_);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07008055 return true;
8056 }
8057
8058 private:
8059 const int flags_;
8060};
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07008061
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008062void ClassLinker::DumpAllClasses(int flags) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07008063 DumpClassVisitor visitor(flags);
8064 VisitClasses(&visitor);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07008065}
8066
Elliott Hughes956af0f2014-12-11 14:34:28 -08008067static OatFile::OatMethod CreateOatMethod(const void* code) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008068 CHECK(code != nullptr);
Mathieu Chartier957ca1c2014-11-21 16:51:29 -08008069 const uint8_t* base = reinterpret_cast<const uint8_t*>(code); // Base of data points at code.
8070 base -= sizeof(void*); // Move backward so that code_offset != 0.
8071 const uint32_t code_offset = sizeof(void*);
8072 return OatFile::OatMethod(base, code_offset);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008073}
8074
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008075bool ClassLinker::IsQuickResolutionStub(const void* entry_point) const {
8076 return (entry_point == GetQuickResolutionStub()) ||
8077 (quick_resolution_trampoline_ == entry_point);
8078}
8079
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008080bool ClassLinker::IsQuickToInterpreterBridge(const void* entry_point) const {
8081 return (entry_point == GetQuickToInterpreterBridge()) ||
8082 (quick_to_interpreter_bridge_trampoline_ == entry_point);
8083}
8084
8085bool ClassLinker::IsQuickGenericJniStub(const void* entry_point) const {
8086 return (entry_point == GetQuickGenericJniStub()) ||
8087 (quick_generic_jni_trampoline_ == entry_point);
8088}
8089
8090const void* ClassLinker::GetRuntimeQuickGenericJniStub() const {
8091 return GetQuickGenericJniStub();
8092}
8093
Mathieu Chartiere401d142015-04-22 13:56:20 -07008094void ClassLinker::SetEntryPointsToCompiledCode(ArtMethod* method,
Elliott Hughes956af0f2014-12-11 14:34:28 -08008095 const void* method_code) const {
8096 OatFile::OatMethod oat_method = CreateOatMethod(method_code);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008097 oat_method.LinkMethod(method);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008098}
8099
Mathieu Chartiere401d142015-04-22 13:56:20 -07008100void ClassLinker::SetEntryPointsToInterpreter(ArtMethod* method) const {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008101 if (!method->IsNative()) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008102 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
8103 } else {
8104 const void* quick_method_code = GetQuickGenericJniStub();
Elliott Hughes956af0f2014-12-11 14:34:28 -08008105 OatFile::OatMethod oat_method = CreateOatMethod(quick_method_code);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008106 oat_method.LinkMethod(method);
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008107 }
8108}
8109
Ian Rogers7dfb28c2013-08-22 08:18:36 -07008110void ClassLinker::DumpForSigQuit(std::ostream& os) {
Mathieu Chartier6b069532015-08-05 15:08:12 -07008111 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier6b069532015-08-05 15:08:12 -07008112 ReaderMutexLock mu(soa.Self(), *Locks::classlinker_classes_lock_);
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008113 os << "Zygote loaded classes=" << NumZygoteClasses() << " post zygote classes="
8114 << NumNonZygoteClasses() << "\n";
8115}
8116
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008117class CountClassesVisitor : public ClassLoaderVisitor {
8118 public:
8119 CountClassesVisitor() : num_zygote_classes(0), num_non_zygote_classes(0) {}
8120
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008121 void Visit(ObjPtr<mirror::ClassLoader> class_loader)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07008122 REQUIRES_SHARED(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008123 ClassTable* const class_table = class_loader->GetClassTable();
Mathieu Chartier6b069532015-08-05 15:08:12 -07008124 if (class_table != nullptr) {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008125 num_zygote_classes += class_table->NumZygoteClasses();
8126 num_non_zygote_classes += class_table->NumNonZygoteClasses();
Mathieu Chartier6b069532015-08-05 15:08:12 -07008127 }
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008128 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008129
8130 size_t num_zygote_classes;
8131 size_t num_non_zygote_classes;
8132};
8133
8134size_t ClassLinker::NumZygoteClasses() const {
8135 CountClassesVisitor visitor;
8136 VisitClassLoaders(&visitor);
8137 return visitor.num_zygote_classes + boot_class_table_.NumZygoteClasses();
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008138}
8139
8140size_t ClassLinker::NumNonZygoteClasses() const {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008141 CountClassesVisitor visitor;
8142 VisitClassLoaders(&visitor);
8143 return visitor.num_non_zygote_classes + boot_class_table_.NumNonZygoteClasses();
Elliott Hughescac6cc72011-11-03 20:31:21 -07008144}
8145
Ian Rogers7dfb28c2013-08-22 08:18:36 -07008146size_t ClassLinker::NumLoadedClasses() {
Ian Rogers1bf8d4d2013-05-30 00:18:49 -07008147 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Mathieu Chartierc2e20622014-11-03 11:41:47 -08008148 // Only return non zygote classes since these are the ones which apps which care about.
Mathieu Chartiercc5ebdf2015-07-27 11:19:43 -07008149 return NumNonZygoteClasses();
Elliott Hughese27955c2011-08-26 15:21:24 -07008150}
8151
Brian Carlstrom47d237a2011-10-18 15:08:33 -07008152pid_t ClassLinker::GetClassesLockOwner() {
Ian Rogersb726dcb2012-09-05 08:57:23 -07008153 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid();
Brian Carlstrom47d237a2011-10-18 15:08:33 -07008154}
8155
8156pid_t ClassLinker::GetDexLockOwner() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07008157 return dex_lock_.GetExclusiveOwnerTid();
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07008158}
8159
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008160void ClassLinker::SetClassRoot(ClassRoot class_root, ObjPtr<mirror::Class> klass) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008161 DCHECK(!init_done_);
8162
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008163 DCHECK(klass != nullptr);
8164 DCHECK(klass->GetClassLoader() == nullptr);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008165
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07008166 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07008167 DCHECK(class_roots != nullptr);
8168 DCHECK(class_roots->Get(class_root) == nullptr);
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -07008169 class_roots->Set<false>(class_root, klass);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08008170}
8171
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008172const char* ClassLinker::GetClassRootDescriptor(ClassRoot class_root) {
8173 static const char* class_roots_descriptors[] = {
8174 "Ljava/lang/Class;",
8175 "Ljava/lang/Object;",
8176 "[Ljava/lang/Class;",
8177 "[Ljava/lang/Object;",
8178 "Ljava/lang/String;",
8179 "Ljava/lang/DexCache;",
8180 "Ljava/lang/ref/Reference;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008181 "Ljava/lang/reflect/Constructor;",
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008182 "Ljava/lang/reflect/Field;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008183 "Ljava/lang/reflect/Method;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008184 "Ljava/lang/reflect/Proxy;",
8185 "[Ljava/lang/String;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008186 "[Ljava/lang/reflect/Constructor;",
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008187 "[Ljava/lang/reflect/Field;",
Mathieu Chartierfc58af42015-04-16 18:00:39 -07008188 "[Ljava/lang/reflect/Method;",
Narayan Kamathafa48272016-08-03 12:46:58 +01008189 "Ljava/lang/invoke/MethodHandleImpl;",
8190 "Ljava/lang/invoke/MethodType;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008191 "Ljava/lang/ClassLoader;",
8192 "Ljava/lang/Throwable;",
8193 "Ljava/lang/ClassNotFoundException;",
8194 "Ljava/lang/StackTraceElement;",
Narayan Kamath000e1882016-10-24 17:14:25 +01008195 "Ldalvik/system/EmulatedStackFrame;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008196 "Z",
8197 "B",
8198 "C",
8199 "D",
8200 "F",
8201 "I",
8202 "J",
8203 "S",
8204 "V",
8205 "[Z",
8206 "[B",
8207 "[C",
8208 "[D",
8209 "[F",
8210 "[I",
8211 "[J",
8212 "[S",
8213 "[Ljava/lang/StackTraceElement;",
Alex Lightd6251582016-10-31 11:12:30 -07008214 "Ldalvik/system/ClassExt;",
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008215 };
Andreas Gampe575e78c2014-11-03 23:41:03 -08008216 static_assert(arraysize(class_roots_descriptors) == size_t(kClassRootsMax),
8217 "Mismatch between class descriptors and class-root enum");
Ian Rogers6f3dbba2014-10-14 17:41:57 -07008218
8219 const char* descriptor = class_roots_descriptors[class_root];
8220 CHECK(descriptor != nullptr);
8221 return descriptor;
8222}
8223
Jeff Hao5872d7c2016-04-27 11:07:41 -07008224jobject ClassLinker::CreatePathClassLoader(Thread* self,
8225 const std::vector<const DexFile*>& dex_files) {
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008226 // SOAAlreadyRunnable is protected, and we need something to add a global reference.
8227 // We could move the jobject to the callers, but all call-sites do this...
8228 ScopedObjectAccessUnchecked soa(self);
8229
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008230 // For now, create a libcore-level DexFile for each ART DexFile. This "explodes" multidex.
Mathieu Chartier3398c782016-09-30 10:27:43 -07008231 StackHandleScope<11> hs(self);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008232
Mathieu Chartierc7853442015-03-27 14:35:38 -07008233 ArtField* dex_elements_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008234 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList_dexElements);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008235
Mathieu Chartier3398c782016-09-30 10:27:43 -07008236 Handle<mirror::Class> dex_elements_class(hs.NewHandle(dex_elements_field->GetType<true>()));
8237 DCHECK(dex_elements_class.Get() != nullptr);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008238 DCHECK(dex_elements_class->IsArrayClass());
Mathieu Chartierdaaf3262015-03-24 13:30:28 -07008239 Handle<mirror::ObjectArray<mirror::Object>> h_dex_elements(hs.NewHandle(
Mathieu Chartier3398c782016-09-30 10:27:43 -07008240 mirror::ObjectArray<mirror::Object>::Alloc(self,
8241 dex_elements_class.Get(),
8242 dex_files.size())));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008243 Handle<mirror::Class> h_dex_element_class =
8244 hs.NewHandle(dex_elements_class->GetComponentType());
8245
Mathieu Chartierc7853442015-03-27 14:35:38 -07008246 ArtField* element_file_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008247 jni::DecodeArtField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008248 DCHECK_EQ(h_dex_element_class.Get(), element_file_field->GetDeclaringClass());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008249
Andreas Gampe08883de2016-11-08 13:20:52 -08008250 ArtField* cookie_field = jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_cookie);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008251 DCHECK_EQ(cookie_field->GetDeclaringClass(), element_file_field->GetType<false>());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008252
Andreas Gampe08883de2016-11-08 13:20:52 -08008253 ArtField* file_name_field = jni::DecodeArtField(WellKnownClasses::dalvik_system_DexFile_fileName);
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008254 DCHECK_EQ(file_name_field->GetDeclaringClass(), element_file_field->GetType<false>());
8255
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008256 // Fill the elements array.
8257 int32_t index = 0;
8258 for (const DexFile* dex_file : dex_files) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008259 StackHandleScope<4> hs2(self);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008260
Mathieu Chartier966878d2016-01-14 14:33:29 -08008261 // CreatePathClassLoader is only used by gtests. Index 0 of h_long_array is supposed to be the
8262 // oat file but we can leave it null.
Mathieu Chartiere58991b2015-10-13 07:59:34 -07008263 Handle<mirror::LongArray> h_long_array = hs2.NewHandle(mirror::LongArray::Alloc(
8264 self,
8265 kDexFileIndexStart + 1));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008266 DCHECK(h_long_array.Get() != nullptr);
Mathieu Chartiere58991b2015-10-13 07:59:34 -07008267 h_long_array->Set(kDexFileIndexStart, reinterpret_cast<intptr_t>(dex_file));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008268
8269 Handle<mirror::Object> h_dex_file = hs2.NewHandle(
Mathieu Chartierc7853442015-03-27 14:35:38 -07008270 cookie_field->GetDeclaringClass()->AllocObject(self));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008271 DCHECK(h_dex_file.Get() != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008272 cookie_field->SetObject<false>(h_dex_file.Get(), h_long_array.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008273
Mathieu Chartierfbc31082016-01-24 11:59:56 -08008274 Handle<mirror::String> h_file_name = hs2.NewHandle(
8275 mirror::String::AllocFromModifiedUtf8(self, dex_file->GetLocation().c_str()));
8276 DCHECK(h_file_name.Get() != nullptr);
8277 file_name_field->SetObject<false>(h_dex_file.Get(), h_file_name.Get());
8278
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008279 Handle<mirror::Object> h_element = hs2.NewHandle(h_dex_element_class->AllocObject(self));
8280 DCHECK(h_element.Get() != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008281 element_file_field->SetObject<false>(h_element.Get(), h_dex_file.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008282
8283 h_dex_elements->Set(index, h_element.Get());
8284 index++;
8285 }
8286 DCHECK_EQ(index, h_dex_elements->GetLength());
8287
8288 // Create DexPathList.
8289 Handle<mirror::Object> h_dex_path_list = hs.NewHandle(
Mathieu Chartierc7853442015-03-27 14:35:38 -07008290 dex_elements_field->GetDeclaringClass()->AllocObject(self));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008291 DCHECK(h_dex_path_list.Get() != nullptr);
8292 // Set elements.
Mathieu Chartierc7853442015-03-27 14:35:38 -07008293 dex_elements_field->SetObject<false>(h_dex_path_list.Get(), h_dex_elements.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008294
8295 // Create PathClassLoader.
8296 Handle<mirror::Class> h_path_class_class = hs.NewHandle(
Mathieu Chartier0795f232016-09-27 18:43:30 -07008297 soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008298 Handle<mirror::Object> h_path_class_loader = hs.NewHandle(
8299 h_path_class_class->AllocObject(self));
8300 DCHECK(h_path_class_loader.Get() != nullptr);
8301 // Set DexPathList.
Mathieu Chartierc7853442015-03-27 14:35:38 -07008302 ArtField* path_list_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08008303 jni::DecodeArtField(WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList);
Mathieu Chartierc7853442015-03-27 14:35:38 -07008304 DCHECK(path_list_field != nullptr);
8305 path_list_field->SetObject<false>(h_path_class_loader.Get(), h_dex_path_list.Get());
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008306
8307 // Make a pretend boot-classpath.
8308 // TODO: Should we scan the image?
Mathieu Chartierc7853442015-03-27 14:35:38 -07008309 ArtField* const parent_field =
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008310 mirror::Class::FindField(self, hs.NewHandle(h_path_class_loader->GetClass()), "parent",
Mathieu Chartierc7853442015-03-27 14:35:38 -07008311 "Ljava/lang/ClassLoader;");
Roland Levillainf39c9eb2015-05-26 15:02:07 +01008312 DCHECK(parent_field != nullptr);
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07008313 ObjPtr<mirror::Object> boot_cl =
Mathieu Chartier0795f232016-09-27 18:43:30 -07008314 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader)->AllocObject(self);
Mathieu Chartier966878d2016-01-14 14:33:29 -08008315 parent_field->SetObject<false>(h_path_class_loader.Get(), boot_cl);
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008316
8317 // Make it a global ref and return.
8318 ScopedLocalRef<jobject> local_ref(
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07008319 soa.Env(), soa.Env()->AddLocalReference<jobject>(h_path_class_loader.Get()));
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07008320 return soa.Env()->NewGlobalRef(local_ref.get());
8321}
8322
Nicolas Geoffray796d6302016-03-13 22:22:31 +00008323ArtMethod* ClassLinker::CreateRuntimeMethod(LinearAlloc* linear_alloc) {
Vladimir Marko14632852015-08-17 12:07:23 +01008324 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_);
8325 const size_t method_size = ArtMethod::Size(image_pointer_size_);
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008326 LengthPrefixedArray<ArtMethod>* method_array = AllocArtMethodArray(
8327 Thread::Current(),
Nicolas Geoffray796d6302016-03-13 22:22:31 +00008328 linear_alloc,
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008329 1);
Vladimir Markocf36d492015-08-12 19:27:26 +01008330 ArtMethod* method = &method_array->At(0, method_size, method_alignment);
Mathieu Chartiere401d142015-04-22 13:56:20 -07008331 CHECK(method != nullptr);
8332 method->SetDexMethodIndex(DexFile::kDexNoIndex);
8333 CHECK(method->IsRuntimeMethod());
8334 return method;
8335}
8336
Andreas Gampe8ac75952015-06-02 21:01:45 -07008337void ClassLinker::DropFindArrayClassCache() {
8338 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
8339 find_array_class_cache_next_victim_ = 0;
8340}
8341
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07008342void ClassLinker::ClearClassTableStrongRoots() const {
8343 Thread* const self = Thread::Current();
8344 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
8345 for (const ClassLoaderData& data : class_loaders_) {
8346 if (data.class_table != nullptr) {
8347 data.class_table->ClearStrongRoots();
8348 }
8349 }
8350}
8351
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008352void ClassLinker::VisitClassLoaders(ClassLoaderVisitor* visitor) const {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008353 Thread* const self = Thread::Current();
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008354 for (const ClassLoaderData& data : class_loaders_) {
Mathieu Chartier4843bd52015-10-01 17:08:44 -07008355 // Need to use DecodeJObject so that we get null for cleared JNI weak globals.
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008356 ObjPtr<mirror::ClassLoader> class_loader = ObjPtr<mirror::ClassLoader>::DownCast(
8357 self->DecodeJObject(data.weak_root));
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008358 if (class_loader != nullptr) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008359 visitor->Visit(class_loader.Ptr());
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008360 }
8361 }
8362}
8363
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008364void ClassLinker::InsertDexFileInToClassLoader(ObjPtr<mirror::Object> dex_file,
8365 ObjPtr<mirror::ClassLoader> class_loader) {
Mathieu Chartier00310e02015-10-17 12:46:42 -07008366 DCHECK(dex_file != nullptr);
Mathieu Chartier00310e02015-10-17 12:46:42 -07008367 Thread* const self = Thread::Current();
8368 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
Mathieu Chartierbc5a7952016-10-17 15:46:31 -07008369 ClassTable* const table = ClassTableForClassLoader(class_loader.Ptr());
Mathieu Chartier00310e02015-10-17 12:46:42 -07008370 DCHECK(table != nullptr);
Mathieu Chartierc9dbb1d2016-06-03 17:47:32 -07008371 if (table->InsertStrongRoot(dex_file) && class_loader != nullptr) {
Mathieu Chartier00310e02015-10-17 12:46:42 -07008372 // It was not already inserted, perform the write barrier to let the GC know the class loader's
8373 // class table was modified.
8374 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader);
8375 }
8376}
8377
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07008378void ClassLinker::CleanupClassLoaders() {
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008379 Thread* const self = Thread::Current();
Mathieu Chartier65975772016-08-05 10:46:36 -07008380 std::vector<ClassLoaderData> to_delete;
8381 // Do the delete outside the lock to avoid lock violation in jit code cache.
8382 {
8383 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
8384 for (auto it = class_loaders_.begin(); it != class_loaders_.end(); ) {
8385 const ClassLoaderData& data = *it;
8386 // Need to use DecodeJObject so that we get null for cleared JNI weak globals.
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008387 ObjPtr<mirror::ClassLoader> class_loader =
8388 ObjPtr<mirror::ClassLoader>::DownCast(self->DecodeJObject(data.weak_root));
Mathieu Chartier65975772016-08-05 10:46:36 -07008389 if (class_loader != nullptr) {
8390 ++it;
8391 } else {
8392 VLOG(class_linker) << "Freeing class loader";
8393 to_delete.push_back(data);
8394 it = class_loaders_.erase(it);
8395 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008396 }
8397 }
Mathieu Chartier65975772016-08-05 10:46:36 -07008398 for (ClassLoaderData& data : to_delete) {
8399 DeleteClassLoader(self, data);
8400 }
Mathieu Chartier9b1c71e2015-09-02 18:51:54 -07008401}
8402
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008403std::set<DexCacheResolvedClasses> ClassLinker::GetResolvedClasses(bool ignore_boot_classes) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08008404 ScopedTrace trace(__PRETTY_FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008405 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier268764d2016-09-13 12:09:38 -07008406 ScopedAssertNoThreadSuspension ants(__FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008407 std::set<DexCacheResolvedClasses> ret;
8408 VLOG(class_linker) << "Collecting resolved classes";
8409 const uint64_t start_time = NanoTime();
8410 ReaderMutexLock mu(soa.Self(), *DexLock());
8411 // Loop through all the dex caches and inspect resolved classes.
8412 for (const ClassLinker::DexCacheData& data : GetDexCachesData()) {
8413 if (soa.Self()->IsJWeakCleared(data.weak_root)) {
8414 continue;
8415 }
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008416 ObjPtr<mirror::DexCache> dex_cache = soa.Decode<mirror::DexCache>(data.weak_root);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008417 if (dex_cache == nullptr) {
8418 continue;
8419 }
8420 const DexFile* dex_file = dex_cache->GetDexFile();
8421 const std::string& location = dex_file->GetLocation();
8422 const size_t num_class_defs = dex_file->NumClassDefs();
8423 // Use the resolved types, this will miss array classes.
8424 const size_t num_types = dex_file->NumTypeIds();
8425 VLOG(class_linker) << "Collecting class profile for dex file " << location
8426 << " types=" << num_types << " class_defs=" << num_class_defs;
8427 DexCacheResolvedClasses resolved_classes(dex_file->GetLocation(),
Mathieu Chartier9275af62016-04-29 12:03:56 -07008428 dex_file->GetBaseLocation(),
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008429 dex_file->GetLocationChecksum());
8430 size_t num_resolved = 0;
Andreas Gampea5b09a62016-11-17 15:21:22 -08008431 std::unordered_set<dex::TypeIndex> class_set;
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008432 CHECK_EQ(num_types, dex_cache->NumResolvedTypes());
8433 for (size_t i = 0; i < num_types; ++i) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08008434 ObjPtr<mirror::Class> klass = dex_cache->GetResolvedType(dex::TypeIndex(i));
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008435 // Filter out null class loader since that is the boot class loader.
8436 if (klass == nullptr || (ignore_boot_classes && klass->GetClassLoader() == nullptr)) {
8437 continue;
8438 }
8439 ++num_resolved;
8440 DCHECK(!klass->IsProxyClass());
Andreas Gampe4309f612016-03-09 15:52:21 -08008441 if (!klass->IsResolved()) {
8442 DCHECK(klass->IsErroneous());
8443 continue;
8444 }
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008445 ObjPtr<mirror::DexCache> klass_dex_cache = klass->GetDexCache();
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008446 if (klass_dex_cache == dex_cache) {
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008447 DCHECK(klass->IsResolved());
Jeff Hao54b58552016-11-16 15:15:04 -08008448 CHECK_LT(klass->GetDexClassDefIndex(), num_class_defs);
8449 class_set.insert(klass->GetDexTypeIndex());
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008450 }
8451 }
8452
8453 if (!class_set.empty()) {
8454 auto it = ret.find(resolved_classes);
8455 if (it != ret.end()) {
Jeff Hao54b58552016-11-16 15:15:04 -08008456 // Already have the key, union the class type indexes.
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008457 it->AddClasses(class_set.begin(), class_set.end());
8458 } else {
8459 resolved_classes.AddClasses(class_set.begin(), class_set.end());
8460 ret.insert(resolved_classes);
8461 }
8462 }
8463
8464 VLOG(class_linker) << "Dex location " << location << " has " << num_resolved << " / "
8465 << num_class_defs << " resolved classes";
8466 }
8467 VLOG(class_linker) << "Collecting class profile took " << PrettyDuration(NanoTime() - start_time);
8468 return ret;
8469}
8470
8471std::unordered_set<std::string> ClassLinker::GetClassDescriptorsForProfileKeys(
8472 const std::set<DexCacheResolvedClasses>& classes) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08008473 ScopedTrace trace(__PRETTY_FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008474 std::unordered_set<std::string> ret;
8475 Thread* const self = Thread::Current();
8476 std::unordered_map<std::string, const DexFile*> location_to_dex_file;
8477 ScopedObjectAccess soa(self);
Mathieu Chartier268764d2016-09-13 12:09:38 -07008478 ScopedAssertNoThreadSuspension ants(__FUNCTION__);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008479 ReaderMutexLock mu(self, *DexLock());
8480 for (const ClassLinker::DexCacheData& data : GetDexCachesData()) {
8481 if (!self->IsJWeakCleared(data.weak_root)) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07008482 ObjPtr<mirror::DexCache> dex_cache = soa.Decode<mirror::DexCache>(data.weak_root);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008483 if (dex_cache != nullptr) {
8484 const DexFile* dex_file = dex_cache->GetDexFile();
8485 // There could be duplicates if two dex files with the same location are mapped.
8486 location_to_dex_file.emplace(
8487 ProfileCompilationInfo::GetProfileDexFileKey(dex_file->GetLocation()), dex_file);
8488 }
8489 }
8490 }
8491 for (const DexCacheResolvedClasses& info : classes) {
8492 const std::string& profile_key = info.GetDexLocation();
8493 auto found = location_to_dex_file.find(profile_key);
8494 if (found != location_to_dex_file.end()) {
8495 const DexFile* dex_file = found->second;
8496 VLOG(profiler) << "Found opened dex file for " << dex_file->GetLocation() << " with "
8497 << info.GetClasses().size() << " classes";
8498 DCHECK_EQ(dex_file->GetLocationChecksum(), info.GetLocationChecksum());
Andreas Gampea5b09a62016-11-17 15:21:22 -08008499 for (dex::TypeIndex type_idx : info.GetClasses()) {
Jeff Hao54b58552016-11-16 15:15:04 -08008500 const DexFile::TypeId& type_id = dex_file->GetTypeId(type_idx);
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08008501 const char* descriptor = dex_file->GetTypeDescriptor(type_id);
8502 ret.insert(descriptor);
8503 }
8504 } else {
8505 VLOG(class_linker) << "Failed to find opened dex file for profile key " << profile_key;
8506 }
8507 }
8508 return ret;
8509}
8510
Mathieu Chartier65975772016-08-05 10:46:36 -07008511class ClassLinker::FindVirtualMethodHolderVisitor : public ClassVisitor {
8512 public:
8513 FindVirtualMethodHolderVisitor(const ArtMethod* method, PointerSize pointer_size)
8514 : method_(method),
8515 pointer_size_(pointer_size) {}
8516
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008517 bool operator()(ObjPtr<mirror::Class> klass) REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE {
Mathieu Chartier65975772016-08-05 10:46:36 -07008518 if (klass->GetVirtualMethodsSliceUnchecked(pointer_size_).Contains(method_)) {
8519 holder_ = klass;
8520 }
8521 // Return false to stop searching if holder_ is not null.
8522 return holder_ == nullptr;
8523 }
8524
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008525 ObjPtr<mirror::Class> holder_ = nullptr;
Mathieu Chartier65975772016-08-05 10:46:36 -07008526 const ArtMethod* const method_;
8527 const PointerSize pointer_size_;
8528};
8529
8530mirror::Class* ClassLinker::GetHoldingClassOfCopiedMethod(ArtMethod* method) {
8531 ScopedTrace trace(__FUNCTION__); // Since this function is slow, have a trace to notify people.
8532 CHECK(method->IsCopied());
8533 FindVirtualMethodHolderVisitor visitor(method, image_pointer_size_);
8534 VisitClasses(&visitor);
Mathieu Chartier28357fa2016-10-18 16:27:40 -07008535 return visitor.holder_.Ptr();
Mathieu Chartier65975772016-08-05 10:46:36 -07008536}
8537
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08008538// Instantiate ResolveMethod.
8539template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kForceICCECheck>(
8540 const DexFile& dex_file,
8541 uint32_t method_idx,
8542 Handle<mirror::DexCache> dex_cache,
8543 Handle<mirror::ClassLoader> class_loader,
8544 ArtMethod* referrer,
8545 InvokeType type);
8546template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kNoICCECheckForCache>(
8547 const DexFile& dex_file,
8548 uint32_t method_idx,
8549 Handle<mirror::DexCache> dex_cache,
8550 Handle<mirror::ClassLoader> class_loader,
8551 ArtMethod* referrer,
8552 InvokeType type);
8553
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07008554} // namespace art