class_linker.cc revision cdca476bf3394ce9d97a369e84e701b427009318
1/* 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 */ 16 17#include "class_linker.h" 18 19#include <algorithm> 20#include <deque> 21#include <iostream> 22#include <memory> 23#include <queue> 24#include <string> 25#include <tuple> 26#include <unistd.h> 27#include <unordered_map> 28#include <utility> 29#include <vector> 30 31#include "art_field-inl.h" 32#include "art_method-inl.h" 33#include "base/arena_allocator.h" 34#include "base/casts.h" 35#include "base/logging.h" 36#include "base/scoped_arena_containers.h" 37#include "base/scoped_flock.h" 38#include "base/stl_util.h" 39#include "base/systrace.h" 40#include "base/time_utils.h" 41#include "base/unix_file/fd_file.h" 42#include "base/value_object.h" 43#include "class_linker-inl.h" 44#include "class_table-inl.h" 45#include "compiler_callbacks.h" 46#include "debugger.h" 47#include "dex_file-inl.h" 48#include "entrypoints/entrypoint_utils.h" 49#include "entrypoints/runtime_asm_entrypoints.h" 50#include "experimental_flags.h" 51#include "gc_root-inl.h" 52#include "gc/accounting/card_table-inl.h" 53#include "gc/accounting/heap_bitmap-inl.h" 54#include "gc/heap.h" 55#include "gc/space/image_space.h" 56#include "handle_scope-inl.h" 57#include "image-inl.h" 58#include "intern_table.h" 59#include "interpreter/interpreter.h" 60#include "jit/jit.h" 61#include "jit/jit_code_cache.h" 62#include "jit/offline_profiling_info.h" 63#include "leb128.h" 64#include "linear_alloc.h" 65#include "mirror/class.h" 66#include "mirror/class-inl.h" 67#include "mirror/class_loader.h" 68#include "mirror/dex_cache-inl.h" 69#include "mirror/field.h" 70#include "mirror/iftable-inl.h" 71#include "mirror/method.h" 72#include "mirror/object-inl.h" 73#include "mirror/object_array-inl.h" 74#include "mirror/proxy.h" 75#include "mirror/reference-inl.h" 76#include "mirror/stack_trace_element.h" 77#include "mirror/string-inl.h" 78#include "native/dalvik_system_DexFile.h" 79#include "oat.h" 80#include "oat_file.h" 81#include "oat_file-inl.h" 82#include "oat_file_assistant.h" 83#include "oat_file_manager.h" 84#include "object_lock.h" 85#include "os.h" 86#include "runtime.h" 87#include "ScopedLocalRef.h" 88#include "scoped_thread_state_change.h" 89#include "thread-inl.h" 90#include "trace.h" 91#include "utils.h" 92#include "utils/dex_cache_arrays_layout-inl.h" 93#include "verifier/method_verifier.h" 94#include "well_known_classes.h" 95 96namespace art { 97 98static constexpr bool kSanityCheckObjects = kIsDebugBuild; 99static constexpr bool kVerifyArtMethodDeclaringClasses = kIsDebugBuild; 100 101static void ThrowNoClassDefFoundError(const char* fmt, ...) 102 __attribute__((__format__(__printf__, 1, 2))) 103 SHARED_REQUIRES(Locks::mutator_lock_); 104static void ThrowNoClassDefFoundError(const char* fmt, ...) { 105 va_list args; 106 va_start(args, fmt); 107 Thread* self = Thread::Current(); 108 self->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args); 109 va_end(args); 110} 111 112static bool HasInitWithString(Thread* self, ClassLinker* class_linker, const char* descriptor) 113 SHARED_REQUIRES(Locks::mutator_lock_) { 114 ArtMethod* method = self->GetCurrentMethod(nullptr); 115 StackHandleScope<1> hs(self); 116 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(method != nullptr ? 117 method->GetDeclaringClass()->GetClassLoader() : nullptr)); 118 mirror::Class* exception_class = class_linker->FindClass(self, descriptor, class_loader); 119 120 if (exception_class == nullptr) { 121 // No exc class ~ no <init>-with-string. 122 CHECK(self->IsExceptionPending()); 123 self->ClearException(); 124 return false; 125 } 126 127 ArtMethod* exception_init_method = exception_class->FindDeclaredDirectMethod( 128 "<init>", "(Ljava/lang/String;)V", class_linker->GetImagePointerSize()); 129 return exception_init_method != nullptr; 130} 131 132// Helper for ThrowEarlierClassFailure. Throws the stored error. 133static void HandleEarlierVerifyError(Thread* self, ClassLinker* class_linker, mirror::Class* c) 134 SHARED_REQUIRES(Locks::mutator_lock_) { 135 mirror::Object* obj = c->GetVerifyError(); 136 DCHECK(obj != nullptr); 137 self->AssertNoPendingException(); 138 if (obj->IsClass()) { 139 // Previous error has been stored as class. Create a new exception of that type. 140 141 // It's possible the exception doesn't have a <init>(String). 142 std::string temp; 143 const char* descriptor = obj->AsClass()->GetDescriptor(&temp); 144 145 if (HasInitWithString(self, class_linker, descriptor)) { 146 self->ThrowNewException(descriptor, PrettyDescriptor(c).c_str()); 147 } else { 148 self->ThrowNewException(descriptor, nullptr); 149 } 150 } else { 151 // Previous error has been stored as an instance. Just rethrow. 152 mirror::Class* throwable_class = 153 self->DecodeJObject(WellKnownClasses::java_lang_Throwable)->AsClass(); 154 mirror::Class* error_class = obj->GetClass(); 155 CHECK(throwable_class->IsAssignableFrom(error_class)); 156 self->SetException(obj->AsThrowable()); 157 } 158 self->AssertPendingException(); 159} 160 161void ClassLinker::ThrowEarlierClassFailure(mirror::Class* c, bool wrap_in_no_class_def) { 162 // The class failed to initialize on a previous attempt, so we want to throw 163 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we 164 // failed in verification, in which case v2 5.4.1 says we need to re-throw 165 // the previous error. 166 Runtime* const runtime = Runtime::Current(); 167 if (!runtime->IsAotCompiler()) { // Give info if this occurs at runtime. 168 std::string extra; 169 if (c->GetVerifyError() != nullptr) { 170 mirror::Object* verify_error = c->GetVerifyError(); 171 if (verify_error->IsClass()) { 172 extra = PrettyDescriptor(verify_error->AsClass()); 173 } else { 174 extra = verify_error->AsThrowable()->Dump(); 175 } 176 } 177 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c) << ": " << extra; 178 } 179 180 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus(); 181 Thread* self = Thread::Current(); 182 if (runtime->IsAotCompiler()) { 183 // At compile time, accurate errors and NCDFE are disabled to speed compilation. 184 mirror::Throwable* pre_allocated = runtime->GetPreAllocatedNoClassDefFoundError(); 185 self->SetException(pre_allocated); 186 } else { 187 if (c->GetVerifyError() != nullptr) { 188 // Rethrow stored error. 189 HandleEarlierVerifyError(self, this, c); 190 } 191 if (c->GetVerifyError() == nullptr || wrap_in_no_class_def) { 192 // If there isn't a recorded earlier error, or this is a repeat throw from initialization, 193 // the top-level exception must be a NoClassDefFoundError. The potentially already pending 194 // exception will be a cause. 195 self->ThrowNewWrappedException("Ljava/lang/NoClassDefFoundError;", 196 PrettyDescriptor(c).c_str()); 197 } 198 } 199} 200 201static void VlogClassInitializationFailure(Handle<mirror::Class> klass) 202 SHARED_REQUIRES(Locks::mutator_lock_) { 203 if (VLOG_IS_ON(class_linker)) { 204 std::string temp; 205 LOG(INFO) << "Failed to initialize class " << klass->GetDescriptor(&temp) << " from " 206 << klass->GetLocation() << "\n" << Thread::Current()->GetException()->Dump(); 207 } 208} 209 210static void WrapExceptionInInitializer(Handle<mirror::Class> klass) 211 SHARED_REQUIRES(Locks::mutator_lock_) { 212 Thread* self = Thread::Current(); 213 JNIEnv* env = self->GetJniEnv(); 214 215 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred()); 216 CHECK(cause.get() != nullptr); 217 218 env->ExceptionClear(); 219 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error); 220 env->Throw(cause.get()); 221 222 // We only wrap non-Error exceptions; an Error can just be used as-is. 223 if (!is_error) { 224 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", nullptr); 225 } 226 VlogClassInitializationFailure(klass); 227} 228 229// Gap between two fields in object layout. 230struct FieldGap { 231 uint32_t start_offset; // The offset from the start of the object. 232 uint32_t size; // The gap size of 1, 2, or 4 bytes. 233}; 234struct FieldGapsComparator { 235 explicit FieldGapsComparator() { 236 } 237 bool operator() (const FieldGap& lhs, const FieldGap& rhs) 238 NO_THREAD_SAFETY_ANALYSIS { 239 // Sort by gap size, largest first. Secondary sort by starting offset. 240 // Note that the priority queue returns the largest element, so operator() 241 // should return true if lhs is less than rhs. 242 return lhs.size < rhs.size || (lhs.size == rhs.size && lhs.start_offset > rhs.start_offset); 243 } 244}; 245typedef std::priority_queue<FieldGap, std::vector<FieldGap>, FieldGapsComparator> FieldGaps; 246 247// Adds largest aligned gaps to queue of gaps. 248static void AddFieldGap(uint32_t gap_start, uint32_t gap_end, FieldGaps* gaps) { 249 DCHECK(gaps != nullptr); 250 251 uint32_t current_offset = gap_start; 252 while (current_offset != gap_end) { 253 size_t remaining = gap_end - current_offset; 254 if (remaining >= sizeof(uint32_t) && IsAligned<4>(current_offset)) { 255 gaps->push(FieldGap {current_offset, sizeof(uint32_t)}); 256 current_offset += sizeof(uint32_t); 257 } else if (remaining >= sizeof(uint16_t) && IsAligned<2>(current_offset)) { 258 gaps->push(FieldGap {current_offset, sizeof(uint16_t)}); 259 current_offset += sizeof(uint16_t); 260 } else { 261 gaps->push(FieldGap {current_offset, sizeof(uint8_t)}); 262 current_offset += sizeof(uint8_t); 263 } 264 DCHECK_LE(current_offset, gap_end) << "Overran gap"; 265 } 266} 267// Shuffle fields forward, making use of gaps whenever possible. 268template<int n> 269static void ShuffleForward(size_t* current_field_idx, 270 MemberOffset* field_offset, 271 std::deque<ArtField*>* grouped_and_sorted_fields, 272 FieldGaps* gaps) 273 SHARED_REQUIRES(Locks::mutator_lock_) { 274 DCHECK(current_field_idx != nullptr); 275 DCHECK(grouped_and_sorted_fields != nullptr); 276 DCHECK(gaps != nullptr); 277 DCHECK(field_offset != nullptr); 278 279 DCHECK(IsPowerOfTwo(n)); 280 while (!grouped_and_sorted_fields->empty()) { 281 ArtField* field = grouped_and_sorted_fields->front(); 282 Primitive::Type type = field->GetTypeAsPrimitiveType(); 283 if (Primitive::ComponentSize(type) < n) { 284 break; 285 } 286 if (!IsAligned<n>(field_offset->Uint32Value())) { 287 MemberOffset old_offset = *field_offset; 288 *field_offset = MemberOffset(RoundUp(field_offset->Uint32Value(), n)); 289 AddFieldGap(old_offset.Uint32Value(), field_offset->Uint32Value(), gaps); 290 } 291 CHECK(type != Primitive::kPrimNot) << PrettyField(field); // should be primitive types 292 grouped_and_sorted_fields->pop_front(); 293 if (!gaps->empty() && gaps->top().size >= n) { 294 FieldGap gap = gaps->top(); 295 gaps->pop(); 296 DCHECK_ALIGNED(gap.start_offset, n); 297 field->SetOffset(MemberOffset(gap.start_offset)); 298 if (gap.size > n) { 299 AddFieldGap(gap.start_offset + n, gap.start_offset + gap.size, gaps); 300 } 301 } else { 302 DCHECK_ALIGNED(field_offset->Uint32Value(), n); 303 field->SetOffset(*field_offset); 304 *field_offset = MemberOffset(field_offset->Uint32Value() + n); 305 } 306 ++(*current_field_idx); 307 } 308} 309 310ClassLinker::ClassLinker(InternTable* intern_table) 311 // dex_lock_ is recursive as it may be used in stack dumping. 312 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel), 313 dex_cache_boot_image_class_lookup_required_(false), 314 failed_dex_cache_class_lookups_(0), 315 class_roots_(nullptr), 316 array_iftable_(nullptr), 317 find_array_class_cache_next_victim_(0), 318 init_done_(false), 319 log_new_class_table_roots_(false), 320 intern_table_(intern_table), 321 quick_resolution_trampoline_(nullptr), 322 quick_imt_conflict_trampoline_(nullptr), 323 quick_generic_jni_trampoline_(nullptr), 324 quick_to_interpreter_bridge_trampoline_(nullptr), 325 image_pointer_size_(sizeof(void*)) { 326 CHECK(intern_table_ != nullptr); 327 static_assert(kFindArrayCacheSize == arraysize(find_array_class_cache_), 328 "Array cache size wrong."); 329 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr)); 330} 331 332void ClassLinker::CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor) { 333 mirror::Class* c2 = FindSystemClass(self, descriptor); 334 if (c2 == nullptr) { 335 LOG(FATAL) << "Could not find class " << descriptor; 336 UNREACHABLE(); 337 } 338 if (c1.Get() != c2) { 339 std::ostringstream os1, os2; 340 c1->DumpClass(os1, mirror::Class::kDumpClassFullDetail); 341 c2->DumpClass(os2, mirror::Class::kDumpClassFullDetail); 342 LOG(FATAL) << "InitWithoutImage: Class mismatch for " << descriptor 343 << ". This is most likely the result of a broken build. Make sure that " 344 << "libcore and art projects match.\n\n" 345 << os1.str() << "\n\n" << os2.str(); 346 UNREACHABLE(); 347 } 348} 349 350bool ClassLinker::InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path, 351 std::string* error_msg) { 352 VLOG(startup) << "ClassLinker::Init"; 353 354 Thread* const self = Thread::Current(); 355 Runtime* const runtime = Runtime::Current(); 356 gc::Heap* const heap = runtime->GetHeap(); 357 358 CHECK(!heap->HasBootImageSpace()) << "Runtime has image. We should use it."; 359 CHECK(!init_done_); 360 361 // Use the pointer size from the runtime since we are probably creating the image. 362 image_pointer_size_ = InstructionSetPointerSize(runtime->GetInstructionSet()); 363 if (!ValidPointerSize(image_pointer_size_)) { 364 *error_msg = StringPrintf("Invalid image pointer size: %zu", image_pointer_size_); 365 return false; 366 } 367 368 // java_lang_Class comes first, it's needed for AllocClass 369 // The GC can't handle an object with a null class since we can't get the size of this object. 370 heap->IncrementDisableMovingGC(self); 371 StackHandleScope<64> hs(self); // 64 is picked arbitrarily. 372 auto class_class_size = mirror::Class::ClassClassSize(image_pointer_size_); 373 Handle<mirror::Class> java_lang_Class(hs.NewHandle(down_cast<mirror::Class*>( 374 heap->AllocNonMovableObject<true>(self, nullptr, class_class_size, VoidFunctor())))); 375 CHECK(java_lang_Class.Get() != nullptr); 376 mirror::Class::SetClassClass(java_lang_Class.Get()); 377 java_lang_Class->SetClass(java_lang_Class.Get()); 378 if (kUseBakerOrBrooksReadBarrier) { 379 java_lang_Class->AssertReadBarrierPointer(); 380 } 381 java_lang_Class->SetClassSize(class_class_size); 382 java_lang_Class->SetPrimitiveType(Primitive::kPrimNot); 383 heap->DecrementDisableMovingGC(self); 384 // AllocClass(mirror::Class*) can now be used 385 386 // Class[] is used for reflection support. 387 auto class_array_class_size = mirror::ObjectArray<mirror::Class>::ClassSize(image_pointer_size_); 388 Handle<mirror::Class> class_array_class(hs.NewHandle( 389 AllocClass(self, java_lang_Class.Get(), class_array_class_size))); 390 class_array_class->SetComponentType(java_lang_Class.Get()); 391 392 // java_lang_Object comes next so that object_array_class can be created. 393 Handle<mirror::Class> java_lang_Object(hs.NewHandle( 394 AllocClass(self, java_lang_Class.Get(), mirror::Object::ClassSize(image_pointer_size_)))); 395 CHECK(java_lang_Object.Get() != nullptr); 396 // backfill Object as the super class of Class. 397 java_lang_Class->SetSuperClass(java_lang_Object.Get()); 398 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusLoaded, self); 399 400 java_lang_Object->SetObjectSize(sizeof(mirror::Object)); 401 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been 402 // cleared without triggering the read barrier and unintentionally mark the sentinel alive. 403 runtime->SetSentinel(heap->AllocNonMovableObject<true>(self, 404 java_lang_Object.Get(), 405 java_lang_Object->GetObjectSize(), 406 VoidFunctor())); 407 408 // Object[] next to hold class roots. 409 Handle<mirror::Class> object_array_class(hs.NewHandle( 410 AllocClass(self, java_lang_Class.Get(), 411 mirror::ObjectArray<mirror::Object>::ClassSize(image_pointer_size_)))); 412 object_array_class->SetComponentType(java_lang_Object.Get()); 413 414 // Setup the char (primitive) class to be used for char[]. 415 Handle<mirror::Class> char_class(hs.NewHandle( 416 AllocClass(self, java_lang_Class.Get(), 417 mirror::Class::PrimitiveClassSize(image_pointer_size_)))); 418 // The primitive char class won't be initialized by 419 // InitializePrimitiveClass until line 459, but strings (and 420 // internal char arrays) will be allocated before that and the 421 // component size, which is computed from the primitive type, needs 422 // to be set here. 423 char_class->SetPrimitiveType(Primitive::kPrimChar); 424 425 // Setup the char[] class to be used for String. 426 Handle<mirror::Class> char_array_class(hs.NewHandle( 427 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_)))); 428 char_array_class->SetComponentType(char_class.Get()); 429 mirror::CharArray::SetArrayClass(char_array_class.Get()); 430 431 // Setup String. 432 Handle<mirror::Class> java_lang_String(hs.NewHandle( 433 AllocClass(self, java_lang_Class.Get(), mirror::String::ClassSize(image_pointer_size_)))); 434 java_lang_String->SetStringClass(); 435 mirror::String::SetClass(java_lang_String.Get()); 436 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusResolved, self); 437 438 // Setup java.lang.ref.Reference. 439 Handle<mirror::Class> java_lang_ref_Reference(hs.NewHandle( 440 AllocClass(self, java_lang_Class.Get(), mirror::Reference::ClassSize(image_pointer_size_)))); 441 mirror::Reference::SetClass(java_lang_ref_Reference.Get()); 442 java_lang_ref_Reference->SetObjectSize(mirror::Reference::InstanceSize()); 443 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusResolved, self); 444 445 // Create storage for root classes, save away our work so far (requires descriptors). 446 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>( 447 mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.Get(), 448 kClassRootsMax)); 449 CHECK(!class_roots_.IsNull()); 450 SetClassRoot(kJavaLangClass, java_lang_Class.Get()); 451 SetClassRoot(kJavaLangObject, java_lang_Object.Get()); 452 SetClassRoot(kClassArrayClass, class_array_class.Get()); 453 SetClassRoot(kObjectArrayClass, object_array_class.Get()); 454 SetClassRoot(kCharArrayClass, char_array_class.Get()); 455 SetClassRoot(kJavaLangString, java_lang_String.Get()); 456 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference.Get()); 457 458 // Setup the primitive type classes. 459 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean)); 460 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte)); 461 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort)); 462 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt)); 463 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong)); 464 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat)); 465 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble)); 466 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid)); 467 468 // Create array interface entries to populate once we can load system classes. 469 array_iftable_ = GcRoot<mirror::IfTable>(AllocIfTable(self, 2)); 470 471 // Create int array type for AllocDexCache (done in AppendToBootClassPath). 472 Handle<mirror::Class> int_array_class(hs.NewHandle( 473 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_)))); 474 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt)); 475 mirror::IntArray::SetArrayClass(int_array_class.Get()); 476 SetClassRoot(kIntArrayClass, int_array_class.Get()); 477 478 // Create long array type for AllocDexCache (done in AppendToBootClassPath). 479 Handle<mirror::Class> long_array_class(hs.NewHandle( 480 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_)))); 481 long_array_class->SetComponentType(GetClassRoot(kPrimitiveLong)); 482 mirror::LongArray::SetArrayClass(long_array_class.Get()); 483 SetClassRoot(kLongArrayClass, long_array_class.Get()); 484 485 // now that these are registered, we can use AllocClass() and AllocObjectArray 486 487 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache. 488 Handle<mirror::Class> java_lang_DexCache(hs.NewHandle( 489 AllocClass(self, java_lang_Class.Get(), mirror::DexCache::ClassSize(image_pointer_size_)))); 490 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.Get()); 491 java_lang_DexCache->SetDexCacheClass(); 492 java_lang_DexCache->SetObjectSize(mirror::DexCache::InstanceSize()); 493 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusResolved, self); 494 495 // Set up array classes for string, field, method 496 Handle<mirror::Class> object_array_string(hs.NewHandle( 497 AllocClass(self, java_lang_Class.Get(), 498 mirror::ObjectArray<mirror::String>::ClassSize(image_pointer_size_)))); 499 object_array_string->SetComponentType(java_lang_String.Get()); 500 SetClassRoot(kJavaLangStringArrayClass, object_array_string.Get()); 501 502 LinearAlloc* linear_alloc = runtime->GetLinearAlloc(); 503 // Create runtime resolution and imt conflict methods. 504 runtime->SetResolutionMethod(runtime->CreateResolutionMethod()); 505 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod(linear_alloc)); 506 runtime->SetImtUnimplementedMethod(runtime->CreateImtConflictMethod(linear_alloc)); 507 508 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create 509 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses 510 // these roots. 511 if (boot_class_path.empty()) { 512 *error_msg = "Boot classpath is empty."; 513 return false; 514 } 515 for (auto& dex_file : boot_class_path) { 516 if (dex_file.get() == nullptr) { 517 *error_msg = "Null dex file."; 518 return false; 519 } 520 AppendToBootClassPath(self, *dex_file); 521 boot_dex_files_.push_back(std::move(dex_file)); 522 } 523 524 // now we can use FindSystemClass 525 526 // run char class through InitializePrimitiveClass to finish init 527 InitializePrimitiveClass(char_class.Get(), Primitive::kPrimChar); 528 SetClassRoot(kPrimitiveChar, char_class.Get()); // needs descriptor 529 530 // Set up GenericJNI entrypoint. That is mainly a hack for common_compiler_test.h so that 531 // we do not need friend classes or a publicly exposed setter. 532 quick_generic_jni_trampoline_ = GetQuickGenericJniStub(); 533 if (!runtime->IsAotCompiler()) { 534 // We need to set up the generic trampolines since we don't have an image. 535 quick_resolution_trampoline_ = GetQuickResolutionStub(); 536 quick_imt_conflict_trampoline_ = GetQuickImtConflictStub(); 537 quick_to_interpreter_bridge_trampoline_ = GetQuickToInterpreterBridge(); 538 } 539 540 // Object, String and DexCache need to be rerun through FindSystemClass to finish init 541 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusNotReady, self); 542 CheckSystemClass(self, java_lang_Object, "Ljava/lang/Object;"); 543 CHECK_EQ(java_lang_Object->GetObjectSize(), mirror::Object::InstanceSize()); 544 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusNotReady, self); 545 CheckSystemClass(self, java_lang_String, "Ljava/lang/String;"); 546 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusNotReady, self); 547 CheckSystemClass(self, java_lang_DexCache, "Ljava/lang/DexCache;"); 548 CHECK_EQ(java_lang_DexCache->GetObjectSize(), mirror::DexCache::InstanceSize()); 549 550 // Setup the primitive array type classes - can't be done until Object has a vtable. 551 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z")); 552 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass)); 553 554 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B")); 555 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass)); 556 557 CheckSystemClass(self, char_array_class, "[C"); 558 559 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S")); 560 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass)); 561 562 CheckSystemClass(self, int_array_class, "[I"); 563 CheckSystemClass(self, long_array_class, "[J"); 564 565 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F")); 566 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass)); 567 568 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D")); 569 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass)); 570 571 // Run Class through FindSystemClass. This initializes the dex_cache_ fields and register it 572 // in class_table_. 573 CheckSystemClass(self, java_lang_Class, "Ljava/lang/Class;"); 574 575 CheckSystemClass(self, class_array_class, "[Ljava/lang/Class;"); 576 CheckSystemClass(self, object_array_class, "[Ljava/lang/Object;"); 577 578 // Setup the single, global copy of "iftable". 579 auto java_lang_Cloneable = hs.NewHandle(FindSystemClass(self, "Ljava/lang/Cloneable;")); 580 CHECK(java_lang_Cloneable.Get() != nullptr); 581 auto java_io_Serializable = hs.NewHandle(FindSystemClass(self, "Ljava/io/Serializable;")); 582 CHECK(java_io_Serializable.Get() != nullptr); 583 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to 584 // crawl up and explicitly list all of the supers as well. 585 array_iftable_.Read()->SetInterface(0, java_lang_Cloneable.Get()); 586 array_iftable_.Read()->SetInterface(1, java_io_Serializable.Get()); 587 588 // Sanity check Class[] and Object[]'s interfaces. GetDirectInterface may cause thread 589 // suspension. 590 CHECK_EQ(java_lang_Cloneable.Get(), 591 mirror::Class::GetDirectInterface(self, class_array_class, 0)); 592 CHECK_EQ(java_io_Serializable.Get(), 593 mirror::Class::GetDirectInterface(self, class_array_class, 1)); 594 CHECK_EQ(java_lang_Cloneable.Get(), 595 mirror::Class::GetDirectInterface(self, object_array_class, 0)); 596 CHECK_EQ(java_io_Serializable.Get(), 597 mirror::Class::GetDirectInterface(self, object_array_class, 1)); 598 599 CHECK_EQ(object_array_string.Get(), 600 FindSystemClass(self, GetClassRootDescriptor(kJavaLangStringArrayClass))); 601 602 // End of special init trickery, all subsequent classes may be loaded via FindSystemClass. 603 604 // Create java.lang.reflect.Proxy root. 605 SetClassRoot(kJavaLangReflectProxy, FindSystemClass(self, "Ljava/lang/reflect/Proxy;")); 606 607 // Create java.lang.reflect.Field.class root. 608 auto* class_root = FindSystemClass(self, "Ljava/lang/reflect/Field;"); 609 CHECK(class_root != nullptr); 610 SetClassRoot(kJavaLangReflectField, class_root); 611 mirror::Field::SetClass(class_root); 612 613 // Create java.lang.reflect.Field array root. 614 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Field;"); 615 CHECK(class_root != nullptr); 616 SetClassRoot(kJavaLangReflectFieldArrayClass, class_root); 617 mirror::Field::SetArrayClass(class_root); 618 619 // Create java.lang.reflect.Constructor.class root and array root. 620 class_root = FindSystemClass(self, "Ljava/lang/reflect/Constructor;"); 621 CHECK(class_root != nullptr); 622 SetClassRoot(kJavaLangReflectConstructor, class_root); 623 mirror::Constructor::SetClass(class_root); 624 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Constructor;"); 625 CHECK(class_root != nullptr); 626 SetClassRoot(kJavaLangReflectConstructorArrayClass, class_root); 627 mirror::Constructor::SetArrayClass(class_root); 628 629 // Create java.lang.reflect.Method.class root and array root. 630 class_root = FindSystemClass(self, "Ljava/lang/reflect/Method;"); 631 CHECK(class_root != nullptr); 632 SetClassRoot(kJavaLangReflectMethod, class_root); 633 mirror::Method::SetClass(class_root); 634 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Method;"); 635 CHECK(class_root != nullptr); 636 SetClassRoot(kJavaLangReflectMethodArrayClass, class_root); 637 mirror::Method::SetArrayClass(class_root); 638 639 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes 640 // finish initializing Reference class 641 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusNotReady, self); 642 CheckSystemClass(self, java_lang_ref_Reference, "Ljava/lang/ref/Reference;"); 643 CHECK_EQ(java_lang_ref_Reference->GetObjectSize(), mirror::Reference::InstanceSize()); 644 CHECK_EQ(java_lang_ref_Reference->GetClassSize(), 645 mirror::Reference::ClassSize(image_pointer_size_)); 646 class_root = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"); 647 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal); 648 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagFinalizerReference); 649 class_root = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;"); 650 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal); 651 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagPhantomReference); 652 class_root = FindSystemClass(self, "Ljava/lang/ref/SoftReference;"); 653 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal); 654 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagSoftReference); 655 class_root = FindSystemClass(self, "Ljava/lang/ref/WeakReference;"); 656 CHECK_EQ(class_root->GetClassFlags(), mirror::kClassFlagNormal); 657 class_root->SetClassFlags(class_root->GetClassFlags() | mirror::kClassFlagWeakReference); 658 659 // Setup the ClassLoader, verifying the object_size_. 660 class_root = FindSystemClass(self, "Ljava/lang/ClassLoader;"); 661 class_root->SetClassLoaderClass(); 662 CHECK_EQ(class_root->GetObjectSize(), mirror::ClassLoader::InstanceSize()); 663 SetClassRoot(kJavaLangClassLoader, class_root); 664 665 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and 666 // java.lang.StackTraceElement as a convenience. 667 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;")); 668 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable)); 669 SetClassRoot(kJavaLangClassNotFoundException, 670 FindSystemClass(self, "Ljava/lang/ClassNotFoundException;")); 671 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;")); 672 SetClassRoot(kJavaLangStackTraceElementArrayClass, 673 FindSystemClass(self, "[Ljava/lang/StackTraceElement;")); 674 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement)); 675 676 // Ensure void type is resolved in the core's dex cache so java.lang.Void is correctly 677 // initialized. 678 { 679 const DexFile& dex_file = java_lang_Object->GetDexFile(); 680 const DexFile::TypeId* void_type_id = dex_file.FindTypeId("V"); 681 CHECK(void_type_id != nullptr); 682 uint16_t void_type_idx = dex_file.GetIndexForTypeId(*void_type_id); 683 // Now we resolve void type so the dex cache contains it. We use java.lang.Object class 684 // as referrer so the used dex cache is core's one. 685 mirror::Class* resolved_type = ResolveType(dex_file, void_type_idx, java_lang_Object.Get()); 686 CHECK_EQ(resolved_type, GetClassRoot(kPrimitiveVoid)); 687 self->AssertNoPendingException(); 688 } 689 690 // Create conflict tables that depend on the class linker. 691 runtime->FixupConflictTables(); 692 693 FinishInit(self); 694 695 VLOG(startup) << "ClassLinker::InitFromCompiler exiting"; 696 697 return true; 698} 699 700void ClassLinker::FinishInit(Thread* self) { 701 VLOG(startup) << "ClassLinker::FinishInit entering"; 702 703 // Let the heap know some key offsets into java.lang.ref instances 704 // Note: we hard code the field indexes here rather than using FindInstanceField 705 // as the types of the field can't be resolved prior to the runtime being 706 // fully initialized 707 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference); 708 mirror::Class* java_lang_ref_FinalizerReference = 709 FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"); 710 711 ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0); 712 CHECK_STREQ(pendingNext->GetName(), "pendingNext"); 713 CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;"); 714 715 ArtField* queue = java_lang_ref_Reference->GetInstanceField(1); 716 CHECK_STREQ(queue->GetName(), "queue"); 717 CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;"); 718 719 ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2); 720 CHECK_STREQ(queueNext->GetName(), "queueNext"); 721 CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;"); 722 723 ArtField* referent = java_lang_ref_Reference->GetInstanceField(3); 724 CHECK_STREQ(referent->GetName(), "referent"); 725 CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;"); 726 727 ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2); 728 CHECK_STREQ(zombie->GetName(), "zombie"); 729 CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;"); 730 731 // ensure all class_roots_ are initialized 732 for (size_t i = 0; i < kClassRootsMax; i++) { 733 ClassRoot class_root = static_cast<ClassRoot>(i); 734 mirror::Class* klass = GetClassRoot(class_root); 735 CHECK(klass != nullptr); 736 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != nullptr); 737 // note SetClassRoot does additional validation. 738 // if possible add new checks there to catch errors early 739 } 740 741 CHECK(!array_iftable_.IsNull()); 742 743 // disable the slow paths in FindClass and CreatePrimitiveClass now 744 // that Object, Class, and Object[] are setup 745 init_done_ = true; 746 747 VLOG(startup) << "ClassLinker::FinishInit exiting"; 748} 749 750void ClassLinker::RunRootClinits() { 751 Thread* self = Thread::Current(); 752 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) { 753 mirror::Class* c = GetClassRoot(ClassRoot(i)); 754 if (!c->IsArrayClass() && !c->IsPrimitive()) { 755 StackHandleScope<1> hs(self); 756 Handle<mirror::Class> h_class(hs.NewHandle(GetClassRoot(ClassRoot(i)))); 757 EnsureInitialized(self, h_class, true, true); 758 self->AssertNoPendingException(); 759 } 760 } 761} 762 763static void SanityCheckArtMethod(ArtMethod* m, 764 mirror::Class* expected_class, 765 const std::vector<gc::space::ImageSpace*>& spaces) 766 SHARED_REQUIRES(Locks::mutator_lock_) { 767 if (m->IsRuntimeMethod()) { 768 mirror::Class* declaring_class = m->GetDeclaringClassUnchecked(); 769 CHECK(declaring_class == nullptr) << declaring_class << " " << PrettyMethod(m); 770 } else if (m->IsCopied()) { 771 CHECK(m->GetDeclaringClass() != nullptr) << PrettyMethod(m); 772 } else if (expected_class != nullptr) { 773 CHECK_EQ(m->GetDeclaringClassUnchecked(), expected_class) << PrettyMethod(m); 774 } 775 if (!spaces.empty()) { 776 bool contains = false; 777 for (gc::space::ImageSpace* space : spaces) { 778 auto& header = space->GetImageHeader(); 779 size_t offset = reinterpret_cast<uint8_t*>(m) - space->Begin(); 780 781 const ImageSection& methods = header.GetMethodsSection(); 782 contains = contains || methods.Contains(offset); 783 784 const ImageSection& runtime_methods = header.GetRuntimeMethodsSection(); 785 contains = contains || runtime_methods.Contains(offset); 786 } 787 CHECK(contains) << m << " not found"; 788 } 789} 790 791static void SanityCheckArtMethodPointerArray(mirror::PointerArray* arr, 792 mirror::Class* expected_class, 793 size_t pointer_size, 794 const std::vector<gc::space::ImageSpace*>& spaces) 795 SHARED_REQUIRES(Locks::mutator_lock_) { 796 CHECK(arr != nullptr); 797 for (int32_t j = 0; j < arr->GetLength(); ++j) { 798 auto* method = arr->GetElementPtrSize<ArtMethod*>(j, pointer_size); 799 // expected_class == null means we are a dex cache. 800 if (expected_class != nullptr) { 801 CHECK(method != nullptr); 802 } 803 if (method != nullptr) { 804 SanityCheckArtMethod(method, expected_class, spaces); 805 } 806 } 807} 808 809static void SanityCheckArtMethodPointerArray(ArtMethod** arr, 810 size_t size, 811 size_t pointer_size, 812 const std::vector<gc::space::ImageSpace*>& spaces) 813 SHARED_REQUIRES(Locks::mutator_lock_) { 814 CHECK_EQ(arr != nullptr, size != 0u); 815 if (arr != nullptr) { 816 bool contains = false; 817 for (auto space : spaces) { 818 auto offset = reinterpret_cast<uint8_t*>(arr) - space->Begin(); 819 if (space->GetImageHeader().GetImageSection( 820 ImageHeader::kSectionDexCacheArrays).Contains(offset)) { 821 contains = true; 822 break; 823 } 824 } 825 CHECK(contains); 826 } 827 for (size_t j = 0; j < size; ++j) { 828 ArtMethod* method = mirror::DexCache::GetElementPtrSize(arr, j, pointer_size); 829 // expected_class == null means we are a dex cache. 830 if (method != nullptr) { 831 SanityCheckArtMethod(method, nullptr, spaces); 832 } 833 } 834} 835 836static void SanityCheckObjectsCallback(mirror::Object* obj, void* arg ATTRIBUTE_UNUSED) 837 SHARED_REQUIRES(Locks::mutator_lock_) { 838 DCHECK(obj != nullptr); 839 CHECK(obj->GetClass() != nullptr) << "Null class in object " << obj; 840 CHECK(obj->GetClass()->GetClass() != nullptr) << "Null class class " << obj; 841 if (obj->IsClass()) { 842 auto klass = obj->AsClass(); 843 for (ArtField& field : klass->GetIFields()) { 844 CHECK_EQ(field.GetDeclaringClass(), klass); 845 } 846 for (ArtField& field : klass->GetSFields()) { 847 CHECK_EQ(field.GetDeclaringClass(), klass); 848 } 849 auto* runtime = Runtime::Current(); 850 auto image_spaces = runtime->GetHeap()->GetBootImageSpaces(); 851 auto pointer_size = runtime->GetClassLinker()->GetImagePointerSize(); 852 for (auto& m : klass->GetMethods(pointer_size)) { 853 SanityCheckArtMethod(&m, klass, image_spaces); 854 } 855 auto* vtable = klass->GetVTable(); 856 if (vtable != nullptr) { 857 SanityCheckArtMethodPointerArray(vtable, nullptr, pointer_size, image_spaces); 858 } 859 if (klass->ShouldHaveEmbeddedImtAndVTable()) { 860 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) { 861 SanityCheckArtMethod( 862 klass->GetEmbeddedImTableEntry(i, pointer_size), nullptr, image_spaces); 863 } 864 for (int32_t i = 0; i < klass->GetEmbeddedVTableLength(); ++i) { 865 SanityCheckArtMethod(klass->GetEmbeddedVTableEntry(i, pointer_size), nullptr, image_spaces); 866 } 867 } 868 auto* iftable = klass->GetIfTable(); 869 if (iftable != nullptr) { 870 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) { 871 if (iftable->GetMethodArrayCount(i) > 0) { 872 SanityCheckArtMethodPointerArray( 873 iftable->GetMethodArray(i), nullptr, pointer_size, image_spaces); 874 } 875 } 876 } 877 } 878} 879 880// Set image methods' entry point to interpreter. 881class SetInterpreterEntrypointArtMethodVisitor : public ArtMethodVisitor { 882 public: 883 explicit SetInterpreterEntrypointArtMethodVisitor(size_t image_pointer_size) 884 : image_pointer_size_(image_pointer_size) {} 885 886 void Visit(ArtMethod* method) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) { 887 if (kIsDebugBuild && !method->IsRuntimeMethod()) { 888 CHECK(method->GetDeclaringClass() != nullptr); 889 } 890 if (!method->IsNative() && !method->IsRuntimeMethod() && !method->IsResolutionMethod()) { 891 method->SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(), 892 image_pointer_size_); 893 } 894 } 895 896 private: 897 const size_t image_pointer_size_; 898 899 DISALLOW_COPY_AND_ASSIGN(SetInterpreterEntrypointArtMethodVisitor); 900}; 901 902struct TrampolineCheckData { 903 const void* quick_resolution_trampoline; 904 const void* quick_imt_conflict_trampoline; 905 const void* quick_generic_jni_trampoline; 906 const void* quick_to_interpreter_bridge_trampoline; 907 size_t pointer_size; 908 ArtMethod* m; 909 bool error; 910}; 911 912static void CheckTrampolines(mirror::Object* obj, void* arg) NO_THREAD_SAFETY_ANALYSIS { 913 if (obj->IsClass()) { 914 mirror::Class* klass = obj->AsClass(); 915 TrampolineCheckData* d = reinterpret_cast<TrampolineCheckData*>(arg); 916 for (ArtMethod& m : klass->GetMethods(d->pointer_size)) { 917 const void* entrypoint = m.GetEntryPointFromQuickCompiledCodePtrSize(d->pointer_size); 918 if (entrypoint == d->quick_resolution_trampoline || 919 entrypoint == d->quick_imt_conflict_trampoline || 920 entrypoint == d->quick_generic_jni_trampoline || 921 entrypoint == d->quick_to_interpreter_bridge_trampoline) { 922 d->m = &m; 923 d->error = true; 924 return; 925 } 926 } 927 } 928} 929 930bool ClassLinker::InitFromBootImage(std::string* error_msg) { 931 VLOG(startup) << __FUNCTION__ << " entering"; 932 CHECK(!init_done_); 933 934 Runtime* const runtime = Runtime::Current(); 935 Thread* const self = Thread::Current(); 936 gc::Heap* const heap = runtime->GetHeap(); 937 std::vector<gc::space::ImageSpace*> spaces = heap->GetBootImageSpaces(); 938 CHECK(!spaces.empty()); 939 image_pointer_size_ = spaces[0]->GetImageHeader().GetPointerSize(); 940 if (!ValidPointerSize(image_pointer_size_)) { 941 *error_msg = StringPrintf("Invalid image pointer size: %zu", image_pointer_size_); 942 return false; 943 } 944 if (!runtime->IsAotCompiler()) { 945 // Only the Aot compiler supports having an image with a different pointer size than the 946 // runtime. This happens on the host for compiling 32 bit tests since we use a 64 bit libart 947 // compiler. We may also use 32 bit dex2oat on a system with 64 bit apps. 948 if (image_pointer_size_ != sizeof(void*)) { 949 *error_msg = StringPrintf("Runtime must use current image pointer size: %zu vs %zu", 950 image_pointer_size_, 951 sizeof(void*)); 952 return false; 953 } 954 } 955 dex_cache_boot_image_class_lookup_required_ = true; 956 std::vector<const OatFile*> oat_files = 957 runtime->GetOatFileManager().RegisterImageOatFiles(spaces); 958 DCHECK(!oat_files.empty()); 959 const OatHeader& default_oat_header = oat_files[0]->GetOatHeader(); 960 CHECK_EQ(default_oat_header.GetImageFileLocationOatChecksum(), 0U); 961 CHECK_EQ(default_oat_header.GetImageFileLocationOatDataBegin(), 0U); 962 const char* image_file_location = oat_files[0]->GetOatHeader(). 963 GetStoreValueByKey(OatHeader::kImageLocationKey); 964 CHECK(image_file_location == nullptr || *image_file_location == 0); 965 quick_resolution_trampoline_ = default_oat_header.GetQuickResolutionTrampoline(); 966 quick_imt_conflict_trampoline_ = default_oat_header.GetQuickImtConflictTrampoline(); 967 quick_generic_jni_trampoline_ = default_oat_header.GetQuickGenericJniTrampoline(); 968 quick_to_interpreter_bridge_trampoline_ = default_oat_header.GetQuickToInterpreterBridge(); 969 if (kIsDebugBuild) { 970 // Check that the other images use the same trampoline. 971 for (size_t i = 1; i < oat_files.size(); ++i) { 972 const OatHeader& ith_oat_header = oat_files[i]->GetOatHeader(); 973 const void* ith_quick_resolution_trampoline = 974 ith_oat_header.GetQuickResolutionTrampoline(); 975 const void* ith_quick_imt_conflict_trampoline = 976 ith_oat_header.GetQuickImtConflictTrampoline(); 977 const void* ith_quick_generic_jni_trampoline = 978 ith_oat_header.GetQuickGenericJniTrampoline(); 979 const void* ith_quick_to_interpreter_bridge_trampoline = 980 ith_oat_header.GetQuickToInterpreterBridge(); 981 if (ith_quick_resolution_trampoline != quick_resolution_trampoline_ || 982 ith_quick_imt_conflict_trampoline != quick_imt_conflict_trampoline_ || 983 ith_quick_generic_jni_trampoline != quick_generic_jni_trampoline_ || 984 ith_quick_to_interpreter_bridge_trampoline != quick_to_interpreter_bridge_trampoline_) { 985 // Make sure that all methods in this image do not contain those trampolines as 986 // entrypoints. Otherwise the class-linker won't be able to work with a single set. 987 TrampolineCheckData data; 988 data.error = false; 989 data.pointer_size = GetImagePointerSize(); 990 data.quick_resolution_trampoline = ith_quick_resolution_trampoline; 991 data.quick_imt_conflict_trampoline = ith_quick_imt_conflict_trampoline; 992 data.quick_generic_jni_trampoline = ith_quick_generic_jni_trampoline; 993 data.quick_to_interpreter_bridge_trampoline = ith_quick_to_interpreter_bridge_trampoline; 994 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_); 995 spaces[i]->GetLiveBitmap()->Walk(CheckTrampolines, &data); 996 if (data.error) { 997 ArtMethod* m = data.m; 998 LOG(ERROR) << "Found a broken ArtMethod: " << PrettyMethod(m); 999 *error_msg = "Found an ArtMethod with a bad entrypoint"; 1000 return false; 1001 } 1002 } 1003 } 1004 } 1005 1006 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>( 1007 down_cast<mirror::ObjectArray<mirror::Class>*>( 1008 spaces[0]->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots))); 1009 mirror::Class::SetClassClass(class_roots_.Read()->Get(kJavaLangClass)); 1010 1011 // Special case of setting up the String class early so that we can test arbitrary objects 1012 // as being Strings or not 1013 mirror::String::SetClass(GetClassRoot(kJavaLangString)); 1014 1015 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject); 1016 java_lang_Object->SetObjectSize(sizeof(mirror::Object)); 1017 // Allocate in non-movable so that it's possible to check if a JNI weak global ref has been 1018 // cleared without triggering the read barrier and unintentionally mark the sentinel alive. 1019 runtime->SetSentinel(heap->AllocNonMovableObject<true>( 1020 self, java_lang_Object, java_lang_Object->GetObjectSize(), VoidFunctor())); 1021 1022 // reinit array_iftable_ from any array class instance, they should be == 1023 array_iftable_ = GcRoot<mirror::IfTable>(GetClassRoot(kObjectArrayClass)->GetIfTable()); 1024 DCHECK_EQ(array_iftable_.Read(), GetClassRoot(kBooleanArrayClass)->GetIfTable()); 1025 // String class root was set above 1026 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField)); 1027 mirror::Field::SetArrayClass(GetClassRoot(kJavaLangReflectFieldArrayClass)); 1028 mirror::Constructor::SetClass(GetClassRoot(kJavaLangReflectConstructor)); 1029 mirror::Constructor::SetArrayClass(GetClassRoot(kJavaLangReflectConstructorArrayClass)); 1030 mirror::Method::SetClass(GetClassRoot(kJavaLangReflectMethod)); 1031 mirror::Method::SetArrayClass(GetClassRoot(kJavaLangReflectMethodArrayClass)); 1032 mirror::Reference::SetClass(GetClassRoot(kJavaLangRefReference)); 1033 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass)); 1034 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass)); 1035 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass)); 1036 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass)); 1037 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass)); 1038 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass)); 1039 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass)); 1040 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass)); 1041 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable)); 1042 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement)); 1043 1044 for (gc::space::ImageSpace* image_space : spaces) { 1045 // Boot class loader, use a null handle. 1046 std::vector<std::unique_ptr<const DexFile>> dex_files; 1047 if (!AddImageSpace(image_space, 1048 ScopedNullHandle<mirror::ClassLoader>(), 1049 /*dex_elements*/nullptr, 1050 /*dex_location*/nullptr, 1051 /*out*/&dex_files, 1052 error_msg)) { 1053 return false; 1054 } 1055 // Append opened dex files at the end. 1056 boot_dex_files_.insert(boot_dex_files_.end(), 1057 std::make_move_iterator(dex_files.begin()), 1058 std::make_move_iterator(dex_files.end())); 1059 } 1060 FinishInit(self); 1061 1062 VLOG(startup) << __FUNCTION__ << " exiting"; 1063 return true; 1064} 1065 1066bool ClassLinker::IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa, 1067 mirror::ClassLoader* class_loader) { 1068 return class_loader == nullptr || 1069 class_loader->GetClass() == 1070 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader); 1071} 1072 1073static mirror::String* GetDexPathListElementName(ScopedObjectAccessUnchecked& soa, 1074 mirror::Object* element) 1075 SHARED_REQUIRES(Locks::mutator_lock_) { 1076 ArtField* const dex_file_field = 1077 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile); 1078 ArtField* const dex_file_name_field = 1079 soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_fileName); 1080 DCHECK(dex_file_field != nullptr); 1081 DCHECK(dex_file_name_field != nullptr); 1082 DCHECK(element != nullptr); 1083 CHECK_EQ(dex_file_field->GetDeclaringClass(), element->GetClass()) << PrettyTypeOf(element); 1084 mirror::Object* dex_file = dex_file_field->GetObject(element); 1085 if (dex_file == nullptr) { 1086 return nullptr; 1087 } 1088 mirror::Object* const name_object = dex_file_name_field->GetObject(dex_file); 1089 if (name_object != nullptr) { 1090 return name_object->AsString(); 1091 } 1092 return nullptr; 1093} 1094 1095static bool FlattenPathClassLoader(mirror::ClassLoader* class_loader, 1096 std::list<mirror::String*>* out_dex_file_names, 1097 std::string* error_msg) 1098 SHARED_REQUIRES(Locks::mutator_lock_) { 1099 DCHECK(out_dex_file_names != nullptr); 1100 DCHECK(error_msg != nullptr); 1101 ScopedObjectAccessUnchecked soa(Thread::Current()); 1102 ArtField* const dex_path_list_field = 1103 soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList); 1104 ArtField* const dex_elements_field = 1105 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements); 1106 CHECK(dex_path_list_field != nullptr); 1107 CHECK(dex_elements_field != nullptr); 1108 while (!ClassLinker::IsBootClassLoader(soa, class_loader)) { 1109 if (class_loader->GetClass() != 1110 soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader)) { 1111 *error_msg = StringPrintf("Unknown class loader type %s", PrettyTypeOf(class_loader).c_str()); 1112 // Unsupported class loader. 1113 return false; 1114 } 1115 mirror::Object* dex_path_list = dex_path_list_field->GetObject(class_loader); 1116 if (dex_path_list != nullptr) { 1117 // DexPathList has an array dexElements of Elements[] which each contain a dex file. 1118 mirror::Object* dex_elements_obj = dex_elements_field->GetObject(dex_path_list); 1119 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look 1120 // at the mCookie which is a DexFile vector. 1121 if (dex_elements_obj != nullptr) { 1122 mirror::ObjectArray<mirror::Object>* dex_elements = 1123 dex_elements_obj->AsObjectArray<mirror::Object>(); 1124 // Reverse order since we insert the parent at the front. 1125 for (int32_t i = dex_elements->GetLength() - 1; i >= 0; --i) { 1126 mirror::Object* const element = dex_elements->GetWithoutChecks(i); 1127 if (element == nullptr) { 1128 *error_msg = StringPrintf("Null dex element at index %d", i); 1129 return false; 1130 } 1131 mirror::String* const name = GetDexPathListElementName(soa, element); 1132 if (name == nullptr) { 1133 *error_msg = StringPrintf("Null name for dex element at index %d", i); 1134 return false; 1135 } 1136 out_dex_file_names->push_front(name); 1137 } 1138 } 1139 } 1140 class_loader = class_loader->GetParent(); 1141 } 1142 return true; 1143} 1144 1145class FixupArtMethodArrayVisitor : public ArtMethodVisitor { 1146 public: 1147 explicit FixupArtMethodArrayVisitor(const ImageHeader& header) : header_(header) {} 1148 1149 virtual void Visit(ArtMethod* method) SHARED_REQUIRES(Locks::mutator_lock_) { 1150 GcRoot<mirror::Class>* resolved_types = method->GetDexCacheResolvedTypes(sizeof(void*)); 1151 const bool is_copied = method->IsCopied(); 1152 if (resolved_types != nullptr) { 1153 bool in_image_space = false; 1154 if (kIsDebugBuild || is_copied) { 1155 in_image_space = header_.GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains( 1156 reinterpret_cast<const uint8_t*>(resolved_types) - header_.GetImageBegin()); 1157 } 1158 // Must be in image space for non-miranda method. 1159 DCHECK(is_copied || in_image_space) 1160 << resolved_types << " is not in image starting at " 1161 << reinterpret_cast<void*>(header_.GetImageBegin()); 1162 if (!is_copied || in_image_space) { 1163 // Go through the array so that we don't need to do a slow map lookup. 1164 method->SetDexCacheResolvedTypes(*reinterpret_cast<GcRoot<mirror::Class>**>(resolved_types), 1165 sizeof(void*)); 1166 } 1167 } 1168 ArtMethod** resolved_methods = method->GetDexCacheResolvedMethods(sizeof(void*)); 1169 if (resolved_methods != nullptr) { 1170 bool in_image_space = false; 1171 if (kIsDebugBuild || is_copied) { 1172 in_image_space = header_.GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains( 1173 reinterpret_cast<const uint8_t*>(resolved_methods) - header_.GetImageBegin()); 1174 } 1175 // Must be in image space for non-miranda method. 1176 DCHECK(is_copied || in_image_space) 1177 << resolved_methods << " is not in image starting at " 1178 << reinterpret_cast<void*>(header_.GetImageBegin()); 1179 if (!is_copied || in_image_space) { 1180 // Go through the array so that we don't need to do a slow map lookup. 1181 method->SetDexCacheResolvedMethods(*reinterpret_cast<ArtMethod***>(resolved_methods), 1182 sizeof(void*)); 1183 } 1184 } 1185 } 1186 1187 private: 1188 const ImageHeader& header_; 1189}; 1190 1191class VerifyClassInTableArtMethodVisitor : public ArtMethodVisitor { 1192 public: 1193 explicit VerifyClassInTableArtMethodVisitor(ClassTable* table) : table_(table) {} 1194 1195 virtual void Visit(ArtMethod* method) 1196 SHARED_REQUIRES(Locks::mutator_lock_, Locks::classlinker_classes_lock_) { 1197 mirror::Class* klass = method->GetDeclaringClass(); 1198 if (klass != nullptr && !Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) { 1199 CHECK_EQ(table_->LookupByDescriptor(klass), klass) << PrettyClass(klass); 1200 } 1201 } 1202 1203 private: 1204 ClassTable* const table_; 1205}; 1206 1207class VerifyDeclaringClassVisitor : public ArtMethodVisitor { 1208 public: 1209 VerifyDeclaringClassVisitor() SHARED_REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_) 1210 : live_bitmap_(Runtime::Current()->GetHeap()->GetLiveBitmap()) {} 1211 1212 virtual void Visit(ArtMethod* method) 1213 SHARED_REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_) { 1214 mirror::Class* klass = method->GetDeclaringClassUnchecked(); 1215 if (klass != nullptr) { 1216 CHECK(live_bitmap_->Test(klass)) << "Image method has unmarked declaring class"; 1217 } 1218 } 1219 1220 private: 1221 gc::accounting::HeapBitmap* const live_bitmap_; 1222}; 1223 1224bool ClassLinker::UpdateAppImageClassLoadersAndDexCaches( 1225 gc::space::ImageSpace* space, 1226 Handle<mirror::ClassLoader> class_loader, 1227 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches, 1228 ClassTable::ClassSet* new_class_set, 1229 bool* out_forward_dex_cache_array, 1230 std::string* out_error_msg) { 1231 DCHECK(out_forward_dex_cache_array != nullptr); 1232 DCHECK(out_error_msg != nullptr); 1233 Thread* const self = Thread::Current(); 1234 gc::Heap* const heap = Runtime::Current()->GetHeap(); 1235 const ImageHeader& header = space->GetImageHeader(); 1236 { 1237 // Add image classes into the class table for the class loader, and fixup the dex caches and 1238 // class loader fields. 1239 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 1240 ClassTable* table = InsertClassTableForClassLoader(class_loader.Get()); 1241 // Dex cache array fixup is all or nothing, we must reject app images that have mixed since we 1242 // rely on clobering the dex cache arrays in the image to forward to bss. 1243 size_t num_dex_caches_with_bss_arrays = 0; 1244 const size_t num_dex_caches = dex_caches->GetLength(); 1245 for (size_t i = 0; i < num_dex_caches; i++) { 1246 mirror::DexCache* const dex_cache = dex_caches->Get(i); 1247 const DexFile* const dex_file = dex_cache->GetDexFile(); 1248 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile(); 1249 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) { 1250 ++num_dex_caches_with_bss_arrays; 1251 } 1252 } 1253 *out_forward_dex_cache_array = num_dex_caches_with_bss_arrays != 0; 1254 if (*out_forward_dex_cache_array) { 1255 if (num_dex_caches_with_bss_arrays != num_dex_caches) { 1256 // Reject application image since we cannot forward only some of the dex cache arrays. 1257 // TODO: We could get around this by having a dedicated forwarding slot. It should be an 1258 // uncommon case. 1259 *out_error_msg = StringPrintf("Dex caches in bss does not match total: %zu vs %zu", 1260 num_dex_caches_with_bss_arrays, 1261 num_dex_caches); 1262 return false; 1263 } 1264 } 1265 // Only add the classes to the class loader after the points where we can return false. 1266 for (size_t i = 0; i < num_dex_caches; i++) { 1267 mirror::DexCache* const dex_cache = dex_caches->Get(i); 1268 const DexFile* const dex_file = dex_cache->GetDexFile(); 1269 const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile(); 1270 if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) { 1271 // If the oat file expects the dex cache arrays to be in the BSS, then allocate there and 1272 // copy over the arrays. 1273 DCHECK(dex_file != nullptr); 1274 const size_t num_strings = dex_file->NumStringIds(); 1275 const size_t num_types = dex_file->NumTypeIds(); 1276 const size_t num_methods = dex_file->NumMethodIds(); 1277 const size_t num_fields = dex_file->NumFieldIds(); 1278 CHECK_EQ(num_strings, dex_cache->NumStrings()); 1279 CHECK_EQ(num_types, dex_cache->NumResolvedTypes()); 1280 CHECK_EQ(num_methods, dex_cache->NumResolvedMethods()); 1281 CHECK_EQ(num_fields, dex_cache->NumResolvedFields()); 1282 DexCacheArraysLayout layout(image_pointer_size_, dex_file); 1283 uint8_t* const raw_arrays = oat_dex_file->GetDexCacheArrays(); 1284 // The space is not yet visible to the GC, we can avoid the read barriers and use 1285 // std::copy_n. 1286 if (num_strings != 0u) { 1287 GcRoot<mirror::String>* const image_resolved_strings = dex_cache->GetStrings(); 1288 GcRoot<mirror::String>* const strings = 1289 reinterpret_cast<GcRoot<mirror::String>*>(raw_arrays + layout.StringsOffset()); 1290 for (size_t j = 0; kIsDebugBuild && j < num_strings; ++j) { 1291 DCHECK(strings[j].IsNull()); 1292 } 1293 std::copy_n(image_resolved_strings, num_strings, strings); 1294 dex_cache->SetStrings(strings); 1295 } 1296 if (num_types != 0u) { 1297 GcRoot<mirror::Class>* const image_resolved_types = dex_cache->GetResolvedTypes(); 1298 GcRoot<mirror::Class>* const types = 1299 reinterpret_cast<GcRoot<mirror::Class>*>(raw_arrays + layout.TypesOffset()); 1300 for (size_t j = 0; kIsDebugBuild && j < num_types; ++j) { 1301 DCHECK(types[j].IsNull()); 1302 } 1303 std::copy_n(image_resolved_types, num_types, types); 1304 // Store a pointer to the new location for fast ArtMethod patching without requiring map. 1305 // This leaves random garbage at the start of the dex cache array, but nobody should ever 1306 // read from it again. 1307 *reinterpret_cast<GcRoot<mirror::Class>**>(image_resolved_types) = types; 1308 dex_cache->SetResolvedTypes(types); 1309 } 1310 if (num_methods != 0u) { 1311 ArtMethod** const methods = reinterpret_cast<ArtMethod**>( 1312 raw_arrays + layout.MethodsOffset()); 1313 ArtMethod** const image_resolved_methods = dex_cache->GetResolvedMethods(); 1314 for (size_t j = 0; kIsDebugBuild && j < num_methods; ++j) { 1315 DCHECK(methods[j] == nullptr); 1316 } 1317 std::copy_n(image_resolved_methods, num_methods, methods); 1318 // Store a pointer to the new location for fast ArtMethod patching without requiring map. 1319 *reinterpret_cast<ArtMethod***>(image_resolved_methods) = methods; 1320 dex_cache->SetResolvedMethods(methods); 1321 } 1322 if (num_fields != 0u) { 1323 ArtField** const fields = 1324 reinterpret_cast<ArtField**>(raw_arrays + layout.FieldsOffset()); 1325 for (size_t j = 0; kIsDebugBuild && j < num_fields; ++j) { 1326 DCHECK(fields[j] == nullptr); 1327 } 1328 std::copy_n(dex_cache->GetResolvedFields(), num_fields, fields); 1329 dex_cache->SetResolvedFields(fields); 1330 } 1331 } 1332 { 1333 WriterMutexLock mu2(self, dex_lock_); 1334 // Make sure to do this after we update the arrays since we store the resolved types array 1335 // in DexCacheData in RegisterDexFileLocked. We need the array pointer to be the one in the 1336 // BSS. 1337 mirror::DexCache* existing_dex_cache = FindDexCacheLocked(self, 1338 *dex_file, 1339 /*allow_failure*/true); 1340 CHECK(existing_dex_cache == nullptr); 1341 StackHandleScope<1> hs3(self); 1342 RegisterDexFileLocked(*dex_file, hs3.NewHandle(dex_cache)); 1343 } 1344 GcRoot<mirror::Class>* const types = dex_cache->GetResolvedTypes(); 1345 const size_t num_types = dex_cache->NumResolvedTypes(); 1346 if (new_class_set == nullptr) { 1347 for (int32_t j = 0; j < static_cast<int32_t>(num_types); j++) { 1348 // The image space is not yet added to the heap, avoid read barriers. 1349 mirror::Class* klass = types[j].Read(); 1350 if (klass != nullptr) { 1351 DCHECK_NE(klass->GetStatus(), mirror::Class::kStatusError); 1352 // Update the class loader from the one in the image class loader to the one that loaded 1353 // the app image. 1354 klass->SetClassLoader(class_loader.Get()); 1355 // The resolved type could be from another dex cache, go through the dex cache just in 1356 // case. May be null for array classes. 1357 if (klass->GetDexCacheStrings() != nullptr) { 1358 DCHECK(!klass->IsArrayClass()); 1359 klass->SetDexCacheStrings(klass->GetDexCache()->GetStrings()); 1360 } 1361 // If there are multiple dex caches, there may be the same class multiple times 1362 // in different dex caches. Check for this since inserting will add duplicates 1363 // otherwise. 1364 if (num_dex_caches > 1) { 1365 mirror::Class* existing = table->LookupByDescriptor(klass); 1366 if (existing != nullptr) { 1367 DCHECK_EQ(existing, klass) << PrettyClass(klass); 1368 } else { 1369 table->Insert(klass); 1370 } 1371 } else { 1372 table->Insert(klass); 1373 } 1374 // Double checked VLOG to avoid overhead. 1375 if (VLOG_IS_ON(image)) { 1376 VLOG(image) << PrettyClass(klass) << " " << klass->GetStatus(); 1377 if (!klass->IsArrayClass()) { 1378 VLOG(image) << "From " << klass->GetDexCache()->GetDexFile()->GetBaseLocation(); 1379 } 1380 VLOG(image) << "Direct methods"; 1381 for (ArtMethod& m : klass->GetDirectMethods(sizeof(void*))) { 1382 VLOG(image) << PrettyMethod(&m); 1383 } 1384 VLOG(image) << "Virtual methods"; 1385 for (ArtMethod& m : klass->GetVirtualMethods(sizeof(void*))) { 1386 VLOG(image) << PrettyMethod(&m); 1387 } 1388 } 1389 } 1390 } 1391 } 1392 if (kIsDebugBuild) { 1393 for (int32_t j = 0; j < static_cast<int32_t>(num_types); j++) { 1394 // The image space is not yet added to the heap, avoid read barriers. 1395 mirror::Class* klass = types[j].Read(); 1396 if (klass != nullptr) { 1397 DCHECK_NE(klass->GetStatus(), mirror::Class::kStatusError); 1398 if (kIsDebugBuild) { 1399 if (new_class_set != nullptr) { 1400 auto it = new_class_set->Find(GcRoot<mirror::Class>(klass)); 1401 DCHECK(it != new_class_set->end()); 1402 DCHECK_EQ(it->Read(), klass); 1403 mirror::Class* super_class = klass->GetSuperClass(); 1404 if (super_class != nullptr && !heap->ObjectIsInBootImageSpace(super_class)) { 1405 auto it2 = new_class_set->Find(GcRoot<mirror::Class>(super_class)); 1406 DCHECK(it2 != new_class_set->end()); 1407 DCHECK_EQ(it2->Read(), super_class); 1408 } 1409 } else { 1410 DCHECK_EQ(table->LookupByDescriptor(klass), klass); 1411 mirror::Class* super_class = klass->GetSuperClass(); 1412 if (super_class != nullptr && !heap->ObjectIsInBootImageSpace(super_class)) { 1413 CHECK_EQ(table->LookupByDescriptor(super_class), super_class); 1414 } 1415 } 1416 } 1417 if (kIsDebugBuild) { 1418 for (ArtMethod& m : klass->GetDirectMethods(sizeof(void*))) { 1419 const void* code = m.GetEntryPointFromQuickCompiledCode(); 1420 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code; 1421 if (!IsQuickResolutionStub(code) && 1422 !IsQuickGenericJniStub(code) && 1423 !IsQuickToInterpreterBridge(code) && 1424 !m.IsNative()) { 1425 DCHECK_EQ(code, oat_code) << PrettyMethod(&m); 1426 } 1427 } 1428 for (ArtMethod& m : klass->GetVirtualMethods(sizeof(void*))) { 1429 const void* code = m.GetEntryPointFromQuickCompiledCode(); 1430 const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code; 1431 if (!IsQuickResolutionStub(code) && 1432 !IsQuickGenericJniStub(code) && 1433 !IsQuickToInterpreterBridge(code) && 1434 !m.IsNative()) { 1435 DCHECK_EQ(code, oat_code) << PrettyMethod(&m); 1436 } 1437 } 1438 } 1439 } 1440 } 1441 } 1442 } 1443 } 1444 if (*out_forward_dex_cache_array) { 1445 ScopedTrace timing("Fixup ArtMethod dex cache arrays"); 1446 FixupArtMethodArrayVisitor visitor(header); 1447 header.VisitPackedArtMethods(&visitor, space->Begin(), sizeof(void*)); 1448 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader.Get()); 1449 } 1450 if (kVerifyArtMethodDeclaringClasses) { 1451 ScopedTrace timing("Verify declaring classes"); 1452 ReaderMutexLock rmu(self, *Locks::heap_bitmap_lock_); 1453 VerifyDeclaringClassVisitor visitor; 1454 header.VisitPackedArtMethods(&visitor, space->Begin(), sizeof(void*)); 1455 } 1456 return true; 1457} 1458 1459// Update the class loader and resolved string dex cache array of classes. Should only be used on 1460// classes in the image space. 1461class UpdateClassLoaderAndResolvedStringsVisitor { 1462 public: 1463 UpdateClassLoaderAndResolvedStringsVisitor(gc::space::ImageSpace* space, 1464 mirror::ClassLoader* class_loader, 1465 bool forward_strings) 1466 : space_(space), 1467 class_loader_(class_loader), 1468 forward_strings_(forward_strings) {} 1469 1470 bool operator()(mirror::Class* klass) const SHARED_REQUIRES(Locks::mutator_lock_) { 1471 if (forward_strings_) { 1472 GcRoot<mirror::String>* strings = klass->GetDexCacheStrings(); 1473 if (strings != nullptr) { 1474 DCHECK( 1475 space_->GetImageHeader().GetImageSection(ImageHeader::kSectionDexCacheArrays).Contains( 1476 reinterpret_cast<uint8_t*>(strings) - space_->Begin())) 1477 << "String dex cache array for " << PrettyClass(klass) << " is not in app image"; 1478 // Dex caches have already been updated, so take the strings pointer from there. 1479 GcRoot<mirror::String>* new_strings = klass->GetDexCache()->GetStrings(); 1480 DCHECK_NE(strings, new_strings); 1481 klass->SetDexCacheStrings(new_strings); 1482 } 1483 } 1484 // Finally, update class loader. 1485 klass->SetClassLoader(class_loader_); 1486 return true; 1487 } 1488 1489 gc::space::ImageSpace* const space_; 1490 mirror::ClassLoader* const class_loader_; 1491 const bool forward_strings_; 1492}; 1493 1494static std::unique_ptr<const DexFile> OpenOatDexFile(const OatFile* oat_file, 1495 const char* location, 1496 std::string* error_msg) 1497 SHARED_REQUIRES(Locks::mutator_lock_) { 1498 DCHECK(error_msg != nullptr); 1499 std::unique_ptr<const DexFile> dex_file; 1500 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(location, nullptr); 1501 if (oat_dex_file == nullptr) { 1502 *error_msg = StringPrintf("Failed finding oat dex file for %s %s", 1503 oat_file->GetLocation().c_str(), 1504 location); 1505 return std::unique_ptr<const DexFile>(); 1506 } 1507 std::string inner_error_msg; 1508 dex_file = oat_dex_file->OpenDexFile(&inner_error_msg); 1509 if (dex_file == nullptr) { 1510 *error_msg = StringPrintf("Failed to open dex file %s from within oat file %s error '%s'", 1511 location, 1512 oat_file->GetLocation().c_str(), 1513 inner_error_msg.c_str()); 1514 return std::unique_ptr<const DexFile>(); 1515 } 1516 1517 if (dex_file->GetLocationChecksum() != oat_dex_file->GetDexFileLocationChecksum()) { 1518 *error_msg = StringPrintf("Checksums do not match for %s: %x vs %x", 1519 location, 1520 dex_file->GetLocationChecksum(), 1521 oat_dex_file->GetDexFileLocationChecksum()); 1522 return std::unique_ptr<const DexFile>(); 1523 } 1524 return dex_file; 1525} 1526 1527bool ClassLinker::OpenImageDexFiles(gc::space::ImageSpace* space, 1528 std::vector<std::unique_ptr<const DexFile>>* out_dex_files, 1529 std::string* error_msg) { 1530 ScopedAssertNoThreadSuspension nts(Thread::Current(), __FUNCTION__); 1531 const ImageHeader& header = space->GetImageHeader(); 1532 mirror::Object* dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches); 1533 DCHECK(dex_caches_object != nullptr); 1534 mirror::ObjectArray<mirror::DexCache>* dex_caches = 1535 dex_caches_object->AsObjectArray<mirror::DexCache>(); 1536 const OatFile* oat_file = space->GetOatFile(); 1537 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 1538 mirror::DexCache* dex_cache = dex_caches->Get(i); 1539 std::string dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8()); 1540 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file, 1541 dex_file_location.c_str(), 1542 error_msg); 1543 if (dex_file == nullptr) { 1544 return false; 1545 } 1546 dex_cache->SetDexFile(dex_file.get()); 1547 out_dex_files->push_back(std::move(dex_file)); 1548 } 1549 return true; 1550} 1551 1552bool ClassLinker::AddImageSpace( 1553 gc::space::ImageSpace* space, 1554 Handle<mirror::ClassLoader> class_loader, 1555 jobjectArray dex_elements, 1556 const char* dex_location, 1557 std::vector<std::unique_ptr<const DexFile>>* out_dex_files, 1558 std::string* error_msg) { 1559 DCHECK(out_dex_files != nullptr); 1560 DCHECK(error_msg != nullptr); 1561 const uint64_t start_time = NanoTime(); 1562 const bool app_image = class_loader.Get() != nullptr; 1563 const ImageHeader& header = space->GetImageHeader(); 1564 mirror::Object* dex_caches_object = header.GetImageRoot(ImageHeader::kDexCaches); 1565 DCHECK(dex_caches_object != nullptr); 1566 Runtime* const runtime = Runtime::Current(); 1567 gc::Heap* const heap = runtime->GetHeap(); 1568 Thread* const self = Thread::Current(); 1569 StackHandleScope<2> hs(self); 1570 Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches( 1571 hs.NewHandle(dex_caches_object->AsObjectArray<mirror::DexCache>())); 1572 Handle<mirror::ObjectArray<mirror::Class>> class_roots(hs.NewHandle( 1573 header.GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>())); 1574 const OatFile* oat_file = space->GetOatFile(); 1575 std::unordered_set<mirror::ClassLoader*> image_class_loaders; 1576 // Check that the image is what we are expecting. 1577 if (image_pointer_size_ != space->GetImageHeader().GetPointerSize()) { 1578 *error_msg = StringPrintf("Application image pointer size does not match runtime: %zu vs %zu", 1579 static_cast<size_t>(space->GetImageHeader().GetPointerSize()), 1580 image_pointer_size_); 1581 return false; 1582 } 1583 DCHECK(class_roots.Get() != nullptr); 1584 if (class_roots->GetLength() != static_cast<int32_t>(kClassRootsMax)) { 1585 *error_msg = StringPrintf("Expected %d class roots but got %d", 1586 class_roots->GetLength(), 1587 static_cast<int32_t>(kClassRootsMax)); 1588 return false; 1589 } 1590 // Check against existing class roots to make sure they match the ones in the boot image. 1591 for (size_t i = 0; i < kClassRootsMax; i++) { 1592 if (class_roots->Get(i) != GetClassRoot(static_cast<ClassRoot>(i))) { 1593 *error_msg = "App image class roots must have pointer equality with runtime ones."; 1594 return false; 1595 } 1596 } 1597 if (oat_file->GetOatHeader().GetDexFileCount() != 1598 static_cast<uint32_t>(dex_caches->GetLength())) { 1599 *error_msg = "Dex cache count and dex file count mismatch while trying to initialize from " 1600 "image"; 1601 return false; 1602 } 1603 1604 StackHandleScope<1> hs2(self); 1605 MutableHandle<mirror::DexCache> h_dex_cache(hs2.NewHandle<mirror::DexCache>(nullptr)); 1606 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 1607 h_dex_cache.Assign(dex_caches->Get(i)); 1608 std::string dex_file_location(h_dex_cache->GetLocation()->ToModifiedUtf8()); 1609 // TODO: Only store qualified paths. 1610 // If non qualified, qualify it. 1611 if (dex_file_location.find('/') == std::string::npos) { 1612 std::string dex_location_path = dex_location; 1613 const size_t pos = dex_location_path.find_last_of('/'); 1614 CHECK_NE(pos, std::string::npos); 1615 dex_location_path = dex_location_path.substr(0, pos + 1); // Keep trailing '/' 1616 dex_file_location = dex_location_path + dex_file_location; 1617 } 1618 std::unique_ptr<const DexFile> dex_file = OpenOatDexFile(oat_file, 1619 dex_file_location.c_str(), 1620 error_msg); 1621 if (dex_file == nullptr) { 1622 return false; 1623 } 1624 1625 if (app_image) { 1626 // The current dex file field is bogus, overwrite it so that we can get the dex file in the 1627 // loop below. 1628 h_dex_cache->SetDexFile(dex_file.get()); 1629 // Check that each class loader resolved the same way. 1630 // TODO: Store image class loaders as image roots. 1631 GcRoot<mirror::Class>* const types = h_dex_cache->GetResolvedTypes(); 1632 for (int32_t j = 0, num_types = h_dex_cache->NumResolvedTypes(); j < num_types; j++) { 1633 mirror::Class* klass = types[j].Read(); 1634 if (klass != nullptr) { 1635 DCHECK_NE(klass->GetStatus(), mirror::Class::kStatusError); 1636 mirror::ClassLoader* image_class_loader = klass->GetClassLoader(); 1637 image_class_loaders.insert(image_class_loader); 1638 } 1639 } 1640 } else { 1641 if (kSanityCheckObjects) { 1642 SanityCheckArtMethodPointerArray(h_dex_cache->GetResolvedMethods(), 1643 h_dex_cache->NumResolvedMethods(), 1644 image_pointer_size_, 1645 heap->GetBootImageSpaces()); 1646 } 1647 // Register dex files, keep track of existing ones that are conflicts. 1648 AppendToBootClassPath(*dex_file.get(), h_dex_cache); 1649 } 1650 out_dex_files->push_back(std::move(dex_file)); 1651 } 1652 1653 if (app_image) { 1654 ScopedObjectAccessUnchecked soa(Thread::Current()); 1655 // Check that the class loader resolves the same way as the ones in the image. 1656 // Image class loader [A][B][C][image dex files] 1657 // Class loader = [???][dex_elements][image dex files] 1658 // Need to ensure that [???][dex_elements] == [A][B][C]. 1659 // For each class loader, PathClassLoader, the laoder checks the parent first. Also the logic 1660 // for PathClassLoader does this by looping through the array of dex files. To ensure they 1661 // resolve the same way, simply flatten the hierarchy in the way the resolution order would be, 1662 // and check that the dex file names are the same. 1663 for (mirror::ClassLoader* image_class_loader : image_class_loaders) { 1664 std::list<mirror::String*> image_dex_file_names; 1665 std::string temp_error_msg; 1666 if (!FlattenPathClassLoader(image_class_loader, &image_dex_file_names, &temp_error_msg)) { 1667 *error_msg = StringPrintf("Failed to flatten image class loader hierarchy '%s'", 1668 temp_error_msg.c_str()); 1669 return false; 1670 } 1671 std::list<mirror::String*> loader_dex_file_names; 1672 if (!FlattenPathClassLoader(class_loader.Get(), &loader_dex_file_names, &temp_error_msg)) { 1673 *error_msg = StringPrintf("Failed to flatten class loader hierarchy '%s'", 1674 temp_error_msg.c_str()); 1675 return false; 1676 } 1677 // Add the temporary dex path list elements at the end. 1678 auto* elements = soa.Decode<mirror::ObjectArray<mirror::Object>*>(dex_elements); 1679 for (size_t i = 0, num_elems = elements->GetLength(); i < num_elems; ++i) { 1680 mirror::Object* element = elements->GetWithoutChecks(i); 1681 if (element != nullptr) { 1682 // If we are somewhere in the middle of the array, there may be nulls at the end. 1683 loader_dex_file_names.push_back(GetDexPathListElementName(soa, element)); 1684 } 1685 } 1686 // Ignore the number of image dex files since we are adding those to the class loader anyways. 1687 CHECK_GE(static_cast<size_t>(image_dex_file_names.size()), 1688 static_cast<size_t>(dex_caches->GetLength())); 1689 size_t image_count = image_dex_file_names.size() - dex_caches->GetLength(); 1690 // Check that the dex file names match. 1691 bool equal = image_count == loader_dex_file_names.size(); 1692 if (equal) { 1693 auto it1 = image_dex_file_names.begin(); 1694 auto it2 = loader_dex_file_names.begin(); 1695 for (size_t i = 0; equal && i < image_count; ++i, ++it1, ++it2) { 1696 equal = equal && (*it1)->Equals(*it2); 1697 } 1698 } 1699 if (!equal) { 1700 VLOG(image) << "Image dex files " << image_dex_file_names.size(); 1701 for (mirror::String* name : image_dex_file_names) { 1702 VLOG(image) << name->ToModifiedUtf8(); 1703 } 1704 VLOG(image) << "Loader dex files " << loader_dex_file_names.size(); 1705 for (mirror::String* name : loader_dex_file_names) { 1706 VLOG(image) << name->ToModifiedUtf8(); 1707 } 1708 *error_msg = "Rejecting application image due to class loader mismatch"; 1709 // Ignore class loader mismatch for now since these would just use possibly incorrect 1710 // oat code anyways. The structural class check should be done in the parent. 1711 } 1712 } 1713 } 1714 1715 if (kSanityCheckObjects) { 1716 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 1717 auto* dex_cache = dex_caches->Get(i); 1718 for (size_t j = 0; j < dex_cache->NumResolvedFields(); ++j) { 1719 auto* field = dex_cache->GetResolvedField(j, image_pointer_size_); 1720 if (field != nullptr) { 1721 CHECK(field->GetDeclaringClass()->GetClass() != nullptr); 1722 } 1723 } 1724 } 1725 if (!app_image) { 1726 heap->VisitObjects(SanityCheckObjectsCallback, nullptr); 1727 } 1728 } 1729 1730 // Set entry point to interpreter if in InterpretOnly mode. 1731 if (!runtime->IsAotCompiler() && runtime->GetInstrumentation()->InterpretOnly()) { 1732 SetInterpreterEntrypointArtMethodVisitor visitor(image_pointer_size_); 1733 header.VisitPackedArtMethods(&visitor, space->Begin(), image_pointer_size_); 1734 } 1735 1736 ClassTable* class_table = nullptr; 1737 { 1738 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 1739 class_table = InsertClassTableForClassLoader(class_loader.Get()); 1740 } 1741 // If we have a class table section, read it and use it for verification in 1742 // UpdateAppImageClassLoadersAndDexCaches. 1743 ClassTable::ClassSet temp_set; 1744 const ImageSection& class_table_section = header.GetImageSection(ImageHeader::kSectionClassTable); 1745 const bool added_class_table = class_table_section.Size() > 0u; 1746 if (added_class_table) { 1747 const uint64_t start_time2 = NanoTime(); 1748 size_t read_count = 0; 1749 temp_set = ClassTable::ClassSet(space->Begin() + class_table_section.Offset(), 1750 /*make copy*/false, 1751 &read_count); 1752 if (!app_image) { 1753 dex_cache_boot_image_class_lookup_required_ = false; 1754 } 1755 VLOG(image) << "Adding class table classes took " << PrettyDuration(NanoTime() - start_time2); 1756 } 1757 if (app_image) { 1758 bool forward_dex_cache_arrays = false; 1759 if (!UpdateAppImageClassLoadersAndDexCaches(space, 1760 class_loader, 1761 dex_caches, 1762 added_class_table ? &temp_set : nullptr, 1763 /*out*/&forward_dex_cache_arrays, 1764 /*out*/error_msg)) { 1765 return false; 1766 } 1767 // Update class loader and resolved strings. If added_class_table is false, the resolved 1768 // strings were forwarded UpdateAppImageClassLoadersAndDexCaches. 1769 UpdateClassLoaderAndResolvedStringsVisitor visitor(space, 1770 class_loader.Get(), 1771 forward_dex_cache_arrays); 1772 if (added_class_table) { 1773 for (GcRoot<mirror::Class>& root : temp_set) { 1774 visitor(root.Read()); 1775 } 1776 } 1777 // forward_dex_cache_arrays is true iff we copied all of the dex cache arrays into the .bss. 1778 // In this case, madvise away the dex cache arrays section of the image to reduce RAM usage and 1779 // mark as PROT_NONE to catch any invalid accesses. 1780 if (forward_dex_cache_arrays) { 1781 const ImageSection& dex_cache_section = header.GetImageSection( 1782 ImageHeader::kSectionDexCacheArrays); 1783 uint8_t* section_begin = AlignUp(space->Begin() + dex_cache_section.Offset(), kPageSize); 1784 uint8_t* section_end = AlignDown(space->Begin() + dex_cache_section.End(), kPageSize); 1785 if (section_begin < section_end) { 1786 madvise(section_begin, section_end - section_begin, MADV_DONTNEED); 1787 mprotect(section_begin, section_end - section_begin, PROT_NONE); 1788 VLOG(image) << "Released and protected dex cache array image section from " 1789 << reinterpret_cast<const void*>(section_begin) << "-" 1790 << reinterpret_cast<const void*>(section_end); 1791 } 1792 } 1793 } 1794 if (added_class_table) { 1795 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 1796 class_table->AddClassSet(std::move(temp_set)); 1797 } 1798 if (kIsDebugBuild && app_image) { 1799 // This verification needs to happen after the classes have been added to the class loader. 1800 // Since it ensures classes are in the class table. 1801 VerifyClassInTableArtMethodVisitor visitor2(class_table); 1802 header.VisitPackedArtMethods(&visitor2, space->Begin(), sizeof(void*)); 1803 } 1804 VLOG(class_linker) << "Adding image space took " << PrettyDuration(NanoTime() - start_time); 1805 return true; 1806} 1807 1808bool ClassLinker::ClassInClassTable(mirror::Class* klass) { 1809 ClassTable* const class_table = ClassTableForClassLoader(klass->GetClassLoader()); 1810 return class_table != nullptr && class_table->Contains(klass); 1811} 1812 1813void ClassLinker::VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) { 1814 // Acquire tracing_enabled before locking class linker lock to prevent lock order violation. Since 1815 // enabling tracing requires the mutator lock, there are no race conditions here. 1816 const bool tracing_enabled = Trace::IsTracingEnabled(); 1817 Thread* const self = Thread::Current(); 1818 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 1819 BufferedRootVisitor<kDefaultBufferedRootCount> buffered_visitor( 1820 visitor, RootInfo(kRootStickyClass)); 1821 if ((flags & kVisitRootFlagAllRoots) != 0) { 1822 // Argument for how root visiting deals with ArtField and ArtMethod roots. 1823 // There is 3 GC cases to handle: 1824 // Non moving concurrent: 1825 // This case is easy to handle since the reference members of ArtMethod and ArtFields are held 1826 // live by the class and class roots. 1827 // 1828 // Moving non-concurrent: 1829 // This case needs to call visit VisitNativeRoots in case the classes or dex cache arrays move. 1830 // To prevent missing roots, this case needs to ensure that there is no 1831 // suspend points between the point which we allocate ArtMethod arrays and place them in a 1832 // class which is in the class table. 1833 // 1834 // Moving concurrent: 1835 // Need to make sure to not copy ArtMethods without doing read barriers since the roots are 1836 // marked concurrently and we don't hold the classlinker_classes_lock_ when we do the copy. 1837 boot_class_table_.VisitRoots(buffered_visitor); 1838 1839 // If tracing is enabled, then mark all the class loaders to prevent unloading. 1840 if (tracing_enabled) { 1841 for (const ClassLoaderData& data : class_loaders_) { 1842 GcRoot<mirror::Object> root(GcRoot<mirror::Object>(self->DecodeJObject(data.weak_root))); 1843 root.VisitRoot(visitor, RootInfo(kRootVMInternal)); 1844 } 1845 } 1846 } else if ((flags & kVisitRootFlagNewRoots) != 0) { 1847 for (auto& root : new_class_roots_) { 1848 mirror::Class* old_ref = root.Read<kWithoutReadBarrier>(); 1849 root.VisitRoot(visitor, RootInfo(kRootStickyClass)); 1850 mirror::Class* new_ref = root.Read<kWithoutReadBarrier>(); 1851 // Concurrent moving GC marked new roots through the to-space invariant. 1852 CHECK_EQ(new_ref, old_ref); 1853 } 1854 } 1855 buffered_visitor.Flush(); // Flush before clearing new_class_roots_. 1856 if ((flags & kVisitRootFlagClearRootLog) != 0) { 1857 new_class_roots_.clear(); 1858 } 1859 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) { 1860 log_new_class_table_roots_ = true; 1861 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) { 1862 log_new_class_table_roots_ = false; 1863 } 1864 // We deliberately ignore the class roots in the image since we 1865 // handle image roots by using the MS/CMS rescanning of dirty cards. 1866} 1867 1868// Keep in sync with InitCallback. Anything we visit, we need to 1869// reinit references to when reinitializing a ClassLinker from a 1870// mapped image. 1871void ClassLinker::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) { 1872 class_roots_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal)); 1873 VisitClassRoots(visitor, flags); 1874 array_iftable_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal)); 1875 // Instead of visiting the find_array_class_cache_ drop it so that it doesn't prevent class 1876 // unloading if we are marking roots. 1877 DropFindArrayClassCache(); 1878} 1879 1880class VisitClassLoaderClassesVisitor : public ClassLoaderVisitor { 1881 public: 1882 explicit VisitClassLoaderClassesVisitor(ClassVisitor* visitor) 1883 : visitor_(visitor), 1884 done_(false) {} 1885 1886 void Visit(mirror::ClassLoader* class_loader) 1887 SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE { 1888 ClassTable* const class_table = class_loader->GetClassTable(); 1889 if (!done_ && class_table != nullptr && !class_table->Visit(*visitor_)) { 1890 // If the visitor ClassTable returns false it means that we don't need to continue. 1891 done_ = true; 1892 } 1893 } 1894 1895 private: 1896 ClassVisitor* const visitor_; 1897 // If done is true then we don't need to do any more visiting. 1898 bool done_; 1899}; 1900 1901void ClassLinker::VisitClassesInternal(ClassVisitor* visitor) { 1902 if (boot_class_table_.Visit(*visitor)) { 1903 VisitClassLoaderClassesVisitor loader_visitor(visitor); 1904 VisitClassLoaders(&loader_visitor); 1905 } 1906} 1907 1908void ClassLinker::VisitClasses(ClassVisitor* visitor) { 1909 if (dex_cache_boot_image_class_lookup_required_) { 1910 AddBootImageClassesToClassTable(); 1911 } 1912 Thread* const self = Thread::Current(); 1913 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 1914 // Not safe to have thread suspension when we are holding a lock. 1915 if (self != nullptr) { 1916 ScopedAssertNoThreadSuspension nts(self, __FUNCTION__); 1917 VisitClassesInternal(visitor); 1918 } else { 1919 VisitClassesInternal(visitor); 1920 } 1921} 1922 1923class GetClassesInToVector : public ClassVisitor { 1924 public: 1925 bool operator()(mirror::Class* klass) OVERRIDE { 1926 classes_.push_back(klass); 1927 return true; 1928 } 1929 std::vector<mirror::Class*> classes_; 1930}; 1931 1932class GetClassInToObjectArray : public ClassVisitor { 1933 public: 1934 explicit GetClassInToObjectArray(mirror::ObjectArray<mirror::Class>* arr) 1935 : arr_(arr), index_(0) {} 1936 1937 bool operator()(mirror::Class* klass) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) { 1938 ++index_; 1939 if (index_ <= arr_->GetLength()) { 1940 arr_->Set(index_ - 1, klass); 1941 return true; 1942 } 1943 return false; 1944 } 1945 1946 bool Succeeded() const SHARED_REQUIRES(Locks::mutator_lock_) { 1947 return index_ <= arr_->GetLength(); 1948 } 1949 1950 private: 1951 mirror::ObjectArray<mirror::Class>* const arr_; 1952 int32_t index_; 1953}; 1954 1955void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor) { 1956 // TODO: it may be possible to avoid secondary storage if we iterate over dex caches. The problem 1957 // is avoiding duplicates. 1958 Thread* const self = Thread::Current(); 1959 if (!kMovingClasses) { 1960 ScopedAssertNoThreadSuspension nts(self, __FUNCTION__); 1961 GetClassesInToVector accumulator; 1962 VisitClasses(&accumulator); 1963 for (mirror::Class* klass : accumulator.classes_) { 1964 if (!visitor->operator()(klass)) { 1965 return; 1966 } 1967 } 1968 } else { 1969 StackHandleScope<1> hs(self); 1970 auto classes = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr); 1971 // We size the array assuming classes won't be added to the class table during the visit. 1972 // If this assumption fails we iterate again. 1973 while (true) { 1974 size_t class_table_size; 1975 { 1976 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 1977 // Add 100 in case new classes get loaded when we are filling in the object array. 1978 class_table_size = NumZygoteClasses() + NumNonZygoteClasses() + 100; 1979 } 1980 mirror::Class* class_type = mirror::Class::GetJavaLangClass(); 1981 mirror::Class* array_of_class = FindArrayClass(self, &class_type); 1982 classes.Assign( 1983 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size)); 1984 CHECK(classes.Get() != nullptr); // OOME. 1985 GetClassInToObjectArray accumulator(classes.Get()); 1986 VisitClasses(&accumulator); 1987 if (accumulator.Succeeded()) { 1988 break; 1989 } 1990 } 1991 for (int32_t i = 0; i < classes->GetLength(); ++i) { 1992 // If the class table shrank during creation of the clases array we expect null elements. If 1993 // the class table grew then the loop repeats. If classes are created after the loop has 1994 // finished then we don't visit. 1995 mirror::Class* klass = classes->Get(i); 1996 if (klass != nullptr && !visitor->operator()(klass)) { 1997 return; 1998 } 1999 } 2000 } 2001} 2002 2003ClassLinker::~ClassLinker() { 2004 mirror::Class::ResetClass(); 2005 mirror::Constructor::ResetClass(); 2006 mirror::Field::ResetClass(); 2007 mirror::Method::ResetClass(); 2008 mirror::Reference::ResetClass(); 2009 mirror::StackTraceElement::ResetClass(); 2010 mirror::String::ResetClass(); 2011 mirror::Throwable::ResetClass(); 2012 mirror::BooleanArray::ResetArrayClass(); 2013 mirror::ByteArray::ResetArrayClass(); 2014 mirror::CharArray::ResetArrayClass(); 2015 mirror::Constructor::ResetArrayClass(); 2016 mirror::DoubleArray::ResetArrayClass(); 2017 mirror::Field::ResetArrayClass(); 2018 mirror::FloatArray::ResetArrayClass(); 2019 mirror::Method::ResetArrayClass(); 2020 mirror::IntArray::ResetArrayClass(); 2021 mirror::LongArray::ResetArrayClass(); 2022 mirror::ShortArray::ResetArrayClass(); 2023 Thread* const self = Thread::Current(); 2024 for (const ClassLoaderData& data : class_loaders_) { 2025 DeleteClassLoader(self, data); 2026 } 2027 class_loaders_.clear(); 2028} 2029 2030void ClassLinker::DeleteClassLoader(Thread* self, const ClassLoaderData& data) { 2031 Runtime* const runtime = Runtime::Current(); 2032 JavaVMExt* const vm = runtime->GetJavaVM(); 2033 vm->DeleteWeakGlobalRef(self, data.weak_root); 2034 // Notify the JIT that we need to remove the methods and/or profiling info. 2035 if (runtime->GetJit() != nullptr) { 2036 jit::JitCodeCache* code_cache = runtime->GetJit()->GetCodeCache(); 2037 if (code_cache != nullptr) { 2038 code_cache->RemoveMethodsIn(self, *data.allocator); 2039 } 2040 } 2041 delete data.allocator; 2042 delete data.class_table; 2043} 2044 2045mirror::PointerArray* ClassLinker::AllocPointerArray(Thread* self, size_t length) { 2046 return down_cast<mirror::PointerArray*>(image_pointer_size_ == 8u ? 2047 static_cast<mirror::Array*>(mirror::LongArray::Alloc(self, length)) : 2048 static_cast<mirror::Array*>(mirror::IntArray::Alloc(self, length))); 2049} 2050 2051mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, 2052 const DexFile& dex_file, 2053 LinearAlloc* linear_alloc) { 2054 StackHandleScope<6> hs(self); 2055 auto dex_cache(hs.NewHandle(down_cast<mirror::DexCache*>( 2056 GetClassRoot(kJavaLangDexCache)->AllocObject(self)))); 2057 if (dex_cache.Get() == nullptr) { 2058 self->AssertPendingOOMException(); 2059 return nullptr; 2060 } 2061 auto location(hs.NewHandle(intern_table_->InternStrong(dex_file.GetLocation().c_str()))); 2062 if (location.Get() == nullptr) { 2063 self->AssertPendingOOMException(); 2064 return nullptr; 2065 } 2066 DexCacheArraysLayout layout(image_pointer_size_, &dex_file); 2067 uint8_t* raw_arrays = nullptr; 2068 if (dex_file.GetOatDexFile() != nullptr && 2069 dex_file.GetOatDexFile()->GetDexCacheArrays() != nullptr) { 2070 raw_arrays = dex_file.GetOatDexFile()->GetDexCacheArrays(); 2071 } else if (dex_file.NumStringIds() != 0u || dex_file.NumTypeIds() != 0u || 2072 dex_file.NumMethodIds() != 0u || dex_file.NumFieldIds() != 0u) { 2073 // NOTE: We "leak" the raw_arrays because we never destroy the dex cache. 2074 DCHECK(image_pointer_size_ == 4u || image_pointer_size_ == 8u); 2075 // Zero-initialized. 2076 raw_arrays = reinterpret_cast<uint8_t*>(linear_alloc->Alloc(self, layout.Size())); 2077 } 2078 GcRoot<mirror::String>* strings = (dex_file.NumStringIds() == 0u) ? nullptr : 2079 reinterpret_cast<GcRoot<mirror::String>*>(raw_arrays + layout.StringsOffset()); 2080 GcRoot<mirror::Class>* types = (dex_file.NumTypeIds() == 0u) ? nullptr : 2081 reinterpret_cast<GcRoot<mirror::Class>*>(raw_arrays + layout.TypesOffset()); 2082 ArtMethod** methods = (dex_file.NumMethodIds() == 0u) ? nullptr : 2083 reinterpret_cast<ArtMethod**>(raw_arrays + layout.MethodsOffset()); 2084 ArtField** fields = (dex_file.NumFieldIds() == 0u) ? nullptr : 2085 reinterpret_cast<ArtField**>(raw_arrays + layout.FieldsOffset()); 2086 dex_cache->Init(&dex_file, 2087 location.Get(), 2088 strings, 2089 dex_file.NumStringIds(), 2090 types, 2091 dex_file.NumTypeIds(), 2092 methods, 2093 dex_file.NumMethodIds(), 2094 fields, 2095 dex_file.NumFieldIds(), 2096 image_pointer_size_); 2097 return dex_cache.Get(); 2098} 2099 2100mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class, 2101 uint32_t class_size) { 2102 DCHECK_GE(class_size, sizeof(mirror::Class)); 2103 gc::Heap* heap = Runtime::Current()->GetHeap(); 2104 mirror::Class::InitializeClassVisitor visitor(class_size); 2105 mirror::Object* k = kMovingClasses ? 2106 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) : 2107 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor); 2108 if (UNLIKELY(k == nullptr)) { 2109 self->AssertPendingOOMException(); 2110 return nullptr; 2111 } 2112 return k->AsClass(); 2113} 2114 2115mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) { 2116 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size); 2117} 2118 2119mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray( 2120 Thread* self, 2121 size_t length) { 2122 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc( 2123 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length); 2124} 2125 2126mirror::Class* ClassLinker::EnsureResolved(Thread* self, 2127 const char* descriptor, 2128 mirror::Class* klass) { 2129 DCHECK(klass != nullptr); 2130 2131 // For temporary classes we must wait for them to be retired. 2132 if (init_done_ && klass->IsTemp()) { 2133 CHECK(!klass->IsResolved()); 2134 if (klass->IsErroneous()) { 2135 ThrowEarlierClassFailure(klass); 2136 return nullptr; 2137 } 2138 StackHandleScope<1> hs(self); 2139 Handle<mirror::Class> h_class(hs.NewHandle(klass)); 2140 ObjectLock<mirror::Class> lock(self, h_class); 2141 // Loop and wait for the resolving thread to retire this class. 2142 while (!h_class->IsRetired() && !h_class->IsErroneous()) { 2143 lock.WaitIgnoringInterrupts(); 2144 } 2145 if (h_class->IsErroneous()) { 2146 ThrowEarlierClassFailure(h_class.Get()); 2147 return nullptr; 2148 } 2149 CHECK(h_class->IsRetired()); 2150 // Get the updated class from class table. 2151 klass = LookupClass(self, descriptor, ComputeModifiedUtf8Hash(descriptor), 2152 h_class.Get()->GetClassLoader()); 2153 } 2154 2155 // Wait for the class if it has not already been linked. 2156 if (!klass->IsResolved() && !klass->IsErroneous()) { 2157 StackHandleScope<1> hs(self); 2158 HandleWrapper<mirror::Class> h_class(hs.NewHandleWrapper(&klass)); 2159 ObjectLock<mirror::Class> lock(self, h_class); 2160 // Check for circular dependencies between classes. 2161 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) { 2162 ThrowClassCircularityError(h_class.Get()); 2163 mirror::Class::SetStatus(h_class, mirror::Class::kStatusError, self); 2164 return nullptr; 2165 } 2166 // Wait for the pending initialization to complete. 2167 while (!h_class->IsResolved() && !h_class->IsErroneous()) { 2168 lock.WaitIgnoringInterrupts(); 2169 } 2170 } 2171 2172 if (klass->IsErroneous()) { 2173 ThrowEarlierClassFailure(klass); 2174 return nullptr; 2175 } 2176 // Return the loaded class. No exceptions should be pending. 2177 CHECK(klass->IsResolved()) << PrettyClass(klass); 2178 self->AssertNoPendingException(); 2179 return klass; 2180} 2181 2182typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry; 2183 2184// Search a collection of DexFiles for a descriptor 2185ClassPathEntry FindInClassPath(const char* descriptor, 2186 size_t hash, const std::vector<const DexFile*>& class_path) { 2187 for (const DexFile* dex_file : class_path) { 2188 const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor, hash); 2189 if (dex_class_def != nullptr) { 2190 return ClassPathEntry(dex_file, dex_class_def); 2191 } 2192 } 2193 return ClassPathEntry(nullptr, nullptr); 2194} 2195 2196bool ClassLinker::FindClassInPathClassLoader(ScopedObjectAccessAlreadyRunnable& soa, 2197 Thread* self, 2198 const char* descriptor, 2199 size_t hash, 2200 Handle<mirror::ClassLoader> class_loader, 2201 mirror::Class** result) { 2202 // Termination case: boot class-loader. 2203 if (IsBootClassLoader(soa, class_loader.Get())) { 2204 // The boot class loader, search the boot class path. 2205 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_); 2206 if (pair.second != nullptr) { 2207 mirror::Class* klass = LookupClass(self, descriptor, hash, nullptr); 2208 if (klass != nullptr) { 2209 *result = EnsureResolved(self, descriptor, klass); 2210 } else { 2211 *result = DefineClass(self, 2212 descriptor, 2213 hash, 2214 ScopedNullHandle<mirror::ClassLoader>(), 2215 *pair.first, 2216 *pair.second); 2217 } 2218 if (*result == nullptr) { 2219 CHECK(self->IsExceptionPending()) << descriptor; 2220 self->ClearException(); 2221 } 2222 } else { 2223 *result = nullptr; 2224 } 2225 return true; 2226 } 2227 2228 // Unsupported class-loader? 2229 if (class_loader->GetClass() != 2230 soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader)) { 2231 *result = nullptr; 2232 return false; 2233 } 2234 2235 // Handles as RegisterDexFile may allocate dex caches (and cause thread suspension). 2236 StackHandleScope<4> hs(self); 2237 Handle<mirror::ClassLoader> h_parent(hs.NewHandle(class_loader->GetParent())); 2238 bool recursive_result = FindClassInPathClassLoader(soa, self, descriptor, hash, h_parent, result); 2239 2240 if (!recursive_result) { 2241 // Something wrong up the chain. 2242 return false; 2243 } 2244 2245 if (*result != nullptr) { 2246 // Found the class up the chain. 2247 return true; 2248 } 2249 2250 // Handle this step. 2251 // Handle as if this is the child PathClassLoader. 2252 // The class loader is a PathClassLoader which inherits from BaseDexClassLoader. 2253 // We need to get the DexPathList and loop through it. 2254 ArtField* const cookie_field = soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_cookie); 2255 ArtField* const dex_file_field = 2256 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile); 2257 mirror::Object* dex_path_list = 2258 soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList)-> 2259 GetObject(class_loader.Get()); 2260 if (dex_path_list != nullptr && dex_file_field != nullptr && cookie_field != nullptr) { 2261 // DexPathList has an array dexElements of Elements[] which each contain a dex file. 2262 mirror::Object* dex_elements_obj = 2263 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements)-> 2264 GetObject(dex_path_list); 2265 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look 2266 // at the mCookie which is a DexFile vector. 2267 if (dex_elements_obj != nullptr) { 2268 Handle<mirror::ObjectArray<mirror::Object>> dex_elements = 2269 hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>()); 2270 for (int32_t i = 0; i < dex_elements->GetLength(); ++i) { 2271 mirror::Object* element = dex_elements->GetWithoutChecks(i); 2272 if (element == nullptr) { 2273 // Should never happen, fall back to java code to throw a NPE. 2274 break; 2275 } 2276 mirror::Object* dex_file = dex_file_field->GetObject(element); 2277 if (dex_file != nullptr) { 2278 mirror::LongArray* long_array = cookie_field->GetObject(dex_file)->AsLongArray(); 2279 if (long_array == nullptr) { 2280 // This should never happen so log a warning. 2281 LOG(WARNING) << "Null DexFile::mCookie for " << descriptor; 2282 break; 2283 } 2284 int32_t long_array_size = long_array->GetLength(); 2285 // First element is the oat file. 2286 for (int32_t j = kDexFileIndexStart; j < long_array_size; ++j) { 2287 const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>( 2288 long_array->GetWithoutChecks(j))); 2289 const DexFile::ClassDef* dex_class_def = cp_dex_file->FindClassDef(descriptor, hash); 2290 if (dex_class_def != nullptr) { 2291 mirror::Class* klass = DefineClass(self, 2292 descriptor, 2293 hash, 2294 class_loader, 2295 *cp_dex_file, 2296 *dex_class_def); 2297 if (klass == nullptr) { 2298 CHECK(self->IsExceptionPending()) << descriptor; 2299 self->ClearException(); 2300 // TODO: Is it really right to break here, and not check the other dex files? 2301 return true; 2302 } 2303 *result = klass; 2304 return true; 2305 } 2306 } 2307 } 2308 } 2309 } 2310 self->AssertNoPendingException(); 2311 } 2312 2313 // Result is still null from the parent call, no need to set it again... 2314 return true; 2315} 2316 2317mirror::Class* ClassLinker::FindClass(Thread* self, 2318 const char* descriptor, 2319 Handle<mirror::ClassLoader> class_loader) { 2320 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string"; 2321 DCHECK(self != nullptr); 2322 self->AssertNoPendingException(); 2323 if (descriptor[1] == '\0') { 2324 // only the descriptors of primitive types should be 1 character long, also avoid class lookup 2325 // for primitive classes that aren't backed by dex files. 2326 return FindPrimitiveClass(descriptor[0]); 2327 } 2328 const size_t hash = ComputeModifiedUtf8Hash(descriptor); 2329 // Find the class in the loaded classes table. 2330 mirror::Class* klass = LookupClass(self, descriptor, hash, class_loader.Get()); 2331 if (klass != nullptr) { 2332 return EnsureResolved(self, descriptor, klass); 2333 } 2334 // Class is not yet loaded. 2335 if (descriptor[0] == '[') { 2336 return CreateArrayClass(self, descriptor, hash, class_loader); 2337 } else if (class_loader.Get() == nullptr) { 2338 // The boot class loader, search the boot class path. 2339 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_); 2340 if (pair.second != nullptr) { 2341 return DefineClass(self, 2342 descriptor, 2343 hash, 2344 ScopedNullHandle<mirror::ClassLoader>(), 2345 *pair.first, 2346 *pair.second); 2347 } else { 2348 // The boot class loader is searched ahead of the application class loader, failures are 2349 // expected and will be wrapped in a ClassNotFoundException. Use the pre-allocated error to 2350 // trigger the chaining with a proper stack trace. 2351 mirror::Throwable* pre_allocated = Runtime::Current()->GetPreAllocatedNoClassDefFoundError(); 2352 self->SetException(pre_allocated); 2353 return nullptr; 2354 } 2355 } else { 2356 ScopedObjectAccessUnchecked soa(self); 2357 mirror::Class* cp_klass; 2358 if (FindClassInPathClassLoader(soa, self, descriptor, hash, class_loader, &cp_klass)) { 2359 // The chain was understood. So the value in cp_klass is either the class we were looking 2360 // for, or not found. 2361 if (cp_klass != nullptr) { 2362 return cp_klass; 2363 } 2364 // TODO: We handle the boot classpath loader in FindClassInPathClassLoader. Try to unify this 2365 // and the branch above. TODO: throw the right exception here. 2366 2367 // We'll let the Java-side rediscover all this and throw the exception with the right stack 2368 // trace. 2369 } 2370 2371 if (Runtime::Current()->IsAotCompiler()) { 2372 // Oops, compile-time, can't run actual class-loader code. 2373 mirror::Throwable* pre_allocated = Runtime::Current()->GetPreAllocatedNoClassDefFoundError(); 2374 self->SetException(pre_allocated); 2375 return nullptr; 2376 } 2377 2378 ScopedLocalRef<jobject> class_loader_object(soa.Env(), 2379 soa.AddLocalReference<jobject>(class_loader.Get())); 2380 std::string class_name_string(DescriptorToDot(descriptor)); 2381 ScopedLocalRef<jobject> result(soa.Env(), nullptr); 2382 { 2383 ScopedThreadStateChange tsc(self, kNative); 2384 ScopedLocalRef<jobject> class_name_object(soa.Env(), 2385 soa.Env()->NewStringUTF(class_name_string.c_str())); 2386 if (class_name_object.get() == nullptr) { 2387 DCHECK(self->IsExceptionPending()); // OOME. 2388 return nullptr; 2389 } 2390 CHECK(class_loader_object.get() != nullptr); 2391 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(), 2392 WellKnownClasses::java_lang_ClassLoader_loadClass, 2393 class_name_object.get())); 2394 } 2395 if (self->IsExceptionPending()) { 2396 // If the ClassLoader threw, pass that exception up. 2397 return nullptr; 2398 } else if (result.get() == nullptr) { 2399 // broken loader - throw NPE to be compatible with Dalvik 2400 ThrowNullPointerException(StringPrintf("ClassLoader.loadClass returned null for %s", 2401 class_name_string.c_str()).c_str()); 2402 return nullptr; 2403 } else { 2404 // success, return mirror::Class* 2405 return soa.Decode<mirror::Class*>(result.get()); 2406 } 2407 } 2408 UNREACHABLE(); 2409} 2410 2411mirror::Class* ClassLinker::DefineClass(Thread* self, 2412 const char* descriptor, 2413 size_t hash, 2414 Handle<mirror::ClassLoader> class_loader, 2415 const DexFile& dex_file, 2416 const DexFile::ClassDef& dex_class_def) { 2417 StackHandleScope<3> hs(self); 2418 auto klass = hs.NewHandle<mirror::Class>(nullptr); 2419 2420 // Load the class from the dex file. 2421 if (UNLIKELY(!init_done_)) { 2422 // finish up init of hand crafted class_roots_ 2423 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) { 2424 klass.Assign(GetClassRoot(kJavaLangObject)); 2425 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) { 2426 klass.Assign(GetClassRoot(kJavaLangClass)); 2427 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) { 2428 klass.Assign(GetClassRoot(kJavaLangString)); 2429 } else if (strcmp(descriptor, "Ljava/lang/ref/Reference;") == 0) { 2430 klass.Assign(GetClassRoot(kJavaLangRefReference)); 2431 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) { 2432 klass.Assign(GetClassRoot(kJavaLangDexCache)); 2433 } 2434 } 2435 2436 if (klass.Get() == nullptr) { 2437 // Allocate a class with the status of not ready. 2438 // Interface object should get the right size here. Regular class will 2439 // figure out the right size later and be replaced with one of the right 2440 // size when the class becomes resolved. 2441 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def))); 2442 } 2443 if (UNLIKELY(klass.Get() == nullptr)) { 2444 self->AssertPendingOOMException(); 2445 return nullptr; 2446 } 2447 mirror::DexCache* dex_cache = RegisterDexFile( 2448 dex_file, 2449 GetOrCreateAllocatorForClassLoader(class_loader.Get())); 2450 if (dex_cache == nullptr) { 2451 self->AssertPendingOOMException(); 2452 return nullptr; 2453 } 2454 klass->SetDexCache(dex_cache); 2455 SetupClass(dex_file, dex_class_def, klass, class_loader.Get()); 2456 2457 // Mark the string class by setting its access flag. 2458 if (UNLIKELY(!init_done_)) { 2459 if (strcmp(descriptor, "Ljava/lang/String;") == 0) { 2460 klass->SetStringClass(); 2461 } 2462 } 2463 2464 ObjectLock<mirror::Class> lock(self, klass); 2465 klass->SetClinitThreadId(self->GetTid()); 2466 2467 // Add the newly loaded class to the loaded classes table. 2468 mirror::Class* existing = InsertClass(descriptor, klass.Get(), hash); 2469 if (existing != nullptr) { 2470 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause 2471 // this thread to block. 2472 return EnsureResolved(self, descriptor, existing); 2473 } 2474 2475 // Load the fields and other things after we are inserted in the table. This is so that we don't 2476 // end up allocating unfree-able linear alloc resources and then lose the race condition. The 2477 // other reason is that the field roots are only visited from the class table. So we need to be 2478 // inserted before we allocate / fill in these fields. 2479 LoadClass(self, dex_file, dex_class_def, klass); 2480 if (self->IsExceptionPending()) { 2481 VLOG(class_linker) << self->GetException()->Dump(); 2482 // An exception occured during load, set status to erroneous while holding klass' lock in case 2483 // notification is necessary. 2484 if (!klass->IsErroneous()) { 2485 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 2486 } 2487 return nullptr; 2488 } 2489 2490 // Finish loading (if necessary) by finding parents 2491 CHECK(!klass->IsLoaded()); 2492 if (!LoadSuperAndInterfaces(klass, dex_file)) { 2493 // Loading failed. 2494 if (!klass->IsErroneous()) { 2495 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 2496 } 2497 return nullptr; 2498 } 2499 CHECK(klass->IsLoaded()); 2500 // Link the class (if necessary) 2501 CHECK(!klass->IsResolved()); 2502 // TODO: Use fast jobjects? 2503 auto interfaces = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr); 2504 2505 MutableHandle<mirror::Class> h_new_class = hs.NewHandle<mirror::Class>(nullptr); 2506 if (!LinkClass(self, descriptor, klass, interfaces, &h_new_class)) { 2507 // Linking failed. 2508 if (!klass->IsErroneous()) { 2509 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 2510 } 2511 return nullptr; 2512 } 2513 self->AssertNoPendingException(); 2514 CHECK(h_new_class.Get() != nullptr) << descriptor; 2515 CHECK(h_new_class->IsResolved()) << descriptor; 2516 2517 // Instrumentation may have updated entrypoints for all methods of all 2518 // classes. However it could not update methods of this class while we 2519 // were loading it. Now the class is resolved, we can update entrypoints 2520 // as required by instrumentation. 2521 if (Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) { 2522 // We must be in the kRunnable state to prevent instrumentation from 2523 // suspending all threads to update entrypoints while we are doing it 2524 // for this class. 2525 DCHECK_EQ(self->GetState(), kRunnable); 2526 Runtime::Current()->GetInstrumentation()->InstallStubsForClass(h_new_class.Get()); 2527 } 2528 2529 /* 2530 * We send CLASS_PREPARE events to the debugger from here. The 2531 * definition of "preparation" is creating the static fields for a 2532 * class and initializing them to the standard default values, but not 2533 * executing any code (that comes later, during "initialization"). 2534 * 2535 * We did the static preparation in LinkClass. 2536 * 2537 * The class has been prepared and resolved but possibly not yet verified 2538 * at this point. 2539 */ 2540 Dbg::PostClassPrepare(h_new_class.Get()); 2541 2542 // Notify native debugger of the new class and its layout. 2543 jit::Jit::NewTypeLoadedIfUsingJit(h_new_class.Get()); 2544 2545 return h_new_class.Get(); 2546} 2547 2548uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file, 2549 const DexFile::ClassDef& dex_class_def) { 2550 const uint8_t* class_data = dex_file.GetClassData(dex_class_def); 2551 size_t num_ref = 0; 2552 size_t num_8 = 0; 2553 size_t num_16 = 0; 2554 size_t num_32 = 0; 2555 size_t num_64 = 0; 2556 if (class_data != nullptr) { 2557 // We allow duplicate definitions of the same field in a class_data_item 2558 // but ignore the repeated indexes here, b/21868015. 2559 uint32_t last_field_idx = DexFile::kDexNoIndex; 2560 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) { 2561 uint32_t field_idx = it.GetMemberIndex(); 2562 // Ordering enforced by DexFileVerifier. 2563 DCHECK(last_field_idx == DexFile::kDexNoIndex || last_field_idx <= field_idx); 2564 if (UNLIKELY(field_idx == last_field_idx)) { 2565 continue; 2566 } 2567 last_field_idx = field_idx; 2568 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 2569 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id); 2570 char c = descriptor[0]; 2571 switch (c) { 2572 case 'L': 2573 case '[': 2574 num_ref++; 2575 break; 2576 case 'J': 2577 case 'D': 2578 num_64++; 2579 break; 2580 case 'I': 2581 case 'F': 2582 num_32++; 2583 break; 2584 case 'S': 2585 case 'C': 2586 num_16++; 2587 break; 2588 case 'B': 2589 case 'Z': 2590 num_8++; 2591 break; 2592 default: 2593 LOG(FATAL) << "Unknown descriptor: " << c; 2594 UNREACHABLE(); 2595 } 2596 } 2597 } 2598 return mirror::Class::ComputeClassSize(false, 2599 0, 2600 num_8, 2601 num_16, 2602 num_32, 2603 num_64, 2604 num_ref, 2605 image_pointer_size_); 2606} 2607 2608OatFile::OatClass ClassLinker::FindOatClass(const DexFile& dex_file, 2609 uint16_t class_def_idx, 2610 bool* found) { 2611 DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16); 2612 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 2613 if (oat_dex_file == nullptr) { 2614 *found = false; 2615 return OatFile::OatClass::Invalid(); 2616 } 2617 *found = true; 2618 return oat_dex_file->GetOatClass(class_def_idx); 2619} 2620 2621static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, 2622 uint16_t class_def_idx, 2623 uint32_t method_idx) { 2624 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx); 2625 const uint8_t* class_data = dex_file.GetClassData(class_def); 2626 CHECK(class_data != nullptr); 2627 ClassDataItemIterator it(dex_file, class_data); 2628 // Skip fields 2629 while (it.HasNextStaticField()) { 2630 it.Next(); 2631 } 2632 while (it.HasNextInstanceField()) { 2633 it.Next(); 2634 } 2635 // Process methods 2636 size_t class_def_method_index = 0; 2637 while (it.HasNextDirectMethod()) { 2638 if (it.GetMemberIndex() == method_idx) { 2639 return class_def_method_index; 2640 } 2641 class_def_method_index++; 2642 it.Next(); 2643 } 2644 while (it.HasNextVirtualMethod()) { 2645 if (it.GetMemberIndex() == method_idx) { 2646 return class_def_method_index; 2647 } 2648 class_def_method_index++; 2649 it.Next(); 2650 } 2651 DCHECK(!it.HasNext()); 2652 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation(); 2653 UNREACHABLE(); 2654} 2655 2656const OatFile::OatMethod ClassLinker::FindOatMethodFor(ArtMethod* method, bool* found) { 2657 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution 2658 // method for direct methods (or virtual methods made direct). 2659 mirror::Class* declaring_class = method->GetDeclaringClass(); 2660 size_t oat_method_index; 2661 if (method->IsStatic() || method->IsDirect()) { 2662 // Simple case where the oat method index was stashed at load time. 2663 oat_method_index = method->GetMethodIndex(); 2664 } else { 2665 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index 2666 // by search for its position in the declared virtual methods. 2667 oat_method_index = declaring_class->NumDirectMethods(); 2668 bool found_virtual = false; 2669 for (ArtMethod& art_method : declaring_class->GetVirtualMethods(image_pointer_size_)) { 2670 // Check method index instead of identity in case of duplicate method definitions. 2671 if (method->GetDexMethodIndex() == art_method.GetDexMethodIndex()) { 2672 found_virtual = true; 2673 break; 2674 } 2675 oat_method_index++; 2676 } 2677 CHECK(found_virtual) << "Didn't find oat method index for virtual method: " 2678 << PrettyMethod(method); 2679 } 2680 DCHECK_EQ(oat_method_index, 2681 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(), 2682 method->GetDeclaringClass()->GetDexClassDefIndex(), 2683 method->GetDexMethodIndex())); 2684 OatFile::OatClass oat_class = FindOatClass(*declaring_class->GetDexCache()->GetDexFile(), 2685 declaring_class->GetDexClassDefIndex(), 2686 found); 2687 if (!(*found)) { 2688 return OatFile::OatMethod::Invalid(); 2689 } 2690 return oat_class.GetOatMethod(oat_method_index); 2691} 2692 2693// Special case to get oat code without overwriting a trampoline. 2694const void* ClassLinker::GetQuickOatCodeFor(ArtMethod* method) { 2695 CHECK(method->IsInvokable()) << PrettyMethod(method); 2696 if (method->IsProxyMethod()) { 2697 return GetQuickProxyInvokeHandler(); 2698 } 2699 bool found; 2700 OatFile::OatMethod oat_method = FindOatMethodFor(method, &found); 2701 if (found) { 2702 auto* code = oat_method.GetQuickCode(); 2703 if (code != nullptr) { 2704 return code; 2705 } 2706 } 2707 if (method->IsNative()) { 2708 // No code and native? Use generic trampoline. 2709 return GetQuickGenericJniStub(); 2710 } 2711 return GetQuickToInterpreterBridge(); 2712} 2713 2714const void* ClassLinker::GetOatMethodQuickCodeFor(ArtMethod* method) { 2715 if (method->IsNative() || !method->IsInvokable() || method->IsProxyMethod()) { 2716 return nullptr; 2717 } 2718 bool found; 2719 OatFile::OatMethod oat_method = FindOatMethodFor(method, &found); 2720 if (found) { 2721 return oat_method.GetQuickCode(); 2722 } 2723 return nullptr; 2724} 2725 2726bool ClassLinker::ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) { 2727 if (UNLIKELY(method->IsNative() || method->IsProxyMethod())) { 2728 return false; 2729 } 2730 2731 if (quick_code == nullptr) { 2732 return true; 2733 } 2734 2735 Runtime* runtime = Runtime::Current(); 2736 instrumentation::Instrumentation* instr = runtime->GetInstrumentation(); 2737 if (instr->InterpretOnly()) { 2738 return true; 2739 } 2740 2741 if (runtime->GetClassLinker()->IsQuickToInterpreterBridge(quick_code)) { 2742 // Doing this check avoids doing compiled/interpreter transitions. 2743 return true; 2744 } 2745 2746 if (Dbg::IsForcedInterpreterNeededForCalling(Thread::Current(), method)) { 2747 // Force the use of interpreter when it is required by the debugger. 2748 return true; 2749 } 2750 2751 if (runtime->IsNativeDebuggable()) { 2752 DCHECK(runtime->UseJitCompilation() && runtime->GetJit()->JitAtFirstUse()); 2753 // If we are doing native debugging, ignore application's AOT code, 2754 // since we want to JIT it with extra stackmaps for native debugging. 2755 // On the other hand, keep all AOT code from the boot image, since the 2756 // blocking JIT would results in non-negligible performance impact. 2757 return !runtime->GetHeap()->IsInBootImageOatFile(quick_code); 2758 } 2759 2760 if (Dbg::IsDebuggerActive()) { 2761 // Boot image classes may be AOT-compiled as non-debuggable. 2762 // This is not suitable for the Java debugger, so ignore the AOT code. 2763 return runtime->GetHeap()->IsInBootImageOatFile(quick_code); 2764 } 2765 2766 return false; 2767} 2768 2769void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) { 2770 DCHECK(klass->IsInitialized()) << PrettyDescriptor(klass); 2771 if (klass->NumDirectMethods() == 0) { 2772 return; // No direct methods => no static methods. 2773 } 2774 Runtime* runtime = Runtime::Current(); 2775 if (!runtime->IsStarted()) { 2776 if (runtime->IsAotCompiler() || runtime->GetHeap()->HasBootImageSpace()) { 2777 return; // OAT file unavailable. 2778 } 2779 } 2780 2781 const DexFile& dex_file = klass->GetDexFile(); 2782 const DexFile::ClassDef* dex_class_def = klass->GetClassDef(); 2783 CHECK(dex_class_def != nullptr); 2784 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def); 2785 // There should always be class data if there were direct methods. 2786 CHECK(class_data != nullptr) << PrettyDescriptor(klass); 2787 ClassDataItemIterator it(dex_file, class_data); 2788 // Skip fields 2789 while (it.HasNextStaticField()) { 2790 it.Next(); 2791 } 2792 while (it.HasNextInstanceField()) { 2793 it.Next(); 2794 } 2795 bool has_oat_class; 2796 OatFile::OatClass oat_class = FindOatClass(dex_file, 2797 klass->GetDexClassDefIndex(), 2798 &has_oat_class); 2799 // Link the code of methods skipped by LinkCode. 2800 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) { 2801 ArtMethod* method = klass->GetDirectMethod(method_index, image_pointer_size_); 2802 if (!method->IsStatic()) { 2803 // Only update static methods. 2804 continue; 2805 } 2806 const void* quick_code = nullptr; 2807 if (has_oat_class) { 2808 OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index); 2809 quick_code = oat_method.GetQuickCode(); 2810 } 2811 // Check whether the method is native, in which case it's generic JNI. 2812 if (quick_code == nullptr && method->IsNative()) { 2813 quick_code = GetQuickGenericJniStub(); 2814 } else if (ShouldUseInterpreterEntrypoint(method, quick_code)) { 2815 // Use interpreter entry point. 2816 quick_code = GetQuickToInterpreterBridge(); 2817 } 2818 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code); 2819 } 2820 // Ignore virtual methods on the iterator. 2821} 2822 2823void ClassLinker::EnsureThrowsInvocationError(ArtMethod* method) { 2824 DCHECK(method != nullptr); 2825 DCHECK(!method->IsInvokable()); 2826 method->SetEntryPointFromQuickCompiledCodePtrSize(quick_to_interpreter_bridge_trampoline_, 2827 image_pointer_size_); 2828} 2829 2830void ClassLinker::LinkCode(ArtMethod* method, const OatFile::OatClass* oat_class, 2831 uint32_t class_def_method_index) { 2832 Runtime* const runtime = Runtime::Current(); 2833 if (runtime->IsAotCompiler()) { 2834 // The following code only applies to a non-compiler runtime. 2835 return; 2836 } 2837 // Method shouldn't have already been linked. 2838 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr); 2839 if (oat_class != nullptr) { 2840 // Every kind of method should at least get an invoke stub from the oat_method. 2841 // non-abstract methods also get their code pointers. 2842 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(class_def_method_index); 2843 oat_method.LinkMethod(method); 2844 } 2845 2846 // Install entry point from interpreter. 2847 const void* quick_code = method->GetEntryPointFromQuickCompiledCode(); 2848 bool enter_interpreter = ShouldUseInterpreterEntrypoint(method, quick_code); 2849 2850 if (!method->IsInvokable()) { 2851 EnsureThrowsInvocationError(method); 2852 return; 2853 } 2854 2855 if (method->IsStatic() && !method->IsConstructor()) { 2856 // For static methods excluding the class initializer, install the trampoline. 2857 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines 2858 // after initializing class (see ClassLinker::InitializeClass method). 2859 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub()); 2860 } else if (quick_code == nullptr && method->IsNative()) { 2861 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniStub()); 2862 } else if (enter_interpreter) { 2863 // Set entry point from compiled code if there's no code or in interpreter only mode. 2864 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge()); 2865 } 2866 2867 if (method->IsNative()) { 2868 // Unregistering restores the dlsym lookup stub. 2869 method->UnregisterNative(); 2870 2871 if (enter_interpreter || quick_code == nullptr) { 2872 // We have a native method here without code. Then it should have either the generic JNI 2873 // trampoline as entrypoint (non-static), or the resolution trampoline (static). 2874 // TODO: this doesn't handle all the cases where trampolines may be installed. 2875 const void* entry_point = method->GetEntryPointFromQuickCompiledCode(); 2876 DCHECK(IsQuickGenericJniStub(entry_point) || IsQuickResolutionStub(entry_point)); 2877 } 2878 } 2879} 2880 2881void ClassLinker::SetupClass(const DexFile& dex_file, 2882 const DexFile::ClassDef& dex_class_def, 2883 Handle<mirror::Class> klass, 2884 mirror::ClassLoader* class_loader) { 2885 CHECK(klass.Get() != nullptr); 2886 CHECK(klass->GetDexCache() != nullptr); 2887 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus()); 2888 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def); 2889 CHECK(descriptor != nullptr); 2890 2891 klass->SetClass(GetClassRoot(kJavaLangClass)); 2892 uint32_t access_flags = dex_class_def.GetJavaAccessFlags(); 2893 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U); 2894 klass->SetAccessFlags(access_flags); 2895 klass->SetClassLoader(class_loader); 2896 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot); 2897 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, nullptr); 2898 2899 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def)); 2900 klass->SetDexTypeIndex(dex_class_def.class_idx_); 2901 CHECK(klass->GetDexCacheStrings() != nullptr); 2902} 2903 2904void ClassLinker::LoadClass(Thread* self, 2905 const DexFile& dex_file, 2906 const DexFile::ClassDef& dex_class_def, 2907 Handle<mirror::Class> klass) { 2908 const uint8_t* class_data = dex_file.GetClassData(dex_class_def); 2909 if (class_data == nullptr) { 2910 return; // no fields or methods - for example a marker interface 2911 } 2912 bool has_oat_class = false; 2913 if (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler()) { 2914 OatFile::OatClass oat_class = FindOatClass(dex_file, klass->GetDexClassDefIndex(), 2915 &has_oat_class); 2916 if (has_oat_class) { 2917 LoadClassMembers(self, dex_file, class_data, klass, &oat_class); 2918 } 2919 } 2920 if (!has_oat_class) { 2921 LoadClassMembers(self, dex_file, class_data, klass, nullptr); 2922 } 2923} 2924 2925LengthPrefixedArray<ArtField>* ClassLinker::AllocArtFieldArray(Thread* self, 2926 LinearAlloc* allocator, 2927 size_t length) { 2928 if (length == 0) { 2929 return nullptr; 2930 } 2931 // If the ArtField alignment changes, review all uses of LengthPrefixedArray<ArtField>. 2932 static_assert(alignof(ArtField) == 4, "ArtField alignment is expected to be 4."); 2933 size_t storage_size = LengthPrefixedArray<ArtField>::ComputeSize(length); 2934 void* array_storage = allocator->Alloc(self, storage_size); 2935 auto* ret = new(array_storage) LengthPrefixedArray<ArtField>(length); 2936 CHECK(ret != nullptr); 2937 std::uninitialized_fill_n(&ret->At(0), length, ArtField()); 2938 return ret; 2939} 2940 2941LengthPrefixedArray<ArtMethod>* ClassLinker::AllocArtMethodArray(Thread* self, 2942 LinearAlloc* allocator, 2943 size_t length) { 2944 if (length == 0) { 2945 return nullptr; 2946 } 2947 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_); 2948 const size_t method_size = ArtMethod::Size(image_pointer_size_); 2949 const size_t storage_size = 2950 LengthPrefixedArray<ArtMethod>::ComputeSize(length, method_size, method_alignment); 2951 void* array_storage = allocator->Alloc(self, storage_size); 2952 auto* ret = new (array_storage) LengthPrefixedArray<ArtMethod>(length); 2953 CHECK(ret != nullptr); 2954 for (size_t i = 0; i < length; ++i) { 2955 new(reinterpret_cast<void*>(&ret->At(i, method_size, method_alignment))) ArtMethod; 2956 } 2957 return ret; 2958} 2959 2960LinearAlloc* ClassLinker::GetAllocatorForClassLoader(mirror::ClassLoader* class_loader) { 2961 if (class_loader == nullptr) { 2962 return Runtime::Current()->GetLinearAlloc(); 2963 } 2964 LinearAlloc* allocator = class_loader->GetAllocator(); 2965 DCHECK(allocator != nullptr); 2966 return allocator; 2967} 2968 2969LinearAlloc* ClassLinker::GetOrCreateAllocatorForClassLoader(mirror::ClassLoader* class_loader) { 2970 if (class_loader == nullptr) { 2971 return Runtime::Current()->GetLinearAlloc(); 2972 } 2973 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 2974 LinearAlloc* allocator = class_loader->GetAllocator(); 2975 if (allocator == nullptr) { 2976 RegisterClassLoader(class_loader); 2977 allocator = class_loader->GetAllocator(); 2978 CHECK(allocator != nullptr); 2979 } 2980 return allocator; 2981} 2982 2983void ClassLinker::LoadClassMembers(Thread* self, 2984 const DexFile& dex_file, 2985 const uint8_t* class_data, 2986 Handle<mirror::Class> klass, 2987 const OatFile::OatClass* oat_class) { 2988 { 2989 // Note: We cannot have thread suspension until the field and method arrays are setup or else 2990 // Class::VisitFieldRoots may miss some fields or methods. 2991 ScopedAssertNoThreadSuspension nts(self, __FUNCTION__); 2992 // Load static fields. 2993 // We allow duplicate definitions of the same field in a class_data_item 2994 // but ignore the repeated indexes here, b/21868015. 2995 LinearAlloc* const allocator = GetAllocatorForClassLoader(klass->GetClassLoader()); 2996 ClassDataItemIterator it(dex_file, class_data); 2997 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self, 2998 allocator, 2999 it.NumStaticFields()); 3000 size_t num_sfields = 0; 3001 uint32_t last_field_idx = 0u; 3002 for (; it.HasNextStaticField(); it.Next()) { 3003 uint32_t field_idx = it.GetMemberIndex(); 3004 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier. 3005 if (num_sfields == 0 || LIKELY(field_idx > last_field_idx)) { 3006 DCHECK_LT(num_sfields, it.NumStaticFields()); 3007 LoadField(it, klass, &sfields->At(num_sfields)); 3008 ++num_sfields; 3009 last_field_idx = field_idx; 3010 } 3011 } 3012 // Load instance fields. 3013 LengthPrefixedArray<ArtField>* ifields = AllocArtFieldArray(self, 3014 allocator, 3015 it.NumInstanceFields()); 3016 size_t num_ifields = 0u; 3017 last_field_idx = 0u; 3018 for (; it.HasNextInstanceField(); it.Next()) { 3019 uint32_t field_idx = it.GetMemberIndex(); 3020 DCHECK_GE(field_idx, last_field_idx); // Ordering enforced by DexFileVerifier. 3021 if (num_ifields == 0 || LIKELY(field_idx > last_field_idx)) { 3022 DCHECK_LT(num_ifields, it.NumInstanceFields()); 3023 LoadField(it, klass, &ifields->At(num_ifields)); 3024 ++num_ifields; 3025 last_field_idx = field_idx; 3026 } 3027 } 3028 if (UNLIKELY(num_sfields != it.NumStaticFields()) || 3029 UNLIKELY(num_ifields != it.NumInstanceFields())) { 3030 LOG(WARNING) << "Duplicate fields in class " << PrettyDescriptor(klass.Get()) 3031 << " (unique static fields: " << num_sfields << "/" << it.NumStaticFields() 3032 << ", unique instance fields: " << num_ifields << "/" << it.NumInstanceFields() << ")"; 3033 // NOTE: Not shrinking the over-allocated sfields/ifields, just setting size. 3034 if (sfields != nullptr) { 3035 sfields->SetSize(num_sfields); 3036 } 3037 if (ifields != nullptr) { 3038 ifields->SetSize(num_ifields); 3039 } 3040 } 3041 // Set the field arrays. 3042 klass->SetSFieldsPtr(sfields); 3043 DCHECK_EQ(klass->NumStaticFields(), num_sfields); 3044 klass->SetIFieldsPtr(ifields); 3045 DCHECK_EQ(klass->NumInstanceFields(), num_ifields); 3046 // Load methods. 3047 klass->SetMethodsPtr( 3048 AllocArtMethodArray(self, allocator, it.NumDirectMethods() + it.NumVirtualMethods()), 3049 it.NumDirectMethods(), 3050 it.NumVirtualMethods()); 3051 size_t class_def_method_index = 0; 3052 uint32_t last_dex_method_index = DexFile::kDexNoIndex; 3053 size_t last_class_def_method_index = 0; 3054 // TODO These should really use the iterators. 3055 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) { 3056 ArtMethod* method = klass->GetDirectMethodUnchecked(i, image_pointer_size_); 3057 LoadMethod(self, dex_file, it, klass, method); 3058 LinkCode(method, oat_class, class_def_method_index); 3059 uint32_t it_method_index = it.GetMemberIndex(); 3060 if (last_dex_method_index == it_method_index) { 3061 // duplicate case 3062 method->SetMethodIndex(last_class_def_method_index); 3063 } else { 3064 method->SetMethodIndex(class_def_method_index); 3065 last_dex_method_index = it_method_index; 3066 last_class_def_method_index = class_def_method_index; 3067 } 3068 class_def_method_index++; 3069 } 3070 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) { 3071 ArtMethod* method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_); 3072 LoadMethod(self, dex_file, it, klass, method); 3073 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i); 3074 LinkCode(method, oat_class, class_def_method_index); 3075 class_def_method_index++; 3076 } 3077 DCHECK(!it.HasNext()); 3078 } 3079 // Ensure that the card is marked so that remembered sets pick up native roots. 3080 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass.Get()); 3081 self->AllowThreadSuspension(); 3082} 3083 3084void ClassLinker::LoadField(const ClassDataItemIterator& it, 3085 Handle<mirror::Class> klass, 3086 ArtField* dst) { 3087 const uint32_t field_idx = it.GetMemberIndex(); 3088 dst->SetDexFieldIndex(field_idx); 3089 dst->SetDeclaringClass(klass.Get()); 3090 dst->SetAccessFlags(it.GetFieldAccessFlags()); 3091} 3092 3093void ClassLinker::LoadMethod(Thread* self, 3094 const DexFile& dex_file, 3095 const ClassDataItemIterator& it, 3096 Handle<mirror::Class> klass, 3097 ArtMethod* dst) { 3098 uint32_t dex_method_idx = it.GetMemberIndex(); 3099 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx); 3100 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_); 3101 3102 ScopedAssertNoThreadSuspension ants(self, "LoadMethod"); 3103 dst->SetDexMethodIndex(dex_method_idx); 3104 dst->SetDeclaringClass(klass.Get()); 3105 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset()); 3106 3107 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods(), image_pointer_size_); 3108 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes(), image_pointer_size_); 3109 3110 uint32_t access_flags = it.GetMethodAccessFlags(); 3111 3112 if (UNLIKELY(strcmp("finalize", method_name) == 0)) { 3113 // Set finalizable flag on declaring class. 3114 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) { 3115 // Void return type. 3116 if (klass->GetClassLoader() != nullptr) { // All non-boot finalizer methods are flagged. 3117 klass->SetFinalizable(); 3118 } else { 3119 std::string temp; 3120 const char* klass_descriptor = klass->GetDescriptor(&temp); 3121 // The Enum class declares a "final" finalize() method to prevent subclasses from 3122 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its 3123 // subclasses, so we exclude it here. 3124 // We also want to avoid setting the flag on Object, where we know that finalize() is 3125 // empty. 3126 if (strcmp(klass_descriptor, "Ljava/lang/Object;") != 0 && 3127 strcmp(klass_descriptor, "Ljava/lang/Enum;") != 0) { 3128 klass->SetFinalizable(); 3129 } 3130 } 3131 } 3132 } else if (method_name[0] == '<') { 3133 // Fix broken access flags for initializers. Bug 11157540. 3134 bool is_init = (strcmp("<init>", method_name) == 0); 3135 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0); 3136 if (UNLIKELY(!is_init && !is_clinit)) { 3137 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name; 3138 } else { 3139 if (UNLIKELY((access_flags & kAccConstructor) == 0)) { 3140 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class " 3141 << PrettyDescriptor(klass.Get()) << " in dex file " << dex_file.GetLocation(); 3142 access_flags |= kAccConstructor; 3143 } 3144 } 3145 } 3146 dst->SetAccessFlags(access_flags); 3147} 3148 3149void ClassLinker::AppendToBootClassPath(Thread* self, const DexFile& dex_file) { 3150 StackHandleScope<1> hs(self); 3151 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache( 3152 self, 3153 dex_file, 3154 Runtime::Current()->GetLinearAlloc()))); 3155 CHECK(dex_cache.Get() != nullptr) << "Failed to allocate dex cache for " 3156 << dex_file.GetLocation(); 3157 AppendToBootClassPath(dex_file, dex_cache); 3158} 3159 3160void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, 3161 Handle<mirror::DexCache> dex_cache) { 3162 CHECK(dex_cache.Get() != nullptr) << dex_file.GetLocation(); 3163 boot_class_path_.push_back(&dex_file); 3164 RegisterDexFile(dex_file, dex_cache); 3165} 3166 3167void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, 3168 Handle<mirror::DexCache> dex_cache) { 3169 Thread* const self = Thread::Current(); 3170 dex_lock_.AssertExclusiveHeld(self); 3171 CHECK(dex_cache.Get() != nullptr) << dex_file.GetLocation(); 3172 // For app images, the dex cache location may be a suffix of the dex file location since the 3173 // dex file location is an absolute path. 3174 const std::string dex_cache_location = dex_cache->GetLocation()->ToModifiedUtf8(); 3175 const size_t dex_cache_length = dex_cache_location.length(); 3176 CHECK_GT(dex_cache_length, 0u) << dex_file.GetLocation(); 3177 std::string dex_file_location = dex_file.GetLocation(); 3178 CHECK_GE(dex_file_location.length(), dex_cache_length) 3179 << dex_cache_location << " " << dex_file.GetLocation(); 3180 // Take suffix. 3181 const std::string dex_file_suffix = dex_file_location.substr( 3182 dex_file_location.length() - dex_cache_length, 3183 dex_cache_length); 3184 // Example dex_cache location is SettingsProvider.apk and 3185 // dex file location is /system/priv-app/SettingsProvider/SettingsProvider.apk 3186 CHECK_EQ(dex_cache_location, dex_file_suffix); 3187 // Clean up pass to remove null dex caches. 3188 // Null dex caches can occur due to class unloading and we are lazily removing null entries. 3189 JavaVMExt* const vm = self->GetJniEnv()->vm; 3190 for (auto it = dex_caches_.begin(); it != dex_caches_.end(); ) { 3191 DexCacheData data = *it; 3192 if (self->IsJWeakCleared(data.weak_root)) { 3193 vm->DeleteWeakGlobalRef(self, data.weak_root); 3194 it = dex_caches_.erase(it); 3195 } else { 3196 ++it; 3197 } 3198 } 3199 jweak dex_cache_jweak = vm->AddWeakGlobalRef(self, dex_cache.Get()); 3200 dex_cache->SetDexFile(&dex_file); 3201 DexCacheData data; 3202 data.weak_root = dex_cache_jweak; 3203 data.dex_file = dex_cache->GetDexFile(); 3204 data.resolved_types = dex_cache->GetResolvedTypes(); 3205 dex_caches_.push_back(data); 3206} 3207 3208mirror::DexCache* ClassLinker::RegisterDexFile(const DexFile& dex_file, LinearAlloc* linear_alloc) { 3209 Thread* self = Thread::Current(); 3210 { 3211 ReaderMutexLock mu(self, dex_lock_); 3212 mirror::DexCache* dex_cache = FindDexCacheLocked(self, dex_file, true); 3213 if (dex_cache != nullptr) { 3214 return dex_cache; 3215 } 3216 } 3217 // Don't alloc while holding the lock, since allocation may need to 3218 // suspend all threads and another thread may need the dex_lock_ to 3219 // get to a suspend point. 3220 StackHandleScope<1> hs(self); 3221 Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(AllocDexCache(self, dex_file, linear_alloc))); 3222 WriterMutexLock mu(self, dex_lock_); 3223 mirror::DexCache* dex_cache = FindDexCacheLocked(self, dex_file, true); 3224 if (dex_cache != nullptr) { 3225 return dex_cache; 3226 } 3227 if (h_dex_cache.Get() == nullptr) { 3228 self->AssertPendingOOMException(); 3229 return nullptr; 3230 } 3231 RegisterDexFileLocked(dex_file, h_dex_cache); 3232 return h_dex_cache.Get(); 3233} 3234 3235void ClassLinker::RegisterDexFile(const DexFile& dex_file, 3236 Handle<mirror::DexCache> dex_cache) { 3237 WriterMutexLock mu(Thread::Current(), dex_lock_); 3238 RegisterDexFileLocked(dex_file, dex_cache); 3239} 3240 3241mirror::DexCache* ClassLinker::FindDexCache(Thread* self, 3242 const DexFile& dex_file, 3243 bool allow_failure) { 3244 ReaderMutexLock mu(self, dex_lock_); 3245 return FindDexCacheLocked(self, dex_file, allow_failure); 3246} 3247 3248mirror::DexCache* ClassLinker::FindDexCacheLocked(Thread* self, 3249 const DexFile& dex_file, 3250 bool allow_failure) { 3251 // Search assuming unique-ness of dex file. 3252 for (const DexCacheData& data : dex_caches_) { 3253 // Avoid decoding (and read barriers) other unrelated dex caches. 3254 if (data.dex_file == &dex_file) { 3255 mirror::DexCache* dex_cache = 3256 down_cast<mirror::DexCache*>(self->DecodeJObject(data.weak_root)); 3257 if (dex_cache != nullptr) { 3258 return dex_cache; 3259 } else { 3260 break; 3261 } 3262 } 3263 } 3264 if (allow_failure) { 3265 return nullptr; 3266 } 3267 std::string location(dex_file.GetLocation()); 3268 // Failure, dump diagnostic and abort. 3269 for (const DexCacheData& data : dex_caches_) { 3270 mirror::DexCache* dex_cache = down_cast<mirror::DexCache*>(self->DecodeJObject(data.weak_root)); 3271 if (dex_cache != nullptr) { 3272 LOG(ERROR) << "Registered dex file " << dex_cache->GetDexFile()->GetLocation(); 3273 } 3274 } 3275 LOG(FATAL) << "Failed to find DexCache for DexFile " << location; 3276 UNREACHABLE(); 3277} 3278 3279void ClassLinker::FixupDexCaches(ArtMethod* resolution_method) { 3280 Thread* const self = Thread::Current(); 3281 ReaderMutexLock mu(self, dex_lock_); 3282 for (const DexCacheData& data : dex_caches_) { 3283 if (!self->IsJWeakCleared(data.weak_root)) { 3284 mirror::DexCache* dex_cache = down_cast<mirror::DexCache*>( 3285 self->DecodeJObject(data.weak_root)); 3286 if (dex_cache != nullptr) { 3287 dex_cache->Fixup(resolution_method, image_pointer_size_); 3288 } 3289 } 3290 } 3291} 3292 3293mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) { 3294 mirror::Class* klass = AllocClass(self, mirror::Class::PrimitiveClassSize(image_pointer_size_)); 3295 if (UNLIKELY(klass == nullptr)) { 3296 self->AssertPendingOOMException(); 3297 return nullptr; 3298 } 3299 return InitializePrimitiveClass(klass, type); 3300} 3301 3302mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, 3303 Primitive::Type type) { 3304 CHECK(primitive_class != nullptr); 3305 // Must hold lock on object when initializing. 3306 Thread* self = Thread::Current(); 3307 StackHandleScope<1> hs(self); 3308 Handle<mirror::Class> h_class(hs.NewHandle(primitive_class)); 3309 ObjectLock<mirror::Class> lock(self, h_class); 3310 h_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract); 3311 h_class->SetPrimitiveType(type); 3312 mirror::Class::SetStatus(h_class, mirror::Class::kStatusInitialized, self); 3313 const char* descriptor = Primitive::Descriptor(type); 3314 mirror::Class* existing = InsertClass(descriptor, h_class.Get(), 3315 ComputeModifiedUtf8Hash(descriptor)); 3316 CHECK(existing == nullptr) << "InitPrimitiveClass(" << type << ") failed"; 3317 return h_class.Get(); 3318} 3319 3320// Create an array class (i.e. the class object for the array, not the 3321// array itself). "descriptor" looks like "[C" or "[[[[B" or 3322// "[Ljava/lang/String;". 3323// 3324// If "descriptor" refers to an array of primitives, look up the 3325// primitive type's internally-generated class object. 3326// 3327// "class_loader" is the class loader of the class that's referring to 3328// us. It's used to ensure that we're looking for the element type in 3329// the right context. It does NOT become the class loader for the 3330// array class; that always comes from the base element class. 3331// 3332// Returns null with an exception raised on failure. 3333mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor, size_t hash, 3334 Handle<mirror::ClassLoader> class_loader) { 3335 // Identify the underlying component type 3336 CHECK_EQ('[', descriptor[0]); 3337 StackHandleScope<2> hs(self); 3338 MutableHandle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1, 3339 class_loader))); 3340 if (component_type.Get() == nullptr) { 3341 DCHECK(self->IsExceptionPending()); 3342 // We need to accept erroneous classes as component types. 3343 const size_t component_hash = ComputeModifiedUtf8Hash(descriptor + 1); 3344 component_type.Assign(LookupClass(self, descriptor + 1, component_hash, class_loader.Get())); 3345 if (component_type.Get() == nullptr) { 3346 DCHECK(self->IsExceptionPending()); 3347 return nullptr; 3348 } else { 3349 self->ClearException(); 3350 } 3351 } 3352 if (UNLIKELY(component_type->IsPrimitiveVoid())) { 3353 ThrowNoClassDefFoundError("Attempt to create array of void primitive type"); 3354 return nullptr; 3355 } 3356 // See if the component type is already loaded. Array classes are 3357 // always associated with the class loader of their underlying 3358 // element type -- an array of Strings goes with the loader for 3359 // java/lang/String -- so we need to look for it there. (The 3360 // caller should have checked for the existence of the class 3361 // before calling here, but they did so with *their* class loader, 3362 // not the component type's loader.) 3363 // 3364 // If we find it, the caller adds "loader" to the class' initiating 3365 // loader list, which should prevent us from going through this again. 3366 // 3367 // This call is unnecessary if "loader" and "component_type->GetClassLoader()" 3368 // are the same, because our caller (FindClass) just did the 3369 // lookup. (Even if we get this wrong we still have correct behavior, 3370 // because we effectively do this lookup again when we add the new 3371 // class to the hash table --- necessary because of possible races with 3372 // other threads.) 3373 if (class_loader.Get() != component_type->GetClassLoader()) { 3374 mirror::Class* new_class = LookupClass(self, descriptor, hash, component_type->GetClassLoader()); 3375 if (new_class != nullptr) { 3376 return new_class; 3377 } 3378 } 3379 3380 // Fill out the fields in the Class. 3381 // 3382 // It is possible to execute some methods against arrays, because 3383 // all arrays are subclasses of java_lang_Object_, so we need to set 3384 // up a vtable. We can just point at the one in java_lang_Object_. 3385 // 3386 // Array classes are simple enough that we don't need to do a full 3387 // link step. 3388 auto new_class = hs.NewHandle<mirror::Class>(nullptr); 3389 if (UNLIKELY(!init_done_)) { 3390 // Classes that were hand created, ie not by FindSystemClass 3391 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) { 3392 new_class.Assign(GetClassRoot(kClassArrayClass)); 3393 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) { 3394 new_class.Assign(GetClassRoot(kObjectArrayClass)); 3395 } else if (strcmp(descriptor, GetClassRootDescriptor(kJavaLangStringArrayClass)) == 0) { 3396 new_class.Assign(GetClassRoot(kJavaLangStringArrayClass)); 3397 } else if (strcmp(descriptor, "[C") == 0) { 3398 new_class.Assign(GetClassRoot(kCharArrayClass)); 3399 } else if (strcmp(descriptor, "[I") == 0) { 3400 new_class.Assign(GetClassRoot(kIntArrayClass)); 3401 } else if (strcmp(descriptor, "[J") == 0) { 3402 new_class.Assign(GetClassRoot(kLongArrayClass)); 3403 } 3404 } 3405 if (new_class.Get() == nullptr) { 3406 new_class.Assign(AllocClass(self, mirror::Array::ClassSize(image_pointer_size_))); 3407 if (new_class.Get() == nullptr) { 3408 self->AssertPendingOOMException(); 3409 return nullptr; 3410 } 3411 new_class->SetComponentType(component_type.Get()); 3412 } 3413 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing. 3414 DCHECK(new_class->GetComponentType() != nullptr); 3415 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject); 3416 new_class->SetSuperClass(java_lang_Object); 3417 new_class->SetVTable(java_lang_Object->GetVTable()); 3418 new_class->SetPrimitiveType(Primitive::kPrimNot); 3419 new_class->SetClassLoader(component_type->GetClassLoader()); 3420 if (component_type->IsPrimitive()) { 3421 new_class->SetClassFlags(mirror::kClassFlagNoReferenceFields); 3422 } else { 3423 new_class->SetClassFlags(mirror::kClassFlagObjectArray); 3424 } 3425 mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self); 3426 { 3427 ArtMethod* imt[mirror::Class::kImtSize]; 3428 std::fill_n(imt, arraysize(imt), Runtime::Current()->GetImtUnimplementedMethod()); 3429 new_class->PopulateEmbeddedImtAndVTable(imt, image_pointer_size_); 3430 } 3431 mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self); 3432 // don't need to set new_class->SetObjectSize(..) 3433 // because Object::SizeOf delegates to Array::SizeOf 3434 3435 3436 // All arrays have java/lang/Cloneable and java/io/Serializable as 3437 // interfaces. We need to set that up here, so that stuff like 3438 // "instanceof" works right. 3439 // 3440 // Note: The GC could run during the call to FindSystemClass, 3441 // so we need to make sure the class object is GC-valid while we're in 3442 // there. Do this by clearing the interface list so the GC will just 3443 // think that the entries are null. 3444 3445 3446 // Use the single, global copies of "interfaces" and "iftable" 3447 // (remember not to free them for arrays). 3448 { 3449 mirror::IfTable* array_iftable = array_iftable_.Read(); 3450 CHECK(array_iftable != nullptr); 3451 new_class->SetIfTable(array_iftable); 3452 } 3453 3454 // Inherit access flags from the component type. 3455 int access_flags = new_class->GetComponentType()->GetAccessFlags(); 3456 // Lose any implementation detail flags; in particular, arrays aren't finalizable. 3457 access_flags &= kAccJavaFlagsMask; 3458 // Arrays can't be used as a superclass or interface, so we want to add "abstract final" 3459 // and remove "interface". 3460 access_flags |= kAccAbstract | kAccFinal; 3461 access_flags &= ~kAccInterface; 3462 3463 new_class->SetAccessFlags(access_flags); 3464 3465 mirror::Class* existing = InsertClass(descriptor, new_class.Get(), hash); 3466 if (existing == nullptr) { 3467 jit::Jit::NewTypeLoadedIfUsingJit(new_class.Get()); 3468 return new_class.Get(); 3469 } 3470 // Another thread must have loaded the class after we 3471 // started but before we finished. Abandon what we've 3472 // done. 3473 // 3474 // (Yes, this happens.) 3475 3476 return existing; 3477} 3478 3479mirror::Class* ClassLinker::FindPrimitiveClass(char type) { 3480 switch (type) { 3481 case 'B': 3482 return GetClassRoot(kPrimitiveByte); 3483 case 'C': 3484 return GetClassRoot(kPrimitiveChar); 3485 case 'D': 3486 return GetClassRoot(kPrimitiveDouble); 3487 case 'F': 3488 return GetClassRoot(kPrimitiveFloat); 3489 case 'I': 3490 return GetClassRoot(kPrimitiveInt); 3491 case 'J': 3492 return GetClassRoot(kPrimitiveLong); 3493 case 'S': 3494 return GetClassRoot(kPrimitiveShort); 3495 case 'Z': 3496 return GetClassRoot(kPrimitiveBoolean); 3497 case 'V': 3498 return GetClassRoot(kPrimitiveVoid); 3499 default: 3500 break; 3501 } 3502 std::string printable_type(PrintableChar(type)); 3503 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str()); 3504 return nullptr; 3505} 3506 3507mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass, size_t hash) { 3508 if (VLOG_IS_ON(class_linker)) { 3509 mirror::DexCache* dex_cache = klass->GetDexCache(); 3510 std::string source; 3511 if (dex_cache != nullptr) { 3512 source += " from "; 3513 source += dex_cache->GetLocation()->ToModifiedUtf8(); 3514 } 3515 LOG(INFO) << "Loaded class " << descriptor << source; 3516 } 3517 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 3518 mirror::ClassLoader* const class_loader = klass->GetClassLoader(); 3519 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader); 3520 mirror::Class* existing = class_table->Lookup(descriptor, hash); 3521 if (existing != nullptr) { 3522 return existing; 3523 } 3524 if (kIsDebugBuild && 3525 !klass->IsTemp() && 3526 class_loader == nullptr && 3527 dex_cache_boot_image_class_lookup_required_) { 3528 // Check a class loaded with the system class loader matches one in the image if the class 3529 // is in the image. 3530 existing = LookupClassFromBootImage(descriptor); 3531 if (existing != nullptr) { 3532 CHECK_EQ(klass, existing); 3533 } 3534 } 3535 VerifyObject(klass); 3536 class_table->InsertWithHash(klass, hash); 3537 if (class_loader != nullptr) { 3538 // This is necessary because we need to have the card dirtied for remembered sets. 3539 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader); 3540 } 3541 if (log_new_class_table_roots_) { 3542 new_class_roots_.push_back(GcRoot<mirror::Class>(klass)); 3543 } 3544 return nullptr; 3545} 3546 3547// TODO This should really be in mirror::Class. 3548void ClassLinker::UpdateClassMethods(mirror::Class* klass, 3549 LengthPrefixedArray<ArtMethod>* new_methods) { 3550 klass->SetMethodsPtrUnchecked(new_methods, 3551 klass->NumDirectMethods(), 3552 klass->NumDeclaredVirtualMethods()); 3553 // Need to mark the card so that the remembered sets and mod union tables get updated. 3554 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(klass); 3555} 3556 3557bool ClassLinker::RemoveClass(const char* descriptor, mirror::ClassLoader* class_loader) { 3558 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 3559 ClassTable* const class_table = ClassTableForClassLoader(class_loader); 3560 return class_table != nullptr && class_table->Remove(descriptor); 3561} 3562 3563mirror::Class* ClassLinker::LookupClass(Thread* self, 3564 const char* descriptor, 3565 size_t hash, 3566 mirror::ClassLoader* class_loader) { 3567 { 3568 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 3569 ClassTable* const class_table = ClassTableForClassLoader(class_loader); 3570 if (class_table != nullptr) { 3571 mirror::Class* result = class_table->Lookup(descriptor, hash); 3572 if (result != nullptr) { 3573 return result; 3574 } 3575 } 3576 } 3577 if (class_loader != nullptr || !dex_cache_boot_image_class_lookup_required_) { 3578 return nullptr; 3579 } 3580 // Lookup failed but need to search dex_caches_. 3581 mirror::Class* result = LookupClassFromBootImage(descriptor); 3582 if (result != nullptr) { 3583 result = InsertClass(descriptor, result, hash); 3584 } else { 3585 // Searching the image dex files/caches failed, we don't want to get into this situation 3586 // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image 3587 // classes into the class table. 3588 constexpr uint32_t kMaxFailedDexCacheLookups = 1000; 3589 if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) { 3590 AddBootImageClassesToClassTable(); 3591 } 3592 } 3593 return result; 3594} 3595 3596static std::vector<mirror::ObjectArray<mirror::DexCache>*> GetImageDexCaches( 3597 std::vector<gc::space::ImageSpace*> image_spaces) SHARED_REQUIRES(Locks::mutator_lock_) { 3598 CHECK(!image_spaces.empty()); 3599 std::vector<mirror::ObjectArray<mirror::DexCache>*> dex_caches_vector; 3600 for (gc::space::ImageSpace* image_space : image_spaces) { 3601 mirror::Object* root = image_space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches); 3602 DCHECK(root != nullptr); 3603 dex_caches_vector.push_back(root->AsObjectArray<mirror::DexCache>()); 3604 } 3605 return dex_caches_vector; 3606} 3607 3608void ClassLinker::AddBootImageClassesToClassTable() { 3609 if (dex_cache_boot_image_class_lookup_required_) { 3610 AddImageClassesToClassTable(Runtime::Current()->GetHeap()->GetBootImageSpaces(), 3611 /*class_loader*/nullptr); 3612 dex_cache_boot_image_class_lookup_required_ = false; 3613 } 3614} 3615 3616void ClassLinker::AddImageClassesToClassTable(std::vector<gc::space::ImageSpace*> image_spaces, 3617 mirror::ClassLoader* class_loader) { 3618 Thread* self = Thread::Current(); 3619 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 3620 ScopedAssertNoThreadSuspension ants(self, "Moving image classes to class table"); 3621 3622 ClassTable* const class_table = InsertClassTableForClassLoader(class_loader); 3623 3624 std::string temp; 3625 std::vector<mirror::ObjectArray<mirror::DexCache>*> dex_caches_vector = 3626 GetImageDexCaches(image_spaces); 3627 for (mirror::ObjectArray<mirror::DexCache>* dex_caches : dex_caches_vector) { 3628 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 3629 mirror::DexCache* dex_cache = dex_caches->Get(i); 3630 GcRoot<mirror::Class>* types = dex_cache->GetResolvedTypes(); 3631 for (int32_t j = 0, num_types = dex_cache->NumResolvedTypes(); j < num_types; j++) { 3632 mirror::Class* klass = types[j].Read(); 3633 if (klass != nullptr) { 3634 DCHECK_EQ(klass->GetClassLoader(), class_loader); 3635 const char* descriptor = klass->GetDescriptor(&temp); 3636 size_t hash = ComputeModifiedUtf8Hash(descriptor); 3637 mirror::Class* existing = class_table->Lookup(descriptor, hash); 3638 if (existing != nullptr) { 3639 CHECK_EQ(existing, klass) << PrettyClassAndClassLoader(existing) << " != " 3640 << PrettyClassAndClassLoader(klass); 3641 } else { 3642 class_table->Insert(klass); 3643 if (log_new_class_table_roots_) { 3644 new_class_roots_.push_back(GcRoot<mirror::Class>(klass)); 3645 } 3646 } 3647 } 3648 } 3649 } 3650 } 3651} 3652 3653class MoveClassTableToPreZygoteVisitor : public ClassLoaderVisitor { 3654 public: 3655 explicit MoveClassTableToPreZygoteVisitor() {} 3656 3657 void Visit(mirror::ClassLoader* class_loader) 3658 REQUIRES(Locks::classlinker_classes_lock_) 3659 SHARED_REQUIRES(Locks::mutator_lock_) OVERRIDE { 3660 ClassTable* const class_table = class_loader->GetClassTable(); 3661 if (class_table != nullptr) { 3662 class_table->FreezeSnapshot(); 3663 } 3664 } 3665}; 3666 3667void ClassLinker::MoveClassTableToPreZygote() { 3668 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 3669 boot_class_table_.FreezeSnapshot(); 3670 MoveClassTableToPreZygoteVisitor visitor; 3671 VisitClassLoaders(&visitor); 3672} 3673 3674mirror::Class* ClassLinker::LookupClassFromBootImage(const char* descriptor) { 3675 ScopedAssertNoThreadSuspension ants(Thread::Current(), "Image class lookup"); 3676 std::vector<mirror::ObjectArray<mirror::DexCache>*> dex_caches_vector = 3677 GetImageDexCaches(Runtime::Current()->GetHeap()->GetBootImageSpaces()); 3678 for (mirror::ObjectArray<mirror::DexCache>* dex_caches : dex_caches_vector) { 3679 for (int32_t i = 0; i < dex_caches->GetLength(); ++i) { 3680 mirror::DexCache* dex_cache = dex_caches->Get(i); 3681 const DexFile* dex_file = dex_cache->GetDexFile(); 3682 // Try binary searching the type index by descriptor. 3683 const DexFile::TypeId* type_id = dex_file->FindTypeId(descriptor); 3684 if (type_id != nullptr) { 3685 uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id); 3686 mirror::Class* klass = dex_cache->GetResolvedType(type_idx); 3687 if (klass != nullptr) { 3688 return klass; 3689 } 3690 } 3691 } 3692 } 3693 return nullptr; 3694} 3695 3696// Look up classes by hash and descriptor and put all matching ones in the result array. 3697class LookupClassesVisitor : public ClassLoaderVisitor { 3698 public: 3699 LookupClassesVisitor(const char* descriptor, size_t hash, std::vector<mirror::Class*>* result) 3700 : descriptor_(descriptor), 3701 hash_(hash), 3702 result_(result) {} 3703 3704 void Visit(mirror::ClassLoader* class_loader) 3705 SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE { 3706 ClassTable* const class_table = class_loader->GetClassTable(); 3707 mirror::Class* klass = class_table->Lookup(descriptor_, hash_); 3708 if (klass != nullptr) { 3709 result_->push_back(klass); 3710 } 3711 } 3712 3713 private: 3714 const char* const descriptor_; 3715 const size_t hash_; 3716 std::vector<mirror::Class*>* const result_; 3717}; 3718 3719void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) { 3720 result.clear(); 3721 if (dex_cache_boot_image_class_lookup_required_) { 3722 AddBootImageClassesToClassTable(); 3723 } 3724 Thread* const self = Thread::Current(); 3725 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 3726 const size_t hash = ComputeModifiedUtf8Hash(descriptor); 3727 mirror::Class* klass = boot_class_table_.Lookup(descriptor, hash); 3728 if (klass != nullptr) { 3729 result.push_back(klass); 3730 } 3731 LookupClassesVisitor visitor(descriptor, hash, &result); 3732 VisitClassLoaders(&visitor); 3733} 3734 3735bool ClassLinker::AttemptSupertypeVerification(Thread* self, 3736 Handle<mirror::Class> klass, 3737 Handle<mirror::Class> supertype) { 3738 DCHECK(self != nullptr); 3739 DCHECK(klass.Get() != nullptr); 3740 DCHECK(supertype.Get() != nullptr); 3741 3742 if (!supertype->IsVerified() && !supertype->IsErroneous()) { 3743 VerifyClass(self, supertype); 3744 } 3745 if (supertype->IsCompileTimeVerified()) { 3746 // Either we are verified or we soft failed and need to retry at runtime. 3747 return true; 3748 } 3749 // If we got this far then we have a hard failure. 3750 std::string error_msg = 3751 StringPrintf("Rejecting class %s that attempts to sub-type erroneous class %s", 3752 PrettyDescriptor(klass.Get()).c_str(), 3753 PrettyDescriptor(supertype.Get()).c_str()); 3754 LOG(WARNING) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8(); 3755 StackHandleScope<1> hs(self); 3756 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException())); 3757 if (cause.Get() != nullptr) { 3758 // Set during VerifyClass call (if at all). 3759 self->ClearException(); 3760 } 3761 // Change into a verify error. 3762 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str()); 3763 if (cause.Get() != nullptr) { 3764 self->GetException()->SetCause(cause.Get()); 3765 } 3766 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex()); 3767 if (Runtime::Current()->IsAotCompiler()) { 3768 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref); 3769 } 3770 // Need to grab the lock to change status. 3771 ObjectLock<mirror::Class> super_lock(self, klass); 3772 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3773 return false; 3774} 3775 3776void ClassLinker::VerifyClass(Thread* self, Handle<mirror::Class> klass, LogSeverity log_level) { 3777 { 3778 // TODO: assert that the monitor on the Class is held 3779 ObjectLock<mirror::Class> lock(self, klass); 3780 3781 // Is somebody verifying this now? 3782 mirror::Class::Status old_status = klass->GetStatus(); 3783 while (old_status == mirror::Class::kStatusVerifying || 3784 old_status == mirror::Class::kStatusVerifyingAtRuntime) { 3785 lock.WaitIgnoringInterrupts(); 3786 CHECK(klass->IsErroneous() || (klass->GetStatus() > old_status)) 3787 << "Class '" << PrettyClass(klass.Get()) << "' performed an illegal verification state " 3788 << "transition from " << old_status << " to " << klass->GetStatus(); 3789 old_status = klass->GetStatus(); 3790 } 3791 3792 // The class might already be erroneous, for example at compile time if we attempted to verify 3793 // this class as a parent to another. 3794 if (klass->IsErroneous()) { 3795 ThrowEarlierClassFailure(klass.Get()); 3796 return; 3797 } 3798 3799 // Don't attempt to re-verify if already sufficiently verified. 3800 if (klass->IsVerified()) { 3801 EnsureSkipAccessChecksMethods(klass); 3802 return; 3803 } 3804 if (klass->IsCompileTimeVerified() && Runtime::Current()->IsAotCompiler()) { 3805 return; 3806 } 3807 3808 if (klass->GetStatus() == mirror::Class::kStatusResolved) { 3809 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifying, self); 3810 } else { 3811 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime) 3812 << PrettyClass(klass.Get()); 3813 CHECK(!Runtime::Current()->IsAotCompiler()); 3814 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifyingAtRuntime, self); 3815 } 3816 3817 // Skip verification if disabled. 3818 if (!Runtime::Current()->IsVerificationEnabled()) { 3819 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self); 3820 EnsureSkipAccessChecksMethods(klass); 3821 return; 3822 } 3823 } 3824 3825 // Verify super class. 3826 StackHandleScope<2> hs(self); 3827 MutableHandle<mirror::Class> supertype(hs.NewHandle(klass->GetSuperClass())); 3828 // If we have a superclass and we get a hard verification failure we can return immediately. 3829 if (supertype.Get() != nullptr && !AttemptSupertypeVerification(self, klass, supertype)) { 3830 CHECK(self->IsExceptionPending()) << "Verification error should be pending."; 3831 return; 3832 } 3833 3834 // Verify all default super-interfaces. 3835 // 3836 // (1) Don't bother if the superclass has already had a soft verification failure. 3837 // 3838 // (2) Interfaces shouldn't bother to do this recursive verification because they cannot cause 3839 // recursive initialization by themselves. This is because when an interface is initialized 3840 // directly it must not initialize its superinterfaces. We are allowed to verify regardless 3841 // but choose not to for an optimization. If the interfaces is being verified due to a class 3842 // initialization (which would need all the default interfaces to be verified) the class code 3843 // will trigger the recursive verification anyway. 3844 if ((supertype.Get() == nullptr || supertype->IsVerified()) // See (1) 3845 && !klass->IsInterface()) { // See (2) 3846 int32_t iftable_count = klass->GetIfTableCount(); 3847 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr)); 3848 // Loop through all interfaces this class has defined. It doesn't matter the order. 3849 for (int32_t i = 0; i < iftable_count; i++) { 3850 iface.Assign(klass->GetIfTable()->GetInterface(i)); 3851 DCHECK(iface.Get() != nullptr); 3852 // We only care if we have default interfaces and can skip if we are already verified... 3853 if (LIKELY(!iface->HasDefaultMethods() || iface->IsVerified())) { 3854 continue; 3855 } else if (UNLIKELY(!AttemptSupertypeVerification(self, klass, iface))) { 3856 // We had a hard failure while verifying this interface. Just return immediately. 3857 CHECK(self->IsExceptionPending()) << "Verification error should be pending."; 3858 return; 3859 } else if (UNLIKELY(!iface->IsVerified())) { 3860 // We softly failed to verify the iface. Stop checking and clean up. 3861 // Put the iface into the supertype handle so we know what caused us to fail. 3862 supertype.Assign(iface.Get()); 3863 break; 3864 } 3865 } 3866 } 3867 3868 // At this point if verification failed, then supertype is the "first" supertype that failed 3869 // verification (without a specific order). If verification succeeded, then supertype is either 3870 // null or the original superclass of klass and is verified. 3871 DCHECK(supertype.Get() == nullptr || 3872 supertype.Get() == klass->GetSuperClass() || 3873 !supertype->IsVerified()); 3874 3875 // Try to use verification information from the oat file, otherwise do runtime verification. 3876 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile(); 3877 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady); 3878 bool preverified = VerifyClassUsingOatFile(dex_file, klass.Get(), oat_file_class_status); 3879 // If the oat file says the class had an error, re-run the verifier. That way we will get a 3880 // precise error message. To ensure a rerun, test: 3881 // oat_file_class_status == mirror::Class::kStatusError => !preverified 3882 DCHECK(!(oat_file_class_status == mirror::Class::kStatusError) || !preverified); 3883 3884 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure; 3885 std::string error_msg; 3886 if (!preverified) { 3887 Runtime* runtime = Runtime::Current(); 3888 verifier_failure = verifier::MethodVerifier::VerifyClass(self, 3889 klass.Get(), 3890 runtime->GetCompilerCallbacks(), 3891 runtime->IsAotCompiler(), 3892 log_level, 3893 &error_msg); 3894 } 3895 3896 // Verification is done, grab the lock again. 3897 ObjectLock<mirror::Class> lock(self, klass); 3898 3899 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) { 3900 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) { 3901 VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass.Get()) 3902 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8() 3903 << " because: " << error_msg; 3904 } 3905 self->AssertNoPendingException(); 3906 // Make sure all classes referenced by catch blocks are resolved. 3907 ResolveClassExceptionHandlerTypes(klass); 3908 if (verifier_failure == verifier::MethodVerifier::kNoFailure) { 3909 // Even though there were no verifier failures we need to respect whether the super-class and 3910 // super-default-interfaces were verified or requiring runtime reverification. 3911 if (supertype.Get() == nullptr || supertype->IsVerified()) { 3912 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self); 3913 } else { 3914 CHECK_EQ(supertype->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 3915 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self); 3916 // Pretend a soft failure occurred so that we don't consider the class verified below. 3917 verifier_failure = verifier::MethodVerifier::kSoftFailure; 3918 } 3919 } else { 3920 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure); 3921 // Soft failures at compile time should be retried at runtime. Soft 3922 // failures at runtime will be handled by slow paths in the generated 3923 // code. Set status accordingly. 3924 if (Runtime::Current()->IsAotCompiler()) { 3925 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self); 3926 } else { 3927 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self); 3928 // As this is a fake verified status, make sure the methods are _not_ marked 3929 // kAccSkipAccessChecks later. 3930 klass->SetVerificationAttempted(); 3931 } 3932 } 3933 } else { 3934 VLOG(verifier) << "Verification failed on class " << PrettyDescriptor(klass.Get()) 3935 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8() 3936 << " because: " << error_msg; 3937 self->AssertNoPendingException(); 3938 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str()); 3939 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3940 } 3941 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) { 3942 // Class is verified so we don't need to do any access check on its methods. 3943 // Let the interpreter know it by setting the kAccSkipAccessChecks flag onto each 3944 // method. 3945 // Note: we're going here during compilation and at runtime. When we set the 3946 // kAccSkipAccessChecks flag when compiling image classes, the flag is recorded 3947 // in the image and is set when loading the image. 3948 3949 if (UNLIKELY(Runtime::Current()->IsVerificationSoftFail())) { 3950 // Never skip access checks if the verification soft fail is forced. 3951 // Mark the class as having a verification attempt to avoid re-running the verifier. 3952 klass->SetVerificationAttempted(); 3953 } else { 3954 EnsureSkipAccessChecksMethods(klass); 3955 } 3956 } 3957} 3958 3959void ClassLinker::EnsureSkipAccessChecksMethods(Handle<mirror::Class> klass) { 3960 if (!klass->WasVerificationAttempted()) { 3961 klass->SetSkipAccessChecksFlagOnAllMethods(image_pointer_size_); 3962 klass->SetVerificationAttempted(); 3963 } 3964} 3965 3966bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, 3967 mirror::Class* klass, 3968 mirror::Class::Status& oat_file_class_status) { 3969 // If we're compiling, we can only verify the class using the oat file if 3970 // we are not compiling the image or if the class we're verifying is not part of 3971 // the app. In other words, we will only check for preverification of bootclasspath 3972 // classes. 3973 if (Runtime::Current()->IsAotCompiler()) { 3974 // Are we compiling the bootclasspath? 3975 if (Runtime::Current()->GetCompilerCallbacks()->IsBootImage()) { 3976 return false; 3977 } 3978 // We are compiling an app (not the image). 3979 3980 // Is this an app class? (I.e. not a bootclasspath class) 3981 if (klass->GetClassLoader() != nullptr) { 3982 return false; 3983 } 3984 } 3985 3986 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 3987 // In case we run without an image there won't be a backing oat file. 3988 if (oat_dex_file == nullptr) { 3989 return false; 3990 } 3991 3992 // We may be running with a preopted oat file but without image. In this case, 3993 // we don't skip verification of skip_access_checks classes to ensure we initialize 3994 // dex caches with all types resolved during verification. 3995 // We need to trust image classes, as these might be coming out of a pre-opted, quickened boot 3996 // image (that we just failed loading), and the verifier can't be run on quickened opcodes when 3997 // the runtime isn't started. On the other hand, app classes can be re-verified even if they are 3998 // already pre-opted, as then the runtime is started. 3999 if (!Runtime::Current()->IsAotCompiler() && 4000 !Runtime::Current()->GetHeap()->HasBootImageSpace() && 4001 klass->GetClassLoader() != nullptr) { 4002 return false; 4003 } 4004 4005 uint16_t class_def_index = klass->GetDexClassDefIndex(); 4006 oat_file_class_status = oat_dex_file->GetOatClass(class_def_index).GetStatus(); 4007 if (oat_file_class_status == mirror::Class::kStatusVerified || 4008 oat_file_class_status == mirror::Class::kStatusInitialized) { 4009 return true; 4010 } 4011 // If we only verified a subset of the classes at compile time, we can end up with classes that 4012 // were resolved by the verifier. 4013 if (oat_file_class_status == mirror::Class::kStatusResolved) { 4014 return false; 4015 } 4016 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) { 4017 // Compile time verification failed with a soft error. Compile time verification can fail 4018 // because we have incomplete type information. Consider the following: 4019 // class ... { 4020 // Foo x; 4021 // .... () { 4022 // if (...) { 4023 // v1 gets assigned a type of resolved class Foo 4024 // } else { 4025 // v1 gets assigned a type of unresolved class Bar 4026 // } 4027 // iput x = v1 4028 // } } 4029 // when we merge v1 following the if-the-else it results in Conflict 4030 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be 4031 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as 4032 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk 4033 // at compile time). 4034 return false; 4035 } 4036 if (oat_file_class_status == mirror::Class::kStatusError) { 4037 // Compile time verification failed with a hard error. This is caused by invalid instructions 4038 // in the class. These errors are unrecoverable. 4039 return false; 4040 } 4041 if (oat_file_class_status == mirror::Class::kStatusNotReady) { 4042 // Status is uninitialized if we couldn't determine the status at compile time, for example, 4043 // not loading the class. 4044 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy 4045 // isn't a problem and this case shouldn't occur 4046 return false; 4047 } 4048 std::string temp; 4049 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status 4050 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " 4051 << klass->GetDescriptor(&temp); 4052 UNREACHABLE(); 4053} 4054 4055void ClassLinker::ResolveClassExceptionHandlerTypes(Handle<mirror::Class> klass) { 4056 for (ArtMethod& method : klass->GetMethods(image_pointer_size_)) { 4057 ResolveMethodExceptionHandlerTypes(&method); 4058 } 4059} 4060 4061void ClassLinker::ResolveMethodExceptionHandlerTypes(ArtMethod* method) { 4062 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod. 4063 const DexFile::CodeItem* code_item = 4064 method->GetDexFile()->GetCodeItem(method->GetCodeItemOffset()); 4065 if (code_item == nullptr) { 4066 return; // native or abstract method 4067 } 4068 if (code_item->tries_size_ == 0) { 4069 return; // nothing to process 4070 } 4071 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0); 4072 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr); 4073 for (uint32_t idx = 0; idx < handlers_size; idx++) { 4074 CatchHandlerIterator iterator(handlers_ptr); 4075 for (; iterator.HasNext(); iterator.Next()) { 4076 // Ensure exception types are resolved so that they don't need resolution to be delivered, 4077 // unresolved exception types will be ignored by exception delivery 4078 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) { 4079 mirror::Class* exception_type = ResolveType(iterator.GetHandlerTypeIndex(), method); 4080 if (exception_type == nullptr) { 4081 DCHECK(Thread::Current()->IsExceptionPending()); 4082 Thread::Current()->ClearException(); 4083 } 4084 } 4085 } 4086 handlers_ptr = iterator.EndDataPointer(); 4087 } 4088} 4089 4090mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, 4091 jstring name, 4092 jobjectArray interfaces, 4093 jobject loader, 4094 jobjectArray methods, 4095 jobjectArray throws) { 4096 Thread* self = soa.Self(); 4097 StackHandleScope<10> hs(self); 4098 MutableHandle<mirror::Class> klass(hs.NewHandle( 4099 AllocClass(self, GetClassRoot(kJavaLangClass), sizeof(mirror::Class)))); 4100 if (klass.Get() == nullptr) { 4101 CHECK(self->IsExceptionPending()); // OOME. 4102 return nullptr; 4103 } 4104 DCHECK(klass->GetClass() != nullptr); 4105 klass->SetObjectSize(sizeof(mirror::Proxy)); 4106 // Set the class access flags incl. VerificationAttempted, so we do not try to set the flag on 4107 // the methods. 4108 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal | kAccVerificationAttempted); 4109 klass->SetClassLoader(soa.Decode<mirror::ClassLoader*>(loader)); 4110 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot); 4111 klass->SetName(soa.Decode<mirror::String*>(name)); 4112 klass->SetDexCache(GetClassRoot(kJavaLangReflectProxy)->GetDexCache()); 4113 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, self); 4114 std::string descriptor(GetDescriptorForProxy(klass.Get())); 4115 const size_t hash = ComputeModifiedUtf8Hash(descriptor.c_str()); 4116 4117 // Needs to be before we insert the class so that the allocator field is set. 4118 LinearAlloc* const allocator = GetOrCreateAllocatorForClassLoader(klass->GetClassLoader()); 4119 4120 // Insert the class before loading the fields as the field roots 4121 // (ArtField::declaring_class_) are only visited from the class 4122 // table. There can't be any suspend points between inserting the 4123 // class and setting the field arrays below. 4124 mirror::Class* existing = InsertClass(descriptor.c_str(), klass.Get(), hash); 4125 CHECK(existing == nullptr); 4126 4127 // Instance fields are inherited, but we add a couple of static fields... 4128 const size_t num_fields = 2; 4129 LengthPrefixedArray<ArtField>* sfields = AllocArtFieldArray(self, allocator, num_fields); 4130 klass->SetSFieldsPtr(sfields); 4131 4132 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by 4133 // our proxy, so Class.getInterfaces doesn't return the flattened set. 4134 ArtField& interfaces_sfield = sfields->At(0); 4135 interfaces_sfield.SetDexFieldIndex(0); 4136 interfaces_sfield.SetDeclaringClass(klass.Get()); 4137 interfaces_sfield.SetAccessFlags(kAccStatic | kAccPublic | kAccFinal); 4138 4139 // 2. Create a static field 'throws' that holds exceptions thrown by our methods. 4140 ArtField& throws_sfield = sfields->At(1); 4141 throws_sfield.SetDexFieldIndex(1); 4142 throws_sfield.SetDeclaringClass(klass.Get()); 4143 throws_sfield.SetAccessFlags(kAccStatic | kAccPublic | kAccFinal); 4144 4145 // Proxies have 1 direct method, the constructor 4146 const size_t num_direct_methods = 1; 4147 4148 // They have as many virtual methods as the array 4149 auto h_methods = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Method>*>(methods)); 4150 DCHECK_EQ(h_methods->GetClass(), mirror::Method::ArrayClass()) 4151 << PrettyClass(h_methods->GetClass()); 4152 const size_t num_virtual_methods = h_methods->GetLength(); 4153 4154 // Create the methods array. 4155 LengthPrefixedArray<ArtMethod>* proxy_class_methods = AllocArtMethodArray( 4156 self, allocator, num_direct_methods + num_virtual_methods); 4157 // Currently AllocArtMethodArray cannot return null, but the OOM logic is left there in case we 4158 // want to throw OOM in the future. 4159 if (UNLIKELY(proxy_class_methods == nullptr)) { 4160 self->AssertPendingOOMException(); 4161 return nullptr; 4162 } 4163 klass->SetMethodsPtr(proxy_class_methods, num_direct_methods, num_virtual_methods); 4164 4165 // Create the single direct method. 4166 CreateProxyConstructor(klass, klass->GetDirectMethodUnchecked(0, image_pointer_size_)); 4167 4168 // Create virtual method using specified prototypes. 4169 // TODO These should really use the iterators. 4170 for (size_t i = 0; i < num_virtual_methods; ++i) { 4171 auto* virtual_method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_); 4172 auto* prototype = h_methods->Get(i)->GetArtMethod(); 4173 CreateProxyMethod(klass, prototype, virtual_method); 4174 DCHECK(virtual_method->GetDeclaringClass() != nullptr); 4175 DCHECK(prototype->GetDeclaringClass() != nullptr); 4176 } 4177 4178 // The super class is java.lang.reflect.Proxy 4179 klass->SetSuperClass(GetClassRoot(kJavaLangReflectProxy)); 4180 // Now effectively in the loaded state. 4181 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, self); 4182 self->AssertNoPendingException(); 4183 4184 MutableHandle<mirror::Class> new_class = hs.NewHandle<mirror::Class>(nullptr); 4185 { 4186 // Must hold lock on object when resolved. 4187 ObjectLock<mirror::Class> resolution_lock(self, klass); 4188 // Link the fields and virtual methods, creating vtable and iftables. 4189 // The new class will replace the old one in the class table. 4190 Handle<mirror::ObjectArray<mirror::Class>> h_interfaces( 4191 hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces))); 4192 if (!LinkClass(self, descriptor.c_str(), klass, h_interfaces, &new_class)) { 4193 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4194 return nullptr; 4195 } 4196 } 4197 CHECK(klass->IsRetired()); 4198 CHECK_NE(klass.Get(), new_class.Get()); 4199 klass.Assign(new_class.Get()); 4200 4201 CHECK_EQ(interfaces_sfield.GetDeclaringClass(), klass.Get()); 4202 interfaces_sfield.SetObject<false>(klass.Get(), 4203 soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces)); 4204 CHECK_EQ(throws_sfield.GetDeclaringClass(), klass.Get()); 4205 throws_sfield.SetObject<false>( 4206 klass.Get(), soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws)); 4207 4208 { 4209 // Lock on klass is released. Lock new class object. 4210 ObjectLock<mirror::Class> initialization_lock(self, klass); 4211 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self); 4212 } 4213 4214 // sanity checks 4215 if (kIsDebugBuild) { 4216 CHECK(klass->GetIFieldsPtr() == nullptr); 4217 CheckProxyConstructor(klass->GetDirectMethod(0, image_pointer_size_)); 4218 4219 for (size_t i = 0; i < num_virtual_methods; ++i) { 4220 auto* virtual_method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_); 4221 auto* prototype = h_methods->Get(i++)->GetArtMethod(); 4222 CheckProxyMethod(virtual_method, prototype); 4223 } 4224 4225 StackHandleScope<1> hs2(self); 4226 Handle<mirror::String> decoded_name = hs2.NewHandle(soa.Decode<mirror::String*>(name)); 4227 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces", 4228 decoded_name->ToModifiedUtf8().c_str())); 4229 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name); 4230 4231 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws", 4232 decoded_name->ToModifiedUtf8().c_str())); 4233 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name); 4234 4235 CHECK_EQ(klass.Get()->GetInterfaces(), 4236 soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces)); 4237 CHECK_EQ(klass.Get()->GetThrows(), 4238 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>*>(throws)); 4239 } 4240 return klass.Get(); 4241} 4242 4243std::string ClassLinker::GetDescriptorForProxy(mirror::Class* proxy_class) { 4244 DCHECK(proxy_class->IsProxyClass()); 4245 mirror::String* name = proxy_class->GetName(); 4246 DCHECK(name != nullptr); 4247 return DotToDescriptor(name->ToModifiedUtf8().c_str()); 4248} 4249 4250ArtMethod* ClassLinker::FindMethodForProxy(mirror::Class* proxy_class, ArtMethod* proxy_method) { 4251 DCHECK(proxy_class->IsProxyClass()); 4252 DCHECK(proxy_method->IsProxyMethod()); 4253 { 4254 Thread* const self = Thread::Current(); 4255 ReaderMutexLock mu(self, dex_lock_); 4256 // Locate the dex cache of the original interface/Object 4257 for (const DexCacheData& data : dex_caches_) { 4258 if (!self->IsJWeakCleared(data.weak_root) && 4259 proxy_method->HasSameDexCacheResolvedTypes(data.resolved_types, 4260 image_pointer_size_)) { 4261 mirror::DexCache* dex_cache = down_cast<mirror::DexCache*>( 4262 self->DecodeJObject(data.weak_root)); 4263 if (dex_cache != nullptr) { 4264 ArtMethod* resolved_method = dex_cache->GetResolvedMethod( 4265 proxy_method->GetDexMethodIndex(), image_pointer_size_); 4266 CHECK(resolved_method != nullptr); 4267 return resolved_method; 4268 } 4269 } 4270 } 4271 } 4272 LOG(FATAL) << "Didn't find dex cache for " << PrettyClass(proxy_class) << " " 4273 << PrettyMethod(proxy_method); 4274 UNREACHABLE(); 4275} 4276 4277void ClassLinker::CreateProxyConstructor(Handle<mirror::Class> klass, ArtMethod* out) { 4278 // Create constructor for Proxy that must initialize the method. 4279 CHECK_EQ(GetClassRoot(kJavaLangReflectProxy)->NumDirectMethods(), 18u); 4280 ArtMethod* proxy_constructor = GetClassRoot(kJavaLangReflectProxy)->GetDirectMethodUnchecked( 4281 2, image_pointer_size_); 4282 DCHECK_EQ(std::string(proxy_constructor->GetName()), "<init>"); 4283 // Ensure constructor is in dex cache so that we can use the dex cache to look up the overridden 4284 // constructor method. 4285 GetClassRoot(kJavaLangReflectProxy)->GetDexCache()->SetResolvedMethod( 4286 proxy_constructor->GetDexMethodIndex(), proxy_constructor, image_pointer_size_); 4287 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its 4288 // code_ too) 4289 DCHECK(out != nullptr); 4290 out->CopyFrom(proxy_constructor, image_pointer_size_); 4291 // Make this constructor public and fix the class to be our Proxy version 4292 out->SetAccessFlags((out->GetAccessFlags() & ~kAccProtected) | kAccPublic); 4293 out->SetDeclaringClass(klass.Get()); 4294} 4295 4296void ClassLinker::CheckProxyConstructor(ArtMethod* constructor) const { 4297 CHECK(constructor->IsConstructor()); 4298 auto* np = constructor->GetInterfaceMethodIfProxy(image_pointer_size_); 4299 CHECK_STREQ(np->GetName(), "<init>"); 4300 CHECK_STREQ(np->GetSignature().ToString().c_str(), "(Ljava/lang/reflect/InvocationHandler;)V"); 4301 DCHECK(constructor->IsPublic()); 4302} 4303 4304void ClassLinker::CreateProxyMethod(Handle<mirror::Class> klass, ArtMethod* prototype, 4305 ArtMethod* out) { 4306 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden 4307 // prototype method 4308 auto* dex_cache = prototype->GetDeclaringClass()->GetDexCache(); 4309 // Avoid dirtying the dex cache unless we need to. 4310 if (dex_cache->GetResolvedMethod(prototype->GetDexMethodIndex(), image_pointer_size_) != 4311 prototype) { 4312 dex_cache->SetResolvedMethod( 4313 prototype->GetDexMethodIndex(), prototype, image_pointer_size_); 4314 } 4315 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize 4316 // as necessary 4317 DCHECK(out != nullptr); 4318 out->CopyFrom(prototype, image_pointer_size_); 4319 4320 // Set class to be the concrete proxy class. 4321 out->SetDeclaringClass(klass.Get()); 4322 // Clear the abstract, default and conflict flags to ensure that defaults aren't picked in 4323 // preference to the invocation handler. 4324 const uint32_t kRemoveFlags = kAccAbstract | kAccDefault | kAccDefaultConflict; 4325 // Make the method final. 4326 const uint32_t kAddFlags = kAccFinal; 4327 out->SetAccessFlags((out->GetAccessFlags() & ~kRemoveFlags) | kAddFlags); 4328 4329 // Clear the dex_code_item_offset_. It needs to be 0 since proxy methods have no CodeItems but the 4330 // method they copy might (if it's a default method). 4331 out->SetCodeItemOffset(0); 4332 4333 // At runtime the method looks like a reference and argument saving method, clone the code 4334 // related parameters from this method. 4335 out->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler()); 4336} 4337 4338void ClassLinker::CheckProxyMethod(ArtMethod* method, ArtMethod* prototype) const { 4339 // Basic sanity 4340 CHECK(!prototype->IsFinal()); 4341 CHECK(method->IsFinal()); 4342 CHECK(method->IsInvokable()); 4343 4344 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its 4345 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself. 4346 CHECK(prototype->HasSameDexCacheResolvedMethods(method, image_pointer_size_)); 4347 CHECK(prototype->HasSameDexCacheResolvedTypes(method, image_pointer_size_)); 4348 auto* np = method->GetInterfaceMethodIfProxy(image_pointer_size_); 4349 CHECK_EQ(prototype->GetDeclaringClass()->GetDexCache(), np->GetDexCache()); 4350 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex()); 4351 4352 CHECK_STREQ(np->GetName(), prototype->GetName()); 4353 CHECK_STREQ(np->GetShorty(), prototype->GetShorty()); 4354 // More complex sanity - via dex cache 4355 CHECK_EQ(np->GetReturnType(true /* resolve */, image_pointer_size_), 4356 prototype->GetReturnType(true /* resolve */, image_pointer_size_)); 4357} 4358 4359bool ClassLinker::CanWeInitializeClass(mirror::Class* klass, bool can_init_statics, 4360 bool can_init_parents) { 4361 if (can_init_statics && can_init_parents) { 4362 return true; 4363 } 4364 if (!can_init_statics) { 4365 // Check if there's a class initializer. 4366 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_); 4367 if (clinit != nullptr) { 4368 return false; 4369 } 4370 // Check if there are encoded static values needing initialization. 4371 if (klass->NumStaticFields() != 0) { 4372 const DexFile::ClassDef* dex_class_def = klass->GetClassDef(); 4373 DCHECK(dex_class_def != nullptr); 4374 if (dex_class_def->static_values_off_ != 0) { 4375 return false; 4376 } 4377 } 4378 // If we are a class we need to initialize all interfaces with default methods when we are 4379 // initialized. Check all of them. 4380 if (!klass->IsInterface()) { 4381 size_t num_interfaces = klass->GetIfTableCount(); 4382 for (size_t i = 0; i < num_interfaces; i++) { 4383 mirror::Class* iface = klass->GetIfTable()->GetInterface(i); 4384 if (iface->HasDefaultMethods() && 4385 !CanWeInitializeClass(iface, can_init_statics, can_init_parents)) { 4386 return false; 4387 } 4388 } 4389 } 4390 } 4391 if (klass->IsInterface() || !klass->HasSuperClass()) { 4392 return true; 4393 } 4394 mirror::Class* super_class = klass->GetSuperClass(); 4395 if (!can_init_parents && !super_class->IsInitialized()) { 4396 return false; 4397 } 4398 return CanWeInitializeClass(super_class, can_init_statics, can_init_parents); 4399} 4400 4401bool ClassLinker::InitializeClass(Thread* self, Handle<mirror::Class> klass, 4402 bool can_init_statics, bool can_init_parents) { 4403 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol 4404 4405 // Are we already initialized and therefore done? 4406 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as 4407 // an initialized class will never change its state. 4408 if (klass->IsInitialized()) { 4409 return true; 4410 } 4411 4412 // Fast fail if initialization requires a full runtime. Not part of the JLS. 4413 if (!CanWeInitializeClass(klass.Get(), can_init_statics, can_init_parents)) { 4414 return false; 4415 } 4416 4417 self->AllowThreadSuspension(); 4418 uint64_t t0; 4419 { 4420 ObjectLock<mirror::Class> lock(self, klass); 4421 4422 // Re-check under the lock in case another thread initialized ahead of us. 4423 if (klass->IsInitialized()) { 4424 return true; 4425 } 4426 4427 // Was the class already found to be erroneous? Done under the lock to match the JLS. 4428 if (klass->IsErroneous()) { 4429 ThrowEarlierClassFailure(klass.Get(), true); 4430 VlogClassInitializationFailure(klass); 4431 return false; 4432 } 4433 4434 CHECK(klass->IsResolved()) << PrettyClass(klass.Get()) << ": state=" << klass->GetStatus(); 4435 4436 if (!klass->IsVerified()) { 4437 VerifyClass(self, klass); 4438 if (!klass->IsVerified()) { 4439 // We failed to verify, expect either the klass to be erroneous or verification failed at 4440 // compile time. 4441 if (klass->IsErroneous()) { 4442 // The class is erroneous. This may be a verifier error, or another thread attempted 4443 // verification and/or initialization and failed. We can distinguish those cases by 4444 // whether an exception is already pending. 4445 if (self->IsExceptionPending()) { 4446 // Check that it's a VerifyError. 4447 DCHECK_EQ("java.lang.Class<java.lang.VerifyError>", 4448 PrettyClass(self->GetException()->GetClass())); 4449 } else { 4450 // Check that another thread attempted initialization. 4451 DCHECK_NE(0, klass->GetClinitThreadId()); 4452 DCHECK_NE(self->GetTid(), klass->GetClinitThreadId()); 4453 // Need to rethrow the previous failure now. 4454 ThrowEarlierClassFailure(klass.Get(), true); 4455 } 4456 VlogClassInitializationFailure(klass); 4457 } else { 4458 CHECK(Runtime::Current()->IsAotCompiler()); 4459 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 4460 } 4461 return false; 4462 } else { 4463 self->AssertNoPendingException(); 4464 } 4465 4466 // A separate thread could have moved us all the way to initialized. A "simple" example 4467 // involves a subclass of the current class being initialized at the same time (which 4468 // will implicitly initialize the superclass, if scheduled that way). b/28254258 4469 DCHECK_NE(mirror::Class::kStatusError, klass->GetStatus()); 4470 if (klass->IsInitialized()) { 4471 return true; 4472 } 4473 } 4474 4475 // If the class is kStatusInitializing, either this thread is 4476 // initializing higher up the stack or another thread has beat us 4477 // to initializing and we need to wait. Either way, this 4478 // invocation of InitializeClass will not be responsible for 4479 // running <clinit> and will return. 4480 if (klass->GetStatus() == mirror::Class::kStatusInitializing) { 4481 // Could have got an exception during verification. 4482 if (self->IsExceptionPending()) { 4483 VlogClassInitializationFailure(klass); 4484 return false; 4485 } 4486 // We caught somebody else in the act; was it us? 4487 if (klass->GetClinitThreadId() == self->GetTid()) { 4488 // Yes. That's fine. Return so we can continue initializing. 4489 return true; 4490 } 4491 // No. That's fine. Wait for another thread to finish initializing. 4492 return WaitForInitializeClass(klass, self, lock); 4493 } 4494 4495 if (!ValidateSuperClassDescriptors(klass)) { 4496 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4497 return false; 4498 } 4499 self->AllowThreadSuspension(); 4500 4501 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass.Get()) 4502 << " self.tid=" << self->GetTid() << " clinit.tid=" << klass->GetClinitThreadId(); 4503 4504 // From here out other threads may observe that we're initializing and so changes of state 4505 // require the a notification. 4506 klass->SetClinitThreadId(self->GetTid()); 4507 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitializing, self); 4508 4509 t0 = NanoTime(); 4510 } 4511 4512 // Initialize super classes, must be done while initializing for the JLS. 4513 if (!klass->IsInterface() && klass->HasSuperClass()) { 4514 mirror::Class* super_class = klass->GetSuperClass(); 4515 if (!super_class->IsInitialized()) { 4516 CHECK(!super_class->IsInterface()); 4517 CHECK(can_init_parents); 4518 StackHandleScope<1> hs(self); 4519 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class)); 4520 bool super_initialized = InitializeClass(self, handle_scope_super, can_init_statics, true); 4521 if (!super_initialized) { 4522 // The super class was verified ahead of entering initializing, we should only be here if 4523 // the super class became erroneous due to initialization. 4524 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending()) 4525 << "Super class initialization failed for " 4526 << PrettyDescriptor(handle_scope_super.Get()) 4527 << " that has unexpected status " << handle_scope_super->GetStatus() 4528 << "\nPending exception:\n" 4529 << (self->GetException() != nullptr ? self->GetException()->Dump() : ""); 4530 ObjectLock<mirror::Class> lock(self, klass); 4531 // Initialization failed because the super-class is erroneous. 4532 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4533 return false; 4534 } 4535 } 4536 } 4537 4538 if (!klass->IsInterface()) { 4539 // Initialize interfaces with default methods for the JLS. 4540 size_t num_direct_interfaces = klass->NumDirectInterfaces(); 4541 // Only setup the (expensive) handle scope if we actually need to. 4542 if (UNLIKELY(num_direct_interfaces > 0)) { 4543 StackHandleScope<1> hs_iface(self); 4544 MutableHandle<mirror::Class> handle_scope_iface(hs_iface.NewHandle<mirror::Class>(nullptr)); 4545 for (size_t i = 0; i < num_direct_interfaces; i++) { 4546 handle_scope_iface.Assign(mirror::Class::GetDirectInterface(self, klass, i)); 4547 CHECK(handle_scope_iface.Get() != nullptr); 4548 CHECK(handle_scope_iface->IsInterface()); 4549 if (handle_scope_iface->HasBeenRecursivelyInitialized()) { 4550 // We have already done this for this interface. Skip it. 4551 continue; 4552 } 4553 // We cannot just call initialize class directly because we need to ensure that ALL 4554 // interfaces with default methods are initialized. Non-default interface initialization 4555 // will not affect other non-default super-interfaces. 4556 bool iface_initialized = InitializeDefaultInterfaceRecursive(self, 4557 handle_scope_iface, 4558 can_init_statics, 4559 can_init_parents); 4560 if (!iface_initialized) { 4561 ObjectLock<mirror::Class> lock(self, klass); 4562 // Initialization failed because one of our interfaces with default methods is erroneous. 4563 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4564 return false; 4565 } 4566 } 4567 } 4568 } 4569 4570 const size_t num_static_fields = klass->NumStaticFields(); 4571 if (num_static_fields > 0) { 4572 const DexFile::ClassDef* dex_class_def = klass->GetClassDef(); 4573 CHECK(dex_class_def != nullptr); 4574 const DexFile& dex_file = klass->GetDexFile(); 4575 StackHandleScope<3> hs(self); 4576 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader())); 4577 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache())); 4578 4579 // Eagerly fill in static fields so that the we don't have to do as many expensive 4580 // Class::FindStaticField in ResolveField. 4581 for (size_t i = 0; i < num_static_fields; ++i) { 4582 ArtField* field = klass->GetStaticField(i); 4583 const uint32_t field_idx = field->GetDexFieldIndex(); 4584 ArtField* resolved_field = dex_cache->GetResolvedField(field_idx, image_pointer_size_); 4585 if (resolved_field == nullptr) { 4586 dex_cache->SetResolvedField(field_idx, field, image_pointer_size_); 4587 } else { 4588 DCHECK_EQ(field, resolved_field); 4589 } 4590 } 4591 4592 EncodedStaticFieldValueIterator value_it(dex_file, &dex_cache, &class_loader, 4593 this, *dex_class_def); 4594 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def); 4595 ClassDataItemIterator field_it(dex_file, class_data); 4596 if (value_it.HasNext()) { 4597 DCHECK(field_it.HasNextStaticField()); 4598 CHECK(can_init_statics); 4599 for ( ; value_it.HasNext(); value_it.Next(), field_it.Next()) { 4600 ArtField* field = ResolveField( 4601 dex_file, field_it.GetMemberIndex(), dex_cache, class_loader, true); 4602 if (Runtime::Current()->IsActiveTransaction()) { 4603 value_it.ReadValueToField<true>(field); 4604 } else { 4605 value_it.ReadValueToField<false>(field); 4606 } 4607 DCHECK(!value_it.HasNext() || field_it.HasNextStaticField()); 4608 } 4609 } 4610 } 4611 4612 ArtMethod* clinit = klass->FindClassInitializer(image_pointer_size_); 4613 if (clinit != nullptr) { 4614 CHECK(can_init_statics); 4615 JValue result; 4616 clinit->Invoke(self, nullptr, 0, &result, "V"); 4617 } 4618 4619 self->AllowThreadSuspension(); 4620 uint64_t t1 = NanoTime(); 4621 4622 bool success = true; 4623 { 4624 ObjectLock<mirror::Class> lock(self, klass); 4625 4626 if (self->IsExceptionPending()) { 4627 WrapExceptionInInitializer(klass); 4628 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4629 success = false; 4630 } else if (Runtime::Current()->IsTransactionAborted()) { 4631 // The exception thrown when the transaction aborted has been caught and cleared 4632 // so we need to throw it again now. 4633 VLOG(compiler) << "Return from class initializer of " << PrettyDescriptor(klass.Get()) 4634 << " without exception while transaction was aborted: re-throw it now."; 4635 Runtime::Current()->ThrowTransactionAbortError(self); 4636 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4637 success = false; 4638 } else { 4639 RuntimeStats* global_stats = Runtime::Current()->GetStats(); 4640 RuntimeStats* thread_stats = self->GetStats(); 4641 ++global_stats->class_init_count; 4642 ++thread_stats->class_init_count; 4643 global_stats->class_init_time_ns += (t1 - t0); 4644 thread_stats->class_init_time_ns += (t1 - t0); 4645 // Set the class as initialized except if failed to initialize static fields. 4646 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self); 4647 if (VLOG_IS_ON(class_linker)) { 4648 std::string temp; 4649 LOG(INFO) << "Initialized class " << klass->GetDescriptor(&temp) << " from " << 4650 klass->GetLocation(); 4651 } 4652 // Opportunistically set static method trampolines to their destination. 4653 FixupStaticTrampolines(klass.Get()); 4654 } 4655 } 4656 return success; 4657} 4658 4659// We recursively run down the tree of interfaces. We need to do this in the order they are declared 4660// and perform the initialization only on those interfaces that contain default methods. 4661bool ClassLinker::InitializeDefaultInterfaceRecursive(Thread* self, 4662 Handle<mirror::Class> iface, 4663 bool can_init_statics, 4664 bool can_init_parents) { 4665 CHECK(iface->IsInterface()); 4666 size_t num_direct_ifaces = iface->NumDirectInterfaces(); 4667 // Only create the (expensive) handle scope if we need it. 4668 if (UNLIKELY(num_direct_ifaces > 0)) { 4669 StackHandleScope<1> hs(self); 4670 MutableHandle<mirror::Class> handle_super_iface(hs.NewHandle<mirror::Class>(nullptr)); 4671 // First we initialize all of iface's super-interfaces recursively. 4672 for (size_t i = 0; i < num_direct_ifaces; i++) { 4673 mirror::Class* super_iface = mirror::Class::GetDirectInterface(self, iface, i); 4674 if (!super_iface->HasBeenRecursivelyInitialized()) { 4675 // Recursive step 4676 handle_super_iface.Assign(super_iface); 4677 if (!InitializeDefaultInterfaceRecursive(self, 4678 handle_super_iface, 4679 can_init_statics, 4680 can_init_parents)) { 4681 return false; 4682 } 4683 } 4684 } 4685 } 4686 4687 bool result = true; 4688 // Then we initialize 'iface' if it has default methods. We do not need to (and in fact must not) 4689 // initialize if we don't have default methods. 4690 if (iface->HasDefaultMethods()) { 4691 result = EnsureInitialized(self, iface, can_init_statics, can_init_parents); 4692 } 4693 4694 // Mark that this interface has undergone recursive default interface initialization so we know we 4695 // can skip it on any later class initializations. We do this even if we are not a default 4696 // interface since we can still avoid the traversal. This is purely a performance optimization. 4697 if (result) { 4698 // TODO This should be done in a better way 4699 ObjectLock<mirror::Class> lock(self, iface); 4700 iface->SetRecursivelyInitialized(); 4701 } 4702 return result; 4703} 4704 4705bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass, 4706 Thread* self, 4707 ObjectLock<mirror::Class>& lock) 4708 SHARED_REQUIRES(Locks::mutator_lock_) { 4709 while (true) { 4710 self->AssertNoPendingException(); 4711 CHECK(!klass->IsInitialized()); 4712 lock.WaitIgnoringInterrupts(); 4713 4714 // When we wake up, repeat the test for init-in-progress. If 4715 // there's an exception pending (only possible if 4716 // we were not using WaitIgnoringInterrupts), bail out. 4717 if (self->IsExceptionPending()) { 4718 WrapExceptionInInitializer(klass); 4719 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 4720 return false; 4721 } 4722 // Spurious wakeup? Go back to waiting. 4723 if (klass->GetStatus() == mirror::Class::kStatusInitializing) { 4724 continue; 4725 } 4726 if (klass->GetStatus() == mirror::Class::kStatusVerified && 4727 Runtime::Current()->IsAotCompiler()) { 4728 // Compile time initialization failed. 4729 return false; 4730 } 4731 if (klass->IsErroneous()) { 4732 // The caller wants an exception, but it was thrown in a 4733 // different thread. Synthesize one here. 4734 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread", 4735 PrettyDescriptor(klass.Get()).c_str()); 4736 VlogClassInitializationFailure(klass); 4737 return false; 4738 } 4739 if (klass->IsInitialized()) { 4740 return true; 4741 } 4742 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass.Get()) << " is " 4743 << klass->GetStatus(); 4744 } 4745 UNREACHABLE(); 4746} 4747 4748static void ThrowSignatureCheckResolveReturnTypeException(Handle<mirror::Class> klass, 4749 Handle<mirror::Class> super_klass, 4750 ArtMethod* method, 4751 ArtMethod* m) 4752 SHARED_REQUIRES(Locks::mutator_lock_) { 4753 DCHECK(Thread::Current()->IsExceptionPending()); 4754 DCHECK(!m->IsProxyMethod()); 4755 const DexFile* dex_file = m->GetDexFile(); 4756 const DexFile::MethodId& method_id = dex_file->GetMethodId(m->GetDexMethodIndex()); 4757 const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id); 4758 uint16_t return_type_idx = proto_id.return_type_idx_; 4759 std::string return_type = PrettyType(return_type_idx, *dex_file); 4760 std::string class_loader = PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader()); 4761 ThrowWrappedLinkageError(klass.Get(), 4762 "While checking class %s method %s signature against %s %s: " 4763 "Failed to resolve return type %s with %s", 4764 PrettyDescriptor(klass.Get()).c_str(), 4765 PrettyMethod(method).c_str(), 4766 super_klass->IsInterface() ? "interface" : "superclass", 4767 PrettyDescriptor(super_klass.Get()).c_str(), 4768 return_type.c_str(), class_loader.c_str()); 4769} 4770 4771static void ThrowSignatureCheckResolveArgException(Handle<mirror::Class> klass, 4772 Handle<mirror::Class> super_klass, 4773 ArtMethod* method, 4774 ArtMethod* m, 4775 uint32_t index, 4776 uint32_t arg_type_idx) 4777 SHARED_REQUIRES(Locks::mutator_lock_) { 4778 DCHECK(Thread::Current()->IsExceptionPending()); 4779 DCHECK(!m->IsProxyMethod()); 4780 const DexFile* dex_file = m->GetDexFile(); 4781 std::string arg_type = PrettyType(arg_type_idx, *dex_file); 4782 std::string class_loader = PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader()); 4783 ThrowWrappedLinkageError(klass.Get(), 4784 "While checking class %s method %s signature against %s %s: " 4785 "Failed to resolve arg %u type %s with %s", 4786 PrettyDescriptor(klass.Get()).c_str(), 4787 PrettyMethod(method).c_str(), 4788 super_klass->IsInterface() ? "interface" : "superclass", 4789 PrettyDescriptor(super_klass.Get()).c_str(), 4790 index, arg_type.c_str(), class_loader.c_str()); 4791} 4792 4793static void ThrowSignatureMismatch(Handle<mirror::Class> klass, 4794 Handle<mirror::Class> super_klass, 4795 ArtMethod* method, 4796 const std::string& error_msg) 4797 SHARED_REQUIRES(Locks::mutator_lock_) { 4798 ThrowLinkageError(klass.Get(), 4799 "Class %s method %s resolves differently in %s %s: %s", 4800 PrettyDescriptor(klass.Get()).c_str(), 4801 PrettyMethod(method).c_str(), 4802 super_klass->IsInterface() ? "interface" : "superclass", 4803 PrettyDescriptor(super_klass.Get()).c_str(), 4804 error_msg.c_str()); 4805} 4806 4807static bool HasSameSignatureWithDifferentClassLoaders(Thread* self, 4808 size_t pointer_size, 4809 Handle<mirror::Class> klass, 4810 Handle<mirror::Class> super_klass, 4811 ArtMethod* method1, 4812 ArtMethod* method2) 4813 SHARED_REQUIRES(Locks::mutator_lock_) { 4814 { 4815 StackHandleScope<1> hs(self); 4816 Handle<mirror::Class> return_type(hs.NewHandle(method1->GetReturnType(true /* resolve */, 4817 pointer_size))); 4818 if (UNLIKELY(return_type.Get() == nullptr)) { 4819 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method1); 4820 return false; 4821 } 4822 mirror::Class* other_return_type = method2->GetReturnType(true /* resolve */, 4823 pointer_size); 4824 if (UNLIKELY(other_return_type == nullptr)) { 4825 ThrowSignatureCheckResolveReturnTypeException(klass, super_klass, method1, method2); 4826 return false; 4827 } 4828 if (UNLIKELY(other_return_type != return_type.Get())) { 4829 ThrowSignatureMismatch(klass, super_klass, method1, 4830 StringPrintf("Return types mismatch: %s(%p) vs %s(%p)", 4831 PrettyClassAndClassLoader(return_type.Get()).c_str(), 4832 return_type.Get(), 4833 PrettyClassAndClassLoader(other_return_type).c_str(), 4834 other_return_type)); 4835 return false; 4836 } 4837 } 4838 const DexFile::TypeList* types1 = method1->GetParameterTypeList(); 4839 const DexFile::TypeList* types2 = method2->GetParameterTypeList(); 4840 if (types1 == nullptr) { 4841 if (types2 != nullptr && types2->Size() != 0) { 4842 ThrowSignatureMismatch(klass, super_klass, method1, 4843 StringPrintf("Type list mismatch with %s", 4844 PrettyMethod(method2, true).c_str())); 4845 return false; 4846 } 4847 return true; 4848 } else if (UNLIKELY(types2 == nullptr)) { 4849 if (types1->Size() != 0) { 4850 ThrowSignatureMismatch(klass, super_klass, method1, 4851 StringPrintf("Type list mismatch with %s", 4852 PrettyMethod(method2, true).c_str())); 4853 return false; 4854 } 4855 return true; 4856 } 4857 uint32_t num_types = types1->Size(); 4858 if (UNLIKELY(num_types != types2->Size())) { 4859 ThrowSignatureMismatch(klass, super_klass, method1, 4860 StringPrintf("Type list mismatch with %s", 4861 PrettyMethod(method2, true).c_str())); 4862 return false; 4863 } 4864 for (uint32_t i = 0; i < num_types; ++i) { 4865 StackHandleScope<1> hs(self); 4866 uint32_t param_type_idx = types1->GetTypeItem(i).type_idx_; 4867 Handle<mirror::Class> param_type(hs.NewHandle( 4868 method1->GetClassFromTypeIndex(param_type_idx, true /* resolve */, pointer_size))); 4869 if (UNLIKELY(param_type.Get() == nullptr)) { 4870 ThrowSignatureCheckResolveArgException(klass, super_klass, method1, 4871 method1, i, param_type_idx); 4872 return false; 4873 } 4874 uint32_t other_param_type_idx = types2->GetTypeItem(i).type_idx_; 4875 mirror::Class* other_param_type = 4876 method2->GetClassFromTypeIndex(other_param_type_idx, true /* resolve */, pointer_size); 4877 if (UNLIKELY(other_param_type == nullptr)) { 4878 ThrowSignatureCheckResolveArgException(klass, super_klass, method1, 4879 method2, i, other_param_type_idx); 4880 return false; 4881 } 4882 if (UNLIKELY(param_type.Get() != other_param_type)) { 4883 ThrowSignatureMismatch(klass, super_klass, method1, 4884 StringPrintf("Parameter %u type mismatch: %s(%p) vs %s(%p)", 4885 i, 4886 PrettyClassAndClassLoader(param_type.Get()).c_str(), 4887 param_type.Get(), 4888 PrettyClassAndClassLoader(other_param_type).c_str(), 4889 other_param_type)); 4890 return false; 4891 } 4892 } 4893 return true; 4894} 4895 4896 4897bool ClassLinker::ValidateSuperClassDescriptors(Handle<mirror::Class> klass) { 4898 if (klass->IsInterface()) { 4899 return true; 4900 } 4901 // Begin with the methods local to the superclass. 4902 Thread* self = Thread::Current(); 4903 StackHandleScope<1> hs(self); 4904 MutableHandle<mirror::Class> super_klass(hs.NewHandle<mirror::Class>(nullptr)); 4905 if (klass->HasSuperClass() && 4906 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) { 4907 super_klass.Assign(klass->GetSuperClass()); 4908 for (int i = klass->GetSuperClass()->GetVTableLength() - 1; i >= 0; --i) { 4909 auto* m = klass->GetVTableEntry(i, image_pointer_size_); 4910 auto* super_m = klass->GetSuperClass()->GetVTableEntry(i, image_pointer_size_); 4911 if (m != super_m) { 4912 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self, image_pointer_size_, 4913 klass, super_klass, 4914 m, super_m))) { 4915 self->AssertPendingException(); 4916 return false; 4917 } 4918 } 4919 } 4920 } 4921 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) { 4922 super_klass.Assign(klass->GetIfTable()->GetInterface(i)); 4923 if (klass->GetClassLoader() != super_klass->GetClassLoader()) { 4924 uint32_t num_methods = super_klass->NumVirtualMethods(); 4925 for (uint32_t j = 0; j < num_methods; ++j) { 4926 auto* m = klass->GetIfTable()->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>( 4927 j, image_pointer_size_); 4928 auto* super_m = super_klass->GetVirtualMethod(j, image_pointer_size_); 4929 if (m != super_m) { 4930 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self, image_pointer_size_, 4931 klass, super_klass, 4932 m, super_m))) { 4933 self->AssertPendingException(); 4934 return false; 4935 } 4936 } 4937 } 4938 } 4939 } 4940 return true; 4941} 4942 4943bool ClassLinker::EnsureInitialized(Thread* self, Handle<mirror::Class> c, bool can_init_fields, 4944 bool can_init_parents) { 4945 DCHECK(c.Get() != nullptr); 4946 if (c->IsInitialized()) { 4947 EnsureSkipAccessChecksMethods(c); 4948 return true; 4949 } 4950 const bool success = InitializeClass(self, c, can_init_fields, can_init_parents); 4951 if (!success) { 4952 if (can_init_fields && can_init_parents) { 4953 CHECK(self->IsExceptionPending()) << PrettyClass(c.Get()); 4954 } 4955 } else { 4956 self->AssertNoPendingException(); 4957 } 4958 return success; 4959} 4960 4961void ClassLinker::FixupTemporaryDeclaringClass(mirror::Class* temp_class, 4962 mirror::Class* new_class) { 4963 DCHECK_EQ(temp_class->NumInstanceFields(), 0u); 4964 for (ArtField& field : new_class->GetIFields()) { 4965 if (field.GetDeclaringClass() == temp_class) { 4966 field.SetDeclaringClass(new_class); 4967 } 4968 } 4969 4970 DCHECK_EQ(temp_class->NumStaticFields(), 0u); 4971 for (ArtField& field : new_class->GetSFields()) { 4972 if (field.GetDeclaringClass() == temp_class) { 4973 field.SetDeclaringClass(new_class); 4974 } 4975 } 4976 4977 DCHECK_EQ(temp_class->NumDirectMethods(), 0u); 4978 DCHECK_EQ(temp_class->NumVirtualMethods(), 0u); 4979 for (auto& method : new_class->GetMethods(image_pointer_size_)) { 4980 if (method.GetDeclaringClass() == temp_class) { 4981 method.SetDeclaringClass(new_class); 4982 } 4983 } 4984 4985 // Make sure the remembered set and mod-union tables know that we updated some of the native 4986 // roots. 4987 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(new_class); 4988} 4989 4990void ClassLinker::RegisterClassLoader(mirror::ClassLoader* class_loader) { 4991 CHECK(class_loader->GetAllocator() == nullptr); 4992 CHECK(class_loader->GetClassTable() == nullptr); 4993 Thread* const self = Thread::Current(); 4994 ClassLoaderData data; 4995 data.weak_root = self->GetJniEnv()->vm->AddWeakGlobalRef(self, class_loader); 4996 // Create and set the class table. 4997 data.class_table = new ClassTable; 4998 class_loader->SetClassTable(data.class_table); 4999 // Create and set the linear allocator. 5000 data.allocator = Runtime::Current()->CreateLinearAlloc(); 5001 class_loader->SetAllocator(data.allocator); 5002 // Add to the list so that we know to free the data later. 5003 class_loaders_.push_back(data); 5004} 5005 5006ClassTable* ClassLinker::InsertClassTableForClassLoader(mirror::ClassLoader* class_loader) { 5007 if (class_loader == nullptr) { 5008 return &boot_class_table_; 5009 } 5010 ClassTable* class_table = class_loader->GetClassTable(); 5011 if (class_table == nullptr) { 5012 RegisterClassLoader(class_loader); 5013 class_table = class_loader->GetClassTable(); 5014 DCHECK(class_table != nullptr); 5015 } 5016 return class_table; 5017} 5018 5019ClassTable* ClassLinker::ClassTableForClassLoader(mirror::ClassLoader* class_loader) { 5020 return class_loader == nullptr ? &boot_class_table_ : class_loader->GetClassTable(); 5021} 5022 5023bool ClassLinker::LinkClass(Thread* self, 5024 const char* descriptor, 5025 Handle<mirror::Class> klass, 5026 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 5027 MutableHandle<mirror::Class>* h_new_class_out) { 5028 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus()); 5029 5030 if (!LinkSuperClass(klass)) { 5031 return false; 5032 } 5033 ArtMethod* imt[mirror::Class::kImtSize]; 5034 std::fill_n(imt, arraysize(imt), Runtime::Current()->GetImtUnimplementedMethod()); 5035 if (!LinkMethods(self, klass, interfaces, imt)) { 5036 return false; 5037 } 5038 if (!LinkInstanceFields(self, klass)) { 5039 return false; 5040 } 5041 size_t class_size; 5042 if (!LinkStaticFields(self, klass, &class_size)) { 5043 return false; 5044 } 5045 CreateReferenceInstanceOffsets(klass); 5046 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus()); 5047 5048 if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) { 5049 // We don't need to retire this class as it has no embedded tables or it was created the 5050 // correct size during class linker initialization. 5051 CHECK_EQ(klass->GetClassSize(), class_size) << PrettyDescriptor(klass.Get()); 5052 5053 if (klass->ShouldHaveEmbeddedImtAndVTable()) { 5054 klass->PopulateEmbeddedImtAndVTable(imt, image_pointer_size_); 5055 } 5056 5057 // This will notify waiters on klass that saw the not yet resolved 5058 // class in the class_table_ during EnsureResolved. 5059 mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self); 5060 h_new_class_out->Assign(klass.Get()); 5061 } else { 5062 CHECK(!klass->IsResolved()); 5063 // Retire the temporary class and create the correctly sized resolved class. 5064 StackHandleScope<1> hs(self); 5065 auto h_new_class = hs.NewHandle(klass->CopyOf(self, class_size, imt, image_pointer_size_)); 5066 // Set arrays to null since we don't want to have multiple classes with the same ArtField or 5067 // ArtMethod array pointers. If this occurs, it causes bugs in remembered sets since the GC 5068 // may not see any references to the target space and clean the card for a class if another 5069 // class had the same array pointer. 5070 klass->SetMethodsPtrUnchecked(nullptr, 0, 0); 5071 klass->SetSFieldsPtrUnchecked(nullptr); 5072 klass->SetIFieldsPtrUnchecked(nullptr); 5073 if (UNLIKELY(h_new_class.Get() == nullptr)) { 5074 self->AssertPendingOOMException(); 5075 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 5076 return false; 5077 } 5078 5079 CHECK_EQ(h_new_class->GetClassSize(), class_size); 5080 ObjectLock<mirror::Class> lock(self, h_new_class); 5081 FixupTemporaryDeclaringClass(klass.Get(), h_new_class.Get()); 5082 5083 { 5084 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 5085 mirror::ClassLoader* const class_loader = h_new_class.Get()->GetClassLoader(); 5086 ClassTable* const table = InsertClassTableForClassLoader(class_loader); 5087 mirror::Class* existing = table->UpdateClass(descriptor, h_new_class.Get(), 5088 ComputeModifiedUtf8Hash(descriptor)); 5089 if (class_loader != nullptr) { 5090 // We updated the class in the class table, perform the write barrier so that the GC knows 5091 // about the change. 5092 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader); 5093 } 5094 CHECK_EQ(existing, klass.Get()); 5095 if (kIsDebugBuild && class_loader == nullptr && dex_cache_boot_image_class_lookup_required_) { 5096 // Check a class loaded with the system class loader matches one in the image if the class 5097 // is in the image. 5098 mirror::Class* const image_class = LookupClassFromBootImage(descriptor); 5099 if (image_class != nullptr) { 5100 CHECK_EQ(klass.Get(), existing) << descriptor; 5101 } 5102 } 5103 if (log_new_class_table_roots_) { 5104 new_class_roots_.push_back(GcRoot<mirror::Class>(h_new_class.Get())); 5105 } 5106 } 5107 5108 // This will notify waiters on temp class that saw the not yet resolved class in the 5109 // class_table_ during EnsureResolved. 5110 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetired, self); 5111 5112 CHECK_EQ(h_new_class->GetStatus(), mirror::Class::kStatusResolving); 5113 // This will notify waiters on new_class that saw the not yet resolved 5114 // class in the class_table_ during EnsureResolved. 5115 mirror::Class::SetStatus(h_new_class, mirror::Class::kStatusResolved, self); 5116 // Return the new class. 5117 h_new_class_out->Assign(h_new_class.Get()); 5118 } 5119 return true; 5120} 5121 5122static void CountMethodsAndFields(ClassDataItemIterator& dex_data, 5123 size_t* virtual_methods, 5124 size_t* direct_methods, 5125 size_t* static_fields, 5126 size_t* instance_fields) { 5127 *virtual_methods = *direct_methods = *static_fields = *instance_fields = 0; 5128 5129 while (dex_data.HasNextStaticField()) { 5130 dex_data.Next(); 5131 (*static_fields)++; 5132 } 5133 while (dex_data.HasNextInstanceField()) { 5134 dex_data.Next(); 5135 (*instance_fields)++; 5136 } 5137 while (dex_data.HasNextDirectMethod()) { 5138 (*direct_methods)++; 5139 dex_data.Next(); 5140 } 5141 while (dex_data.HasNextVirtualMethod()) { 5142 (*virtual_methods)++; 5143 dex_data.Next(); 5144 } 5145 DCHECK(!dex_data.HasNext()); 5146} 5147 5148static void DumpClass(std::ostream& os, 5149 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, 5150 const char* suffix) { 5151 ClassDataItemIterator dex_data(dex_file, dex_file.GetClassData(dex_class_def)); 5152 os << dex_file.GetClassDescriptor(dex_class_def) << suffix << ":\n"; 5153 os << " Static fields:\n"; 5154 while (dex_data.HasNextStaticField()) { 5155 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex()); 5156 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n"; 5157 dex_data.Next(); 5158 } 5159 os << " Instance fields:\n"; 5160 while (dex_data.HasNextInstanceField()) { 5161 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex()); 5162 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n"; 5163 dex_data.Next(); 5164 } 5165 os << " Direct methods:\n"; 5166 while (dex_data.HasNextDirectMethod()) { 5167 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex()); 5168 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n"; 5169 dex_data.Next(); 5170 } 5171 os << " Virtual methods:\n"; 5172 while (dex_data.HasNextVirtualMethod()) { 5173 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex()); 5174 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n"; 5175 dex_data.Next(); 5176 } 5177} 5178 5179static std::string DumpClasses(const DexFile& dex_file1, 5180 const DexFile::ClassDef& dex_class_def1, 5181 const DexFile& dex_file2, 5182 const DexFile::ClassDef& dex_class_def2) { 5183 std::ostringstream os; 5184 DumpClass(os, dex_file1, dex_class_def1, " (Compile time)"); 5185 DumpClass(os, dex_file2, dex_class_def2, " (Runtime)"); 5186 return os.str(); 5187} 5188 5189 5190// Very simple structural check on whether the classes match. Only compares the number of 5191// methods and fields. 5192static bool SimpleStructuralCheck(const DexFile& dex_file1, 5193 const DexFile::ClassDef& dex_class_def1, 5194 const DexFile& dex_file2, 5195 const DexFile::ClassDef& dex_class_def2, 5196 std::string* error_msg) { 5197 ClassDataItemIterator dex_data1(dex_file1, dex_file1.GetClassData(dex_class_def1)); 5198 ClassDataItemIterator dex_data2(dex_file2, dex_file2.GetClassData(dex_class_def2)); 5199 5200 // Counters for current dex file. 5201 size_t dex_virtual_methods1, dex_direct_methods1, dex_static_fields1, dex_instance_fields1; 5202 CountMethodsAndFields(dex_data1, 5203 &dex_virtual_methods1, 5204 &dex_direct_methods1, 5205 &dex_static_fields1, 5206 &dex_instance_fields1); 5207 // Counters for compile-time dex file. 5208 size_t dex_virtual_methods2, dex_direct_methods2, dex_static_fields2, dex_instance_fields2; 5209 CountMethodsAndFields(dex_data2, 5210 &dex_virtual_methods2, 5211 &dex_direct_methods2, 5212 &dex_static_fields2, 5213 &dex_instance_fields2); 5214 5215 if (dex_virtual_methods1 != dex_virtual_methods2) { 5216 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 5217 *error_msg = StringPrintf("Virtual method count off: %zu vs %zu\n%s", 5218 dex_virtual_methods1, 5219 dex_virtual_methods2, 5220 class_dump.c_str()); 5221 return false; 5222 } 5223 if (dex_direct_methods1 != dex_direct_methods2) { 5224 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 5225 *error_msg = StringPrintf("Direct method count off: %zu vs %zu\n%s", 5226 dex_direct_methods1, 5227 dex_direct_methods2, 5228 class_dump.c_str()); 5229 return false; 5230 } 5231 if (dex_static_fields1 != dex_static_fields2) { 5232 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 5233 *error_msg = StringPrintf("Static field count off: %zu vs %zu\n%s", 5234 dex_static_fields1, 5235 dex_static_fields2, 5236 class_dump.c_str()); 5237 return false; 5238 } 5239 if (dex_instance_fields1 != dex_instance_fields2) { 5240 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 5241 *error_msg = StringPrintf("Instance field count off: %zu vs %zu\n%s", 5242 dex_instance_fields1, 5243 dex_instance_fields2, 5244 class_dump.c_str()); 5245 return false; 5246 } 5247 5248 return true; 5249} 5250 5251// Checks whether a the super-class changed from what we had at compile-time. This would 5252// invalidate quickening. 5253static bool CheckSuperClassChange(Handle<mirror::Class> klass, 5254 const DexFile& dex_file, 5255 const DexFile::ClassDef& class_def, 5256 mirror::Class* super_class) 5257 SHARED_REQUIRES(Locks::mutator_lock_) { 5258 // Check for unexpected changes in the superclass. 5259 // Quick check 1) is the super_class class-loader the boot class loader? This always has 5260 // precedence. 5261 if (super_class->GetClassLoader() != nullptr && 5262 // Quick check 2) different dex cache? Breaks can only occur for different dex files, 5263 // which is implied by different dex cache. 5264 klass->GetDexCache() != super_class->GetDexCache()) { 5265 // Now comes the expensive part: things can be broken if (a) the klass' dex file has a 5266 // definition for the super-class, and (b) the files are in separate oat files. The oat files 5267 // are referenced from the dex file, so do (b) first. Only relevant if we have oat files. 5268 const OatDexFile* class_oat_dex_file = dex_file.GetOatDexFile(); 5269 const OatFile* class_oat_file = nullptr; 5270 if (class_oat_dex_file != nullptr) { 5271 class_oat_file = class_oat_dex_file->GetOatFile(); 5272 } 5273 5274 if (class_oat_file != nullptr) { 5275 const OatDexFile* loaded_super_oat_dex_file = super_class->GetDexFile().GetOatDexFile(); 5276 const OatFile* loaded_super_oat_file = nullptr; 5277 if (loaded_super_oat_dex_file != nullptr) { 5278 loaded_super_oat_file = loaded_super_oat_dex_file->GetOatFile(); 5279 } 5280 5281 if (loaded_super_oat_file != nullptr && class_oat_file != loaded_super_oat_file) { 5282 // Now check (a). 5283 const DexFile::ClassDef* super_class_def = dex_file.FindClassDef(class_def.superclass_idx_); 5284 if (super_class_def != nullptr) { 5285 // Uh-oh, we found something. Do our check. 5286 std::string error_msg; 5287 if (!SimpleStructuralCheck(dex_file, *super_class_def, 5288 super_class->GetDexFile(), *super_class->GetClassDef(), 5289 &error_msg)) { 5290 // Print a warning to the log. This exception might be caught, e.g., as common in test 5291 // drivers. When the class is later tried to be used, we re-throw a new instance, as we 5292 // only save the type of the exception. 5293 LOG(WARNING) << "Incompatible structural change detected: " << 5294 StringPrintf( 5295 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s", 5296 PrettyType(super_class_def->class_idx_, dex_file).c_str(), 5297 class_oat_file->GetLocation().c_str(), 5298 loaded_super_oat_file->GetLocation().c_str(), 5299 error_msg.c_str()); 5300 ThrowIncompatibleClassChangeError(klass.Get(), 5301 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s", 5302 PrettyType(super_class_def->class_idx_, dex_file).c_str(), 5303 class_oat_file->GetLocation().c_str(), 5304 loaded_super_oat_file->GetLocation().c_str(), 5305 error_msg.c_str()); 5306 return false; 5307 } 5308 } 5309 } 5310 } 5311 } 5312 return true; 5313} 5314 5315bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) { 5316 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus()); 5317 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex()); 5318 uint16_t super_class_idx = class_def.superclass_idx_; 5319 if (super_class_idx != DexFile::kDexNoIndex16) { 5320 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.Get()); 5321 if (super_class == nullptr) { 5322 DCHECK(Thread::Current()->IsExceptionPending()); 5323 return false; 5324 } 5325 // Verify 5326 if (!klass->CanAccess(super_class)) { 5327 ThrowIllegalAccessError(klass.Get(), "Class %s extended by class %s is inaccessible", 5328 PrettyDescriptor(super_class).c_str(), 5329 PrettyDescriptor(klass.Get()).c_str()); 5330 return false; 5331 } 5332 CHECK(super_class->IsResolved()); 5333 klass->SetSuperClass(super_class); 5334 5335 if (!CheckSuperClassChange(klass, dex_file, class_def, super_class)) { 5336 DCHECK(Thread::Current()->IsExceptionPending()); 5337 return false; 5338 } 5339 } 5340 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def); 5341 if (interfaces != nullptr) { 5342 for (size_t i = 0; i < interfaces->Size(); i++) { 5343 uint16_t idx = interfaces->GetTypeItem(i).type_idx_; 5344 mirror::Class* interface = ResolveType(dex_file, idx, klass.Get()); 5345 if (interface == nullptr) { 5346 DCHECK(Thread::Current()->IsExceptionPending()); 5347 return false; 5348 } 5349 // Verify 5350 if (!klass->CanAccess(interface)) { 5351 // TODO: the RI seemed to ignore this in my testing. 5352 ThrowIllegalAccessError(klass.Get(), 5353 "Interface %s implemented by class %s is inaccessible", 5354 PrettyDescriptor(interface).c_str(), 5355 PrettyDescriptor(klass.Get()).c_str()); 5356 return false; 5357 } 5358 } 5359 } 5360 // Mark the class as loaded. 5361 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, nullptr); 5362 return true; 5363} 5364 5365bool ClassLinker::LinkSuperClass(Handle<mirror::Class> klass) { 5366 CHECK(!klass->IsPrimitive()); 5367 mirror::Class* super = klass->GetSuperClass(); 5368 if (klass.Get() == GetClassRoot(kJavaLangObject)) { 5369 if (super != nullptr) { 5370 ThrowClassFormatError(klass.Get(), "java.lang.Object must not have a superclass"); 5371 return false; 5372 } 5373 return true; 5374 } 5375 if (super == nullptr) { 5376 ThrowLinkageError(klass.Get(), "No superclass defined for class %s", 5377 PrettyDescriptor(klass.Get()).c_str()); 5378 return false; 5379 } 5380 // Verify 5381 if (super->IsFinal() || super->IsInterface()) { 5382 ThrowIncompatibleClassChangeError(klass.Get(), 5383 "Superclass %s of %s is %s", 5384 PrettyDescriptor(super).c_str(), 5385 PrettyDescriptor(klass.Get()).c_str(), 5386 super->IsFinal() ? "declared final" : "an interface"); 5387 return false; 5388 } 5389 if (!klass->CanAccess(super)) { 5390 ThrowIllegalAccessError(klass.Get(), "Superclass %s is inaccessible to class %s", 5391 PrettyDescriptor(super).c_str(), 5392 PrettyDescriptor(klass.Get()).c_str()); 5393 return false; 5394 } 5395 5396 // Inherit kAccClassIsFinalizable from the superclass in case this 5397 // class doesn't override finalize. 5398 if (super->IsFinalizable()) { 5399 klass->SetFinalizable(); 5400 } 5401 5402 // Inherit class loader flag form super class. 5403 if (super->IsClassLoaderClass()) { 5404 klass->SetClassLoaderClass(); 5405 } 5406 5407 // Inherit reference flags (if any) from the superclass. 5408 uint32_t reference_flags = (super->GetClassFlags() & mirror::kClassFlagReference); 5409 if (reference_flags != 0) { 5410 CHECK_EQ(klass->GetClassFlags(), 0u); 5411 klass->SetClassFlags(klass->GetClassFlags() | reference_flags); 5412 } 5413 // Disallow custom direct subclasses of java.lang.ref.Reference. 5414 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) { 5415 ThrowLinkageError(klass.Get(), 5416 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed", 5417 PrettyDescriptor(klass.Get()).c_str()); 5418 return false; 5419 } 5420 5421 if (kIsDebugBuild) { 5422 // Ensure super classes are fully resolved prior to resolving fields.. 5423 while (super != nullptr) { 5424 CHECK(super->IsResolved()); 5425 super = super->GetSuperClass(); 5426 } 5427 } 5428 return true; 5429} 5430 5431// Populate the class vtable and itable. Compute return type indices. 5432bool ClassLinker::LinkMethods(Thread* self, 5433 Handle<mirror::Class> klass, 5434 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 5435 ArtMethod** out_imt) { 5436 self->AllowThreadSuspension(); 5437 // A map from vtable indexes to the method they need to be updated to point to. Used because we 5438 // need to have default methods be in the virtuals array of each class but we don't set that up 5439 // until LinkInterfaceMethods. 5440 std::unordered_map<size_t, ClassLinker::MethodTranslation> default_translations; 5441 // Link virtual methods then interface methods. 5442 // We set up the interface lookup table first because we need it to determine if we need to update 5443 // any vtable entries with new default method implementations. 5444 return SetupInterfaceLookupTable(self, klass, interfaces) 5445 && LinkVirtualMethods(self, klass, /*out*/ &default_translations) 5446 && LinkInterfaceMethods(self, klass, default_translations, out_imt); 5447} 5448 5449// Comparator for name and signature of a method, used in finding overriding methods. Implementation 5450// avoids the use of handles, if it didn't then rather than compare dex files we could compare dex 5451// caches in the implementation below. 5452class MethodNameAndSignatureComparator FINAL : public ValueObject { 5453 public: 5454 explicit MethodNameAndSignatureComparator(ArtMethod* method) 5455 SHARED_REQUIRES(Locks::mutator_lock_) : 5456 dex_file_(method->GetDexFile()), mid_(&dex_file_->GetMethodId(method->GetDexMethodIndex())), 5457 name_(nullptr), name_len_(0) { 5458 DCHECK(!method->IsProxyMethod()) << PrettyMethod(method); 5459 } 5460 5461 const char* GetName() { 5462 if (name_ == nullptr) { 5463 name_ = dex_file_->StringDataAndUtf16LengthByIdx(mid_->name_idx_, &name_len_); 5464 } 5465 return name_; 5466 } 5467 5468 bool HasSameNameAndSignature(ArtMethod* other) 5469 SHARED_REQUIRES(Locks::mutator_lock_) { 5470 DCHECK(!other->IsProxyMethod()) << PrettyMethod(other); 5471 const DexFile* other_dex_file = other->GetDexFile(); 5472 const DexFile::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex()); 5473 if (dex_file_ == other_dex_file) { 5474 return mid_->name_idx_ == other_mid.name_idx_ && mid_->proto_idx_ == other_mid.proto_idx_; 5475 } 5476 GetName(); // Only used to make sure its calculated. 5477 uint32_t other_name_len; 5478 const char* other_name = other_dex_file->StringDataAndUtf16LengthByIdx(other_mid.name_idx_, 5479 &other_name_len); 5480 if (name_len_ != other_name_len || strcmp(name_, other_name) != 0) { 5481 return false; 5482 } 5483 return dex_file_->GetMethodSignature(*mid_) == other_dex_file->GetMethodSignature(other_mid); 5484 } 5485 5486 private: 5487 // Dex file for the method to compare against. 5488 const DexFile* const dex_file_; 5489 // MethodId for the method to compare against. 5490 const DexFile::MethodId* const mid_; 5491 // Lazily computed name from the dex file's strings. 5492 const char* name_; 5493 // Lazily computed name length. 5494 uint32_t name_len_; 5495}; 5496 5497class LinkVirtualHashTable { 5498 public: 5499 LinkVirtualHashTable(Handle<mirror::Class> klass, 5500 size_t hash_size, 5501 uint32_t* hash_table, 5502 size_t image_pointer_size) 5503 : klass_(klass), 5504 hash_size_(hash_size), 5505 hash_table_(hash_table), 5506 image_pointer_size_(image_pointer_size) { 5507 std::fill(hash_table_, hash_table_ + hash_size_, invalid_index_); 5508 } 5509 5510 void Add(uint32_t virtual_method_index) SHARED_REQUIRES(Locks::mutator_lock_) { 5511 ArtMethod* local_method = klass_->GetVirtualMethodDuringLinking( 5512 virtual_method_index, image_pointer_size_); 5513 const char* name = local_method->GetInterfaceMethodIfProxy(image_pointer_size_)->GetName(); 5514 uint32_t hash = ComputeModifiedUtf8Hash(name); 5515 uint32_t index = hash % hash_size_; 5516 // Linear probe until we have an empty slot. 5517 while (hash_table_[index] != invalid_index_) { 5518 if (++index == hash_size_) { 5519 index = 0; 5520 } 5521 } 5522 hash_table_[index] = virtual_method_index; 5523 } 5524 5525 uint32_t FindAndRemove(MethodNameAndSignatureComparator* comparator) 5526 SHARED_REQUIRES(Locks::mutator_lock_) { 5527 const char* name = comparator->GetName(); 5528 uint32_t hash = ComputeModifiedUtf8Hash(name); 5529 size_t index = hash % hash_size_; 5530 while (true) { 5531 const uint32_t value = hash_table_[index]; 5532 // Since linear probe makes continuous blocks, hitting an invalid index means we are done 5533 // the block and can safely assume not found. 5534 if (value == invalid_index_) { 5535 break; 5536 } 5537 if (value != removed_index_) { // This signifies not already overriden. 5538 ArtMethod* virtual_method = 5539 klass_->GetVirtualMethodDuringLinking(value, image_pointer_size_); 5540 if (comparator->HasSameNameAndSignature( 5541 virtual_method->GetInterfaceMethodIfProxy(image_pointer_size_))) { 5542 hash_table_[index] = removed_index_; 5543 return value; 5544 } 5545 } 5546 if (++index == hash_size_) { 5547 index = 0; 5548 } 5549 } 5550 return GetNotFoundIndex(); 5551 } 5552 5553 static uint32_t GetNotFoundIndex() { 5554 return invalid_index_; 5555 } 5556 5557 private: 5558 static const uint32_t invalid_index_; 5559 static const uint32_t removed_index_; 5560 5561 Handle<mirror::Class> klass_; 5562 const size_t hash_size_; 5563 uint32_t* const hash_table_; 5564 const size_t image_pointer_size_; 5565}; 5566 5567const uint32_t LinkVirtualHashTable::invalid_index_ = std::numeric_limits<uint32_t>::max(); 5568const uint32_t LinkVirtualHashTable::removed_index_ = std::numeric_limits<uint32_t>::max() - 1; 5569 5570bool ClassLinker::LinkVirtualMethods( 5571 Thread* self, 5572 Handle<mirror::Class> klass, 5573 /*out*/std::unordered_map<size_t, ClassLinker::MethodTranslation>* default_translations) { 5574 const size_t num_virtual_methods = klass->NumVirtualMethods(); 5575 if (klass->IsInterface()) { 5576 // No vtable. 5577 if (!IsUint<16>(num_virtual_methods)) { 5578 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zu", num_virtual_methods); 5579 return false; 5580 } 5581 bool has_defaults = false; 5582 // Assign each method an IMT index and set the default flag. 5583 for (size_t i = 0; i < num_virtual_methods; ++i) { 5584 ArtMethod* m = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_); 5585 m->SetMethodIndex(i); 5586 if (!m->IsAbstract()) { 5587 m->SetAccessFlags(m->GetAccessFlags() | kAccDefault); 5588 has_defaults = true; 5589 } 5590 } 5591 // Mark that we have default methods so that we won't need to scan the virtual_methods_ array 5592 // during initialization. This is a performance optimization. We could simply traverse the 5593 // virtual_methods_ array again during initialization. 5594 if (has_defaults) { 5595 klass->SetHasDefaultMethods(); 5596 } 5597 return true; 5598 } else if (klass->HasSuperClass()) { 5599 const size_t super_vtable_length = klass->GetSuperClass()->GetVTableLength(); 5600 const size_t max_count = num_virtual_methods + super_vtable_length; 5601 StackHandleScope<2> hs(self); 5602 Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass())); 5603 MutableHandle<mirror::PointerArray> vtable; 5604 if (super_class->ShouldHaveEmbeddedImtAndVTable()) { 5605 vtable = hs.NewHandle(AllocPointerArray(self, max_count)); 5606 if (UNLIKELY(vtable.Get() == nullptr)) { 5607 self->AssertPendingOOMException(); 5608 return false; 5609 } 5610 for (size_t i = 0; i < super_vtable_length; i++) { 5611 vtable->SetElementPtrSize( 5612 i, super_class->GetEmbeddedVTableEntry(i, image_pointer_size_), image_pointer_size_); 5613 } 5614 // We might need to change vtable if we have new virtual methods or new interfaces (since that 5615 // might give us new default methods). If no new interfaces then we can skip the rest since 5616 // the class cannot override any of the super-class's methods. This is required for 5617 // correctness since without it we might not update overridden default method vtable entries 5618 // correctly. 5619 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) { 5620 klass->SetVTable(vtable.Get()); 5621 return true; 5622 } 5623 } else { 5624 DCHECK(super_class->IsAbstract() && !super_class->IsArrayClass()); 5625 auto* super_vtable = super_class->GetVTable(); 5626 CHECK(super_vtable != nullptr) << PrettyClass(super_class.Get()); 5627 // We might need to change vtable if we have new virtual methods or new interfaces (since that 5628 // might give us new default methods). See comment above. 5629 if (num_virtual_methods == 0 && super_class->GetIfTableCount() == klass->GetIfTableCount()) { 5630 klass->SetVTable(super_vtable); 5631 return true; 5632 } 5633 vtable = hs.NewHandle(down_cast<mirror::PointerArray*>( 5634 super_vtable->CopyOf(self, max_count))); 5635 if (UNLIKELY(vtable.Get() == nullptr)) { 5636 self->AssertPendingOOMException(); 5637 return false; 5638 } 5639 } 5640 // How the algorithm works: 5641 // 1. Populate hash table by adding num_virtual_methods from klass. The values in the hash 5642 // table are: invalid_index for unused slots, index super_vtable_length + i for a virtual 5643 // method which has not been matched to a vtable method, and j if the virtual method at the 5644 // index overrode the super virtual method at index j. 5645 // 2. Loop through super virtual methods, if they overwrite, update hash table to j 5646 // (j < super_vtable_length) to avoid redundant checks. (TODO maybe use this info for reducing 5647 // the need for the initial vtable which we later shrink back down). 5648 // 3. Add non overridden methods to the end of the vtable. 5649 static constexpr size_t kMaxStackHash = 250; 5650 // + 1 so that even if we only have new default methods we will still be able to use this hash 5651 // table (i.e. it will never have 0 size). 5652 const size_t hash_table_size = num_virtual_methods * 3 + 1; 5653 uint32_t* hash_table_ptr; 5654 std::unique_ptr<uint32_t[]> hash_heap_storage; 5655 if (hash_table_size <= kMaxStackHash) { 5656 hash_table_ptr = reinterpret_cast<uint32_t*>( 5657 alloca(hash_table_size * sizeof(*hash_table_ptr))); 5658 } else { 5659 hash_heap_storage.reset(new uint32_t[hash_table_size]); 5660 hash_table_ptr = hash_heap_storage.get(); 5661 } 5662 LinkVirtualHashTable hash_table(klass, hash_table_size, hash_table_ptr, image_pointer_size_); 5663 // Add virtual methods to the hash table. 5664 for (size_t i = 0; i < num_virtual_methods; ++i) { 5665 DCHECK(klass->GetVirtualMethodDuringLinking( 5666 i, image_pointer_size_)->GetDeclaringClass() != nullptr); 5667 hash_table.Add(i); 5668 } 5669 // Loop through each super vtable method and see if they are overridden by a method we added to 5670 // the hash table. 5671 for (size_t j = 0; j < super_vtable_length; ++j) { 5672 // Search the hash table to see if we are overridden by any method. 5673 ArtMethod* super_method = vtable->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_); 5674 MethodNameAndSignatureComparator super_method_name_comparator( 5675 super_method->GetInterfaceMethodIfProxy(image_pointer_size_)); 5676 uint32_t hash_index = hash_table.FindAndRemove(&super_method_name_comparator); 5677 if (hash_index != hash_table.GetNotFoundIndex()) { 5678 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking( 5679 hash_index, image_pointer_size_); 5680 if (klass->CanAccessMember(super_method->GetDeclaringClass(), 5681 super_method->GetAccessFlags())) { 5682 if (super_method->IsFinal()) { 5683 ThrowLinkageError(klass.Get(), "Method %s overrides final method in class %s", 5684 PrettyMethod(virtual_method).c_str(), 5685 super_method->GetDeclaringClassDescriptor()); 5686 return false; 5687 } 5688 vtable->SetElementPtrSize(j, virtual_method, image_pointer_size_); 5689 virtual_method->SetMethodIndex(j); 5690 } else { 5691 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(virtual_method) 5692 << " would have incorrectly overridden the package-private method in " 5693 << PrettyDescriptor(super_method->GetDeclaringClassDescriptor()); 5694 } 5695 } else if (super_method->IsOverridableByDefaultMethod()) { 5696 // We didn't directly override this method but we might through default methods... 5697 // Check for default method update. 5698 ArtMethod* default_method = nullptr; 5699 switch (FindDefaultMethodImplementation(self, 5700 super_method, 5701 klass, 5702 /*out*/&default_method)) { 5703 case DefaultMethodSearchResult::kDefaultConflict: { 5704 // A conflict was found looking for default methods. Note this (assuming it wasn't 5705 // pre-existing) in the translations map. 5706 if (UNLIKELY(!super_method->IsDefaultConflicting())) { 5707 // Don't generate another conflict method to reduce memory use as an optimization. 5708 default_translations->insert( 5709 {j, ClassLinker::MethodTranslation::CreateConflictingMethod()}); 5710 } 5711 break; 5712 } 5713 case DefaultMethodSearchResult::kAbstractFound: { 5714 // No conflict but method is abstract. 5715 // We note that this vtable entry must be made abstract. 5716 if (UNLIKELY(!super_method->IsAbstract())) { 5717 default_translations->insert( 5718 {j, ClassLinker::MethodTranslation::CreateAbstractMethod()}); 5719 } 5720 break; 5721 } 5722 case DefaultMethodSearchResult::kDefaultFound: { 5723 if (UNLIKELY(super_method->IsDefaultConflicting() || 5724 default_method->GetDeclaringClass() != super_method->GetDeclaringClass())) { 5725 // Found a default method implementation that is new. 5726 // TODO Refactor this add default methods to virtuals here and not in 5727 // LinkInterfaceMethods maybe. 5728 // The problem is default methods might override previously present 5729 // default-method or miranda-method vtable entries from the superclass. 5730 // Unfortunately we need these to be entries in this class's virtuals. We do not 5731 // give these entries there until LinkInterfaceMethods so we pass this map around 5732 // to let it know which vtable entries need to be updated. 5733 // Make a note that vtable entry j must be updated, store what it needs to be updated 5734 // to. We will allocate a virtual method slot in LinkInterfaceMethods and fix it up 5735 // then. 5736 default_translations->insert( 5737 {j, ClassLinker::MethodTranslation::CreateTranslatedMethod(default_method)}); 5738 VLOG(class_linker) << "Method " << PrettyMethod(super_method) 5739 << " overridden by default " << PrettyMethod(default_method) 5740 << " in " << PrettyClass(klass.Get()); 5741 } 5742 break; 5743 } 5744 } 5745 } 5746 } 5747 size_t actual_count = super_vtable_length; 5748 // Add the non-overridden methods at the end. 5749 for (size_t i = 0; i < num_virtual_methods; ++i) { 5750 ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_); 5751 size_t method_idx = local_method->GetMethodIndexDuringLinking(); 5752 if (method_idx < super_vtable_length && 5753 local_method == vtable->GetElementPtrSize<ArtMethod*>(method_idx, image_pointer_size_)) { 5754 continue; 5755 } 5756 vtable->SetElementPtrSize(actual_count, local_method, image_pointer_size_); 5757 local_method->SetMethodIndex(actual_count); 5758 ++actual_count; 5759 } 5760 if (!IsUint<16>(actual_count)) { 5761 ThrowClassFormatError(klass.Get(), "Too many methods defined on class: %zd", actual_count); 5762 return false; 5763 } 5764 // Shrink vtable if possible 5765 CHECK_LE(actual_count, max_count); 5766 if (actual_count < max_count) { 5767 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, actual_count))); 5768 if (UNLIKELY(vtable.Get() == nullptr)) { 5769 self->AssertPendingOOMException(); 5770 return false; 5771 } 5772 } 5773 klass->SetVTable(vtable.Get()); 5774 } else { 5775 CHECK_EQ(klass.Get(), GetClassRoot(kJavaLangObject)); 5776 if (!IsUint<16>(num_virtual_methods)) { 5777 ThrowClassFormatError(klass.Get(), "Too many methods: %d", 5778 static_cast<int>(num_virtual_methods)); 5779 return false; 5780 } 5781 auto* vtable = AllocPointerArray(self, num_virtual_methods); 5782 if (UNLIKELY(vtable == nullptr)) { 5783 self->AssertPendingOOMException(); 5784 return false; 5785 } 5786 for (size_t i = 0; i < num_virtual_methods; ++i) { 5787 ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i, image_pointer_size_); 5788 vtable->SetElementPtrSize(i, virtual_method, image_pointer_size_); 5789 virtual_method->SetMethodIndex(i & 0xFFFF); 5790 } 5791 klass->SetVTable(vtable); 5792 } 5793 return true; 5794} 5795 5796// Determine if the given iface has any subinterface in the given list that declares the method 5797// specified by 'target'. 5798// 5799// Arguments 5800// - self: The thread we are running on 5801// - target: A comparator that will match any method that overrides the method we are checking for 5802// - iftable: The iftable we are searching for an overriding method on. 5803// - ifstart: The index of the interface we are checking to see if anything overrides 5804// - iface: The interface we are checking to see if anything overrides. 5805// - image_pointer_size: 5806// The image pointer size. 5807// 5808// Returns 5809// - True: There is some method that matches the target comparator defined in an interface that 5810// is a subtype of iface. 5811// - False: There is no method that matches the target comparator in any interface that is a subtype 5812// of iface. 5813static bool ContainsOverridingMethodOf(Thread* self, 5814 MethodNameAndSignatureComparator& target, 5815 Handle<mirror::IfTable> iftable, 5816 size_t ifstart, 5817 Handle<mirror::Class> iface, 5818 size_t image_pointer_size) 5819 SHARED_REQUIRES(Locks::mutator_lock_) { 5820 DCHECK(self != nullptr); 5821 DCHECK(iface.Get() != nullptr); 5822 DCHECK(iftable.Get() != nullptr); 5823 DCHECK_GE(ifstart, 0u); 5824 DCHECK_LT(ifstart, iftable->Count()); 5825 DCHECK_EQ(iface.Get(), iftable->GetInterface(ifstart)); 5826 DCHECK(iface->IsInterface()); 5827 5828 size_t iftable_count = iftable->Count(); 5829 StackHandleScope<1> hs(self); 5830 MutableHandle<mirror::Class> current_iface(hs.NewHandle<mirror::Class>(nullptr)); 5831 for (size_t k = ifstart + 1; k < iftable_count; k++) { 5832 // Skip ifstart since our current interface obviously cannot override itself. 5833 current_iface.Assign(iftable->GetInterface(k)); 5834 // Iterate through every method on this interface. The order does not matter. 5835 for (ArtMethod& current_method : current_iface->GetDeclaredVirtualMethods(image_pointer_size)) { 5836 if (UNLIKELY(target.HasSameNameAndSignature( 5837 current_method.GetInterfaceMethodIfProxy(image_pointer_size)))) { 5838 // Check if the i'th interface is a subtype of this one. 5839 if (iface->IsAssignableFrom(current_iface.Get())) { 5840 return true; 5841 } 5842 break; 5843 } 5844 } 5845 } 5846 return false; 5847} 5848 5849// Find the default method implementation for 'interface_method' in 'klass'. Stores it into 5850// out_default_method and returns kDefaultFound on success. If no default method was found return 5851// kAbstractFound and store nullptr into out_default_method. If an error occurs (such as a 5852// default_method conflict) it will return kDefaultConflict. 5853ClassLinker::DefaultMethodSearchResult ClassLinker::FindDefaultMethodImplementation( 5854 Thread* self, 5855 ArtMethod* target_method, 5856 Handle<mirror::Class> klass, 5857 /*out*/ArtMethod** out_default_method) const { 5858 DCHECK(self != nullptr); 5859 DCHECK(target_method != nullptr); 5860 DCHECK(out_default_method != nullptr); 5861 5862 *out_default_method = nullptr; 5863 5864 // We organize the interface table so that, for interface I any subinterfaces J follow it in the 5865 // table. This lets us walk the table backwards when searching for default methods. The first one 5866 // we encounter is the best candidate since it is the most specific. Once we have found it we keep 5867 // track of it and then continue checking all other interfaces, since we need to throw an error if 5868 // we encounter conflicting default method implementations (one is not a subtype of the other). 5869 // 5870 // The order of unrelated interfaces does not matter and is not defined. 5871 size_t iftable_count = klass->GetIfTableCount(); 5872 if (iftable_count == 0) { 5873 // No interfaces. We have already reset out to null so just return kAbstractFound. 5874 return DefaultMethodSearchResult::kAbstractFound; 5875 } 5876 5877 StackHandleScope<3> hs(self); 5878 MutableHandle<mirror::Class> chosen_iface(hs.NewHandle<mirror::Class>(nullptr)); 5879 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable())); 5880 MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr)); 5881 MethodNameAndSignatureComparator target_name_comparator( 5882 target_method->GetInterfaceMethodIfProxy(image_pointer_size_)); 5883 // Iterates over the klass's iftable in reverse 5884 for (size_t k = iftable_count; k != 0; ) { 5885 --k; 5886 5887 DCHECK_LT(k, iftable->Count()); 5888 5889 iface.Assign(iftable->GetInterface(k)); 5890 // Iterate through every declared method on this interface. The order does not matter. 5891 for (auto& method_iter : iface->GetDeclaredVirtualMethods(image_pointer_size_)) { 5892 ArtMethod* current_method = &method_iter; 5893 // Skip abstract methods and methods with different names. 5894 if (current_method->IsAbstract() || 5895 !target_name_comparator.HasSameNameAndSignature( 5896 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) { 5897 continue; 5898 } else if (!current_method->IsPublic()) { 5899 // The verifier should have caught the non-public method for dex version 37. Just warn and 5900 // skip it since this is from before default-methods so we don't really need to care that it 5901 // has code. 5902 LOG(WARNING) << "Interface method " << PrettyMethod(current_method) << " is not public! " 5903 << "This will be a fatal error in subsequent versions of android. " 5904 << "Continuing anyway."; 5905 } 5906 if (UNLIKELY(chosen_iface.Get() != nullptr)) { 5907 // We have multiple default impls of the same method. This is a potential default conflict. 5908 // We need to check if this possibly conflicting method is either a superclass of the chosen 5909 // default implementation or is overridden by a non-default interface method. In either case 5910 // there is no conflict. 5911 if (!iface->IsAssignableFrom(chosen_iface.Get()) && 5912 !ContainsOverridingMethodOf(self, 5913 target_name_comparator, 5914 iftable, 5915 k, 5916 iface, 5917 image_pointer_size_)) { 5918 VLOG(class_linker) << "Conflicting default method implementations found: " 5919 << PrettyMethod(current_method) << " and " 5920 << PrettyMethod(*out_default_method) << " in class " 5921 << PrettyClass(klass.Get()) << " conflict."; 5922 *out_default_method = nullptr; 5923 return DefaultMethodSearchResult::kDefaultConflict; 5924 } else { 5925 break; // Continue checking at the next interface. 5926 } 5927 } else { 5928 // chosen_iface == null 5929 if (!ContainsOverridingMethodOf(self, 5930 target_name_comparator, 5931 iftable, 5932 k, 5933 iface, 5934 image_pointer_size_)) { 5935 // Don't set this as the chosen interface if something else is overriding it (because that 5936 // other interface would be potentially chosen instead if it was default). If the other 5937 // interface was abstract then we wouldn't select this interface as chosen anyway since 5938 // the abstract method masks it. 5939 *out_default_method = current_method; 5940 chosen_iface.Assign(iface.Get()); 5941 // We should now finish traversing the graph to find if we have default methods that 5942 // conflict. 5943 } else { 5944 VLOG(class_linker) << "A default method '" << PrettyMethod(current_method) << "' was " 5945 << "skipped because it was overridden by an abstract method in a " 5946 << "subinterface on class '" << PrettyClass(klass.Get()) << "'"; 5947 } 5948 } 5949 break; 5950 } 5951 } 5952 if (*out_default_method != nullptr) { 5953 VLOG(class_linker) << "Default method '" << PrettyMethod(*out_default_method) << "' selected " 5954 << "as the implementation for '" << PrettyMethod(target_method) << "' " 5955 << "in '" << PrettyClass(klass.Get()) << "'"; 5956 return DefaultMethodSearchResult::kDefaultFound; 5957 } else { 5958 return DefaultMethodSearchResult::kAbstractFound; 5959 } 5960} 5961 5962ArtMethod* ClassLinker::AddMethodToConflictTable(mirror::Class* klass, 5963 ArtMethod* conflict_method, 5964 ArtMethod* interface_method, 5965 ArtMethod* method, 5966 bool force_new_conflict_method) { 5967 ImtConflictTable* current_table = conflict_method->GetImtConflictTable(sizeof(void*)); 5968 Runtime* const runtime = Runtime::Current(); 5969 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader()); 5970 bool new_entry = conflict_method == runtime->GetImtConflictMethod() || force_new_conflict_method; 5971 5972 // Create a new entry if the existing one is the shared conflict method. 5973 ArtMethod* new_conflict_method = new_entry 5974 ? runtime->CreateImtConflictMethod(linear_alloc) 5975 : conflict_method; 5976 5977 // Allocate a new table. Note that we will leak this table at the next conflict, 5978 // but that's a tradeoff compared to making the table fixed size. 5979 void* data = linear_alloc->Alloc( 5980 Thread::Current(), ImtConflictTable::ComputeSizeWithOneMoreEntry(current_table, 5981 image_pointer_size_)); 5982 if (data == nullptr) { 5983 LOG(ERROR) << "Failed to allocate conflict table"; 5984 return conflict_method; 5985 } 5986 ImtConflictTable* new_table = new (data) ImtConflictTable(current_table, 5987 interface_method, 5988 method, 5989 image_pointer_size_); 5990 5991 // Do a fence to ensure threads see the data in the table before it is assigned 5992 // to the conflict method. 5993 // Note that there is a race in the presence of multiple threads and we may leak 5994 // memory from the LinearAlloc, but that's a tradeoff compared to using 5995 // atomic operations. 5996 QuasiAtomic::ThreadFenceRelease(); 5997 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_); 5998 return new_conflict_method; 5999} 6000 6001void ClassLinker::SetIMTRef(ArtMethod* unimplemented_method, 6002 ArtMethod* imt_conflict_method, 6003 ArtMethod* current_method, 6004 /*out*/ArtMethod** imt_ref) { 6005 // Place method in imt if entry is empty, place conflict otherwise. 6006 if (*imt_ref == unimplemented_method) { 6007 *imt_ref = current_method; 6008 } else if (!(*imt_ref)->IsRuntimeMethod()) { 6009 // If we are not a conflict and we have the same signature and name as the imt 6010 // entry, it must be that we overwrote a superclass vtable entry. 6011 // Note that we have checked IsRuntimeMethod, as there may be multiple different 6012 // conflict methods. 6013 MethodNameAndSignatureComparator imt_comparator( 6014 (*imt_ref)->GetInterfaceMethodIfProxy(image_pointer_size_)); 6015 if (imt_comparator.HasSameNameAndSignature( 6016 current_method->GetInterfaceMethodIfProxy(image_pointer_size_))) { 6017 *imt_ref = current_method; 6018 } else { 6019 *imt_ref = imt_conflict_method; 6020 } 6021 } else { 6022 // Place the default conflict method. Note that there may be an existing conflict 6023 // method in the IMT, but it could be one tailored to the super class, with a 6024 // specific ImtConflictTable. 6025 *imt_ref = imt_conflict_method; 6026 } 6027} 6028 6029void ClassLinker::FillIMTAndConflictTables(mirror::Class* klass) { 6030 DCHECK(klass->ShouldHaveEmbeddedImtAndVTable()) << PrettyClass(klass); 6031 DCHECK(!klass->IsTemp()) << PrettyClass(klass); 6032 ArtMethod* imt[mirror::Class::kImtSize]; 6033 Runtime* const runtime = Runtime::Current(); 6034 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod(); 6035 ArtMethod* const conflict_method = runtime->GetImtConflictMethod(); 6036 std::fill_n(imt, arraysize(imt), unimplemented_method); 6037 if (klass->GetIfTable() != nullptr) { 6038 FillIMTFromIfTable(klass->GetIfTable(), 6039 unimplemented_method, 6040 conflict_method, 6041 klass, 6042 true, 6043 false, 6044 &imt[0]); 6045 } 6046 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) { 6047 klass->SetEmbeddedImTableEntry(i, imt[i], image_pointer_size_); 6048 } 6049} 6050 6051static inline uint32_t GetIMTIndex(ArtMethod* interface_method) 6052 SHARED_REQUIRES(Locks::mutator_lock_) { 6053 return interface_method->GetDexMethodIndex() % mirror::Class::kImtSize; 6054} 6055 6056ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count, 6057 LinearAlloc* linear_alloc, 6058 size_t image_pointer_size) { 6059 void* data = linear_alloc->Alloc(Thread::Current(), 6060 ImtConflictTable::ComputeSize(count, 6061 image_pointer_size)); 6062 return (data != nullptr) ? new (data) ImtConflictTable(count, image_pointer_size) : nullptr; 6063} 6064 6065ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count, LinearAlloc* linear_alloc) { 6066 return CreateImtConflictTable(count, linear_alloc, image_pointer_size_); 6067} 6068 6069void ClassLinker::FillIMTFromIfTable(mirror::IfTable* if_table, 6070 ArtMethod* unimplemented_method, 6071 ArtMethod* imt_conflict_method, 6072 mirror::Class* klass, 6073 bool create_conflict_tables, 6074 bool ignore_copied_methods, 6075 ArtMethod** imt) { 6076 uint32_t conflict_counts[mirror::Class::kImtSize] = {}; 6077 for (size_t i = 0, length = if_table->Count(); i < length; ++i) { 6078 mirror::Class* interface = if_table->GetInterface(i); 6079 const size_t num_virtuals = interface->NumVirtualMethods(); 6080 const size_t method_array_count = if_table->GetMethodArrayCount(i); 6081 // Virtual methods can be larger than the if table methods if there are default methods. 6082 DCHECK_GE(num_virtuals, method_array_count); 6083 if (kIsDebugBuild) { 6084 if (klass->IsInterface()) { 6085 DCHECK_EQ(method_array_count, 0u); 6086 } else { 6087 DCHECK_EQ(interface->NumDeclaredVirtualMethods(), method_array_count); 6088 } 6089 } 6090 if (method_array_count == 0) { 6091 continue; 6092 } 6093 auto* method_array = if_table->GetMethodArray(i); 6094 for (size_t j = 0; j < method_array_count; ++j) { 6095 ArtMethod* implementation_method = 6096 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_); 6097 if (ignore_copied_methods && implementation_method->IsCopied()) { 6098 continue; 6099 } 6100 DCHECK(implementation_method != nullptr); 6101 // Miranda methods cannot be used to implement an interface method, but they are safe to put 6102 // in the IMT since their entrypoint is the interface trampoline. If we put any copied methods 6103 // or interface methods in the IMT here they will not create extra conflicts since we compare 6104 // names and signatures in SetIMTRef. 6105 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_); 6106 const uint32_t imt_index = GetIMTIndex(interface_method); 6107 6108 // There is only any conflicts if all of the interface methods for an IMT slot don't have 6109 // the same implementation method, keep track of this to avoid creating a conflict table in 6110 // this case. 6111 6112 // Conflict table size for each IMT slot. 6113 ++conflict_counts[imt_index]; 6114 6115 SetIMTRef(unimplemented_method, 6116 imt_conflict_method, 6117 implementation_method, 6118 /*out*/&imt[imt_index]); 6119 } 6120 } 6121 6122 if (create_conflict_tables) { 6123 // Create the conflict tables. 6124 LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader()); 6125 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) { 6126 size_t conflicts = conflict_counts[i]; 6127 if (imt[i] == imt_conflict_method) { 6128 ImtConflictTable* new_table = CreateImtConflictTable(conflicts, linear_alloc); 6129 if (new_table != nullptr) { 6130 ArtMethod* new_conflict_method = 6131 Runtime::Current()->CreateImtConflictMethod(linear_alloc); 6132 new_conflict_method->SetImtConflictTable(new_table, image_pointer_size_); 6133 imt[i] = new_conflict_method; 6134 } else { 6135 LOG(ERROR) << "Failed to allocate conflict table"; 6136 imt[i] = imt_conflict_method; 6137 } 6138 } else { 6139 DCHECK_NE(imt[i], imt_conflict_method); 6140 } 6141 } 6142 6143 for (size_t i = 0, length = if_table->Count(); i < length; ++i) { 6144 mirror::Class* interface = if_table->GetInterface(i); 6145 const size_t method_array_count = if_table->GetMethodArrayCount(i); 6146 // Virtual methods can be larger than the if table methods if there are default methods. 6147 if (method_array_count == 0) { 6148 continue; 6149 } 6150 auto* method_array = if_table->GetMethodArray(i); 6151 for (size_t j = 0; j < method_array_count; ++j) { 6152 ArtMethod* implementation_method = 6153 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_); 6154 if (ignore_copied_methods && implementation_method->IsCopied()) { 6155 continue; 6156 } 6157 DCHECK(implementation_method != nullptr); 6158 ArtMethod* interface_method = interface->GetVirtualMethod(j, image_pointer_size_); 6159 const uint32_t imt_index = GetIMTIndex(interface_method); 6160 if (!imt[imt_index]->IsRuntimeMethod() || 6161 imt[imt_index] == unimplemented_method || 6162 imt[imt_index] == imt_conflict_method) { 6163 continue; 6164 } 6165 ImtConflictTable* table = imt[imt_index]->GetImtConflictTable(image_pointer_size_); 6166 const size_t num_entries = table->NumEntries(image_pointer_size_); 6167 table->SetInterfaceMethod(num_entries, image_pointer_size_, interface_method); 6168 table->SetImplementationMethod(num_entries, image_pointer_size_, implementation_method); 6169 } 6170 } 6171 } 6172} 6173 6174// Simple helper function that checks that no subtypes of 'val' are contained within the 'classes' 6175// set. 6176static bool NotSubinterfaceOfAny(const std::unordered_set<mirror::Class*>& classes, 6177 mirror::Class* val) 6178 REQUIRES(Roles::uninterruptible_) 6179 SHARED_REQUIRES(Locks::mutator_lock_) { 6180 DCHECK(val != nullptr); 6181 for (auto c : classes) { 6182 if (val->IsAssignableFrom(&*c)) { 6183 return false; 6184 } 6185 } 6186 return true; 6187} 6188 6189// Fills in and flattens the interface inheritance hierarchy. 6190// 6191// By the end of this function all interfaces in the transitive closure of to_process are added to 6192// the iftable and every interface precedes all of its sub-interfaces in this list. 6193// 6194// all I, J: Interface | I <: J implies J precedes I 6195// 6196// (note A <: B means that A is a subtype of B) 6197// 6198// This returns the total number of items in the iftable. The iftable might be resized down after 6199// this call. 6200// 6201// We order this backwards so that we do not need to reorder superclass interfaces when new 6202// interfaces are added in subclass's interface tables. 6203// 6204// Upon entry into this function iftable is a copy of the superclass's iftable with the first 6205// super_ifcount entries filled in with the transitive closure of the interfaces of the superclass. 6206// The other entries are uninitialized. We will fill in the remaining entries in this function. The 6207// iftable must be large enough to hold all interfaces without changing its size. 6208static size_t FillIfTable(mirror::IfTable* iftable, 6209 size_t super_ifcount, 6210 std::vector<mirror::Class*> to_process) 6211 REQUIRES(Roles::uninterruptible_) 6212 SHARED_REQUIRES(Locks::mutator_lock_) { 6213 // This is the set of all class's already in the iftable. Used to make checking if a class has 6214 // already been added quicker. 6215 std::unordered_set<mirror::Class*> classes_in_iftable; 6216 // The first super_ifcount elements are from the superclass. We note that they are already added. 6217 for (size_t i = 0; i < super_ifcount; i++) { 6218 mirror::Class* iface = iftable->GetInterface(i); 6219 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, iface)) << "Bad ordering."; 6220 classes_in_iftable.insert(iface); 6221 } 6222 size_t filled_ifcount = super_ifcount; 6223 for (mirror::Class* interface : to_process) { 6224 // Let us call the first filled_ifcount elements of iftable the current-iface-list. 6225 // At this point in the loop current-iface-list has the invariant that: 6226 // for every pair of interfaces I,J within it: 6227 // if index_of(I) < index_of(J) then I is not a subtype of J 6228 6229 // If we have already seen this element then all of its super-interfaces must already be in the 6230 // current-iface-list so we can skip adding it. 6231 if (!ContainsElement(classes_in_iftable, interface)) { 6232 // We haven't seen this interface so add all of its super-interfaces onto the 6233 // current-iface-list, skipping those already on it. 6234 int32_t ifcount = interface->GetIfTableCount(); 6235 for (int32_t j = 0; j < ifcount; j++) { 6236 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j); 6237 if (!ContainsElement(classes_in_iftable, super_interface)) { 6238 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, super_interface)) << "Bad ordering."; 6239 classes_in_iftable.insert(super_interface); 6240 iftable->SetInterface(filled_ifcount, super_interface); 6241 filled_ifcount++; 6242 } 6243 } 6244 DCHECK(NotSubinterfaceOfAny(classes_in_iftable, interface)) << "Bad ordering"; 6245 // Place this interface onto the current-iface-list after all of its super-interfaces. 6246 classes_in_iftable.insert(interface); 6247 iftable->SetInterface(filled_ifcount, interface); 6248 filled_ifcount++; 6249 } else if (kIsDebugBuild) { 6250 // Check all super-interfaces are already in the list. 6251 int32_t ifcount = interface->GetIfTableCount(); 6252 for (int32_t j = 0; j < ifcount; j++) { 6253 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j); 6254 DCHECK(ContainsElement(classes_in_iftable, super_interface)) 6255 << "Iftable does not contain " << PrettyClass(super_interface) 6256 << ", a superinterface of " << PrettyClass(interface); 6257 } 6258 } 6259 } 6260 if (kIsDebugBuild) { 6261 // Check that the iftable is ordered correctly. 6262 for (size_t i = 0; i < filled_ifcount; i++) { 6263 mirror::Class* if_a = iftable->GetInterface(i); 6264 for (size_t j = i + 1; j < filled_ifcount; j++) { 6265 mirror::Class* if_b = iftable->GetInterface(j); 6266 // !(if_a <: if_b) 6267 CHECK(!if_b->IsAssignableFrom(if_a)) 6268 << "Bad interface order: " << PrettyClass(if_a) << " (index " << i << ") extends " 6269 << PrettyClass(if_b) << " (index " << j << ") and so should be after it in the " 6270 << "interface list."; 6271 } 6272 } 6273 } 6274 return filled_ifcount; 6275} 6276 6277bool ClassLinker::SetupInterfaceLookupTable(Thread* self, Handle<mirror::Class> klass, 6278 Handle<mirror::ObjectArray<mirror::Class>> interfaces) { 6279 StackHandleScope<1> hs(self); 6280 const size_t super_ifcount = 6281 klass->HasSuperClass() ? klass->GetSuperClass()->GetIfTableCount() : 0U; 6282 const bool have_interfaces = interfaces.Get() != nullptr; 6283 const size_t num_interfaces = 6284 have_interfaces ? interfaces->GetLength() : klass->NumDirectInterfaces(); 6285 if (num_interfaces == 0) { 6286 if (super_ifcount == 0) { 6287 // Class implements no interfaces. 6288 DCHECK_EQ(klass->GetIfTableCount(), 0); 6289 DCHECK(klass->GetIfTable() == nullptr); 6290 return true; 6291 } 6292 // Class implements same interfaces as parent, are any of these not marker interfaces? 6293 bool has_non_marker_interface = false; 6294 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable(); 6295 for (size_t i = 0; i < super_ifcount; ++i) { 6296 if (super_iftable->GetMethodArrayCount(i) > 0) { 6297 has_non_marker_interface = true; 6298 break; 6299 } 6300 } 6301 // Class just inherits marker interfaces from parent so recycle parent's iftable. 6302 if (!has_non_marker_interface) { 6303 klass->SetIfTable(super_iftable); 6304 return true; 6305 } 6306 } 6307 size_t ifcount = super_ifcount + num_interfaces; 6308 // Check that every class being implemented is an interface. 6309 for (size_t i = 0; i < num_interfaces; i++) { 6310 mirror::Class* interface = have_interfaces 6311 ? interfaces->GetWithoutChecks(i) 6312 : mirror::Class::GetDirectInterface(self, klass, i); 6313 DCHECK(interface != nullptr); 6314 if (UNLIKELY(!interface->IsInterface())) { 6315 std::string temp; 6316 ThrowIncompatibleClassChangeError(klass.Get(), 6317 "Class %s implements non-interface class %s", 6318 PrettyDescriptor(klass.Get()).c_str(), 6319 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str()); 6320 return false; 6321 } 6322 ifcount += interface->GetIfTableCount(); 6323 } 6324 // Create the interface function table. 6325 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount))); 6326 if (UNLIKELY(iftable.Get() == nullptr)) { 6327 self->AssertPendingOOMException(); 6328 return false; 6329 } 6330 // Fill in table with superclass's iftable. 6331 if (super_ifcount != 0) { 6332 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable(); 6333 for (size_t i = 0; i < super_ifcount; i++) { 6334 mirror::Class* super_interface = super_iftable->GetInterface(i); 6335 iftable->SetInterface(i, super_interface); 6336 } 6337 } 6338 6339 // Note that AllowThreadSuspension is to thread suspension as pthread_testcancel is to pthread 6340 // cancellation. That is it will suspend if one has a pending suspend request but otherwise 6341 // doesn't really do anything. 6342 self->AllowThreadSuspension(); 6343 6344 size_t new_ifcount; 6345 { 6346 ScopedAssertNoThreadSuspension nts(self, "Copying mirror::Class*'s for FillIfTable"); 6347 std::vector<mirror::Class*> to_add; 6348 for (size_t i = 0; i < num_interfaces; i++) { 6349 mirror::Class* interface = have_interfaces ? interfaces->Get(i) : 6350 mirror::Class::GetDirectInterface(self, klass, i); 6351 to_add.push_back(interface); 6352 } 6353 6354 new_ifcount = FillIfTable(iftable.Get(), super_ifcount, std::move(to_add)); 6355 } 6356 6357 self->AllowThreadSuspension(); 6358 6359 // Shrink iftable in case duplicates were found 6360 if (new_ifcount < ifcount) { 6361 DCHECK_NE(num_interfaces, 0U); 6362 iftable.Assign(down_cast<mirror::IfTable*>( 6363 iftable->CopyOf(self, new_ifcount * mirror::IfTable::kMax))); 6364 if (UNLIKELY(iftable.Get() == nullptr)) { 6365 self->AssertPendingOOMException(); 6366 return false; 6367 } 6368 ifcount = new_ifcount; 6369 } else { 6370 DCHECK_EQ(new_ifcount, ifcount); 6371 } 6372 klass->SetIfTable(iftable.Get()); 6373 return true; 6374} 6375 6376// Finds the method with a name/signature that matches cmp in the given list of methods. The list of 6377// methods must be unique. 6378static ArtMethod* FindSameNameAndSignature(MethodNameAndSignatureComparator& cmp, 6379 const ScopedArenaVector<ArtMethod*>& list) 6380 SHARED_REQUIRES(Locks::mutator_lock_) { 6381 for (ArtMethod* method : list) { 6382 if (cmp.HasSameNameAndSignature(method)) { 6383 return method; 6384 } 6385 } 6386 return nullptr; 6387} 6388 6389static void SanityCheckVTable(Handle<mirror::Class> klass, uint32_t pointer_size) 6390 SHARED_REQUIRES(Locks::mutator_lock_) { 6391 mirror::PointerArray* check_vtable = klass->GetVTableDuringLinking(); 6392 mirror::Class* superclass = (klass->HasSuperClass()) ? klass->GetSuperClass() : nullptr; 6393 int32_t super_vtable_length = (superclass != nullptr) ? superclass->GetVTableLength() : 0; 6394 for (int32_t i = 0; i < check_vtable->GetLength(); ++i) { 6395 ArtMethod* m = check_vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size); 6396 CHECK(m != nullptr); 6397 6398 ArraySlice<ArtMethod> virtuals = klass->GetVirtualMethodsSliceUnchecked(pointer_size); 6399 auto is_same_method = [m] (const ArtMethod& meth) { 6400 return &meth == m; 6401 }; 6402 CHECK((super_vtable_length > i && superclass->GetVTableEntry(i, pointer_size) == m) || 6403 std::find_if(virtuals.begin(), virtuals.end(), is_same_method) != virtuals.end()) 6404 << "While linking class '" << PrettyClass(klass.Get()) << "' unable to find owning class " 6405 << "of '" << PrettyMethod(m) << "' (vtable index: " << i << ")."; 6406 } 6407} 6408 6409void ClassLinker::FillImtFromSuperClass(Handle<mirror::Class> klass, 6410 ArtMethod* unimplemented_method, 6411 ArtMethod* imt_conflict_method, 6412 ArtMethod** imt) { 6413 DCHECK(klass->HasSuperClass()); 6414 mirror::Class* super_class = klass->GetSuperClass(); 6415 if (super_class->ShouldHaveEmbeddedImtAndVTable()) { 6416 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) { 6417 imt[i] = super_class->GetEmbeddedImTableEntry(i, image_pointer_size_); 6418 } 6419 } else { 6420 // No imt in the super class, need to reconstruct from the iftable. 6421 mirror::IfTable* if_table = super_class->GetIfTable(); 6422 if (if_table != nullptr) { 6423 // Ignore copied methods since we will handle these in LinkInterfaceMethods. 6424 FillIMTFromIfTable(if_table, 6425 unimplemented_method, 6426 imt_conflict_method, 6427 klass.Get(), 6428 /*create_conflict_table*/false, 6429 /*ignore_copied_methods*/true, 6430 /*out*/imt); 6431 } 6432 } 6433} 6434 6435// TODO This method needs to be split up into several smaller methods. 6436bool ClassLinker::LinkInterfaceMethods( 6437 Thread* self, 6438 Handle<mirror::Class> klass, 6439 const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations, 6440 ArtMethod** out_imt) { 6441 StackHandleScope<3> hs(self); 6442 Runtime* const runtime = Runtime::Current(); 6443 6444 const bool is_interface = klass->IsInterface(); 6445 const bool has_superclass = klass->HasSuperClass(); 6446 const bool fill_tables = !is_interface; 6447 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U; 6448 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_); 6449 const size_t method_size = ArtMethod::Size(image_pointer_size_); 6450 const size_t ifcount = klass->GetIfTableCount(); 6451 6452 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(klass->GetIfTable())); 6453 6454 // These are allocated on the heap to begin, we then transfer to linear alloc when we re-create 6455 // the virtual methods array. 6456 // Need to use low 4GB arenas for compiler or else the pointers wont fit in 32 bit method array 6457 // during cross compilation. 6458 // Use the linear alloc pool since this one is in the low 4gb for the compiler. 6459 ArenaStack stack(runtime->GetLinearAlloc()->GetArenaPool()); 6460 ScopedArenaAllocator allocator(&stack); 6461 6462 ScopedArenaVector<ArtMethod*> default_conflict_methods(allocator.Adapter()); 6463 ScopedArenaVector<ArtMethod*> miranda_methods(allocator.Adapter()); 6464 ScopedArenaVector<ArtMethod*> default_methods(allocator.Adapter()); 6465 6466 MutableHandle<mirror::PointerArray> vtable(hs.NewHandle(klass->GetVTableDuringLinking())); 6467 ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod(); 6468 ArtMethod* const imt_conflict_method = runtime->GetImtConflictMethod(); 6469 // Copy the IMT from the super class if possible. 6470 const bool extend_super_iftable = has_superclass; 6471 if (has_superclass && fill_tables) { 6472 FillImtFromSuperClass(klass, 6473 unimplemented_method, 6474 imt_conflict_method, 6475 out_imt); 6476 } 6477 // Allocate method arrays before since we don't want miss visiting miranda method roots due to 6478 // thread suspension. 6479 if (fill_tables) { 6480 for (size_t i = 0; i < ifcount; ++i) { 6481 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods(); 6482 if (num_methods > 0) { 6483 const bool is_super = i < super_ifcount; 6484 // This is an interface implemented by a super-class. Therefore we can just copy the method 6485 // array from the superclass. 6486 const bool super_interface = is_super && extend_super_iftable; 6487 mirror::PointerArray* method_array; 6488 if (super_interface) { 6489 mirror::IfTable* if_table = klass->GetSuperClass()->GetIfTable(); 6490 DCHECK(if_table != nullptr); 6491 DCHECK(if_table->GetMethodArray(i) != nullptr); 6492 // If we are working on a super interface, try extending the existing method array. 6493 method_array = down_cast<mirror::PointerArray*>(if_table->GetMethodArray(i)->Clone(self)); 6494 } else { 6495 method_array = AllocPointerArray(self, num_methods); 6496 } 6497 if (UNLIKELY(method_array == nullptr)) { 6498 self->AssertPendingOOMException(); 6499 return false; 6500 } 6501 iftable->SetMethodArray(i, method_array); 6502 } 6503 } 6504 } 6505 6506 auto* old_cause = self->StartAssertNoThreadSuspension( 6507 "Copying ArtMethods for LinkInterfaceMethods"); 6508 // Going in reverse to ensure that we will hit abstract methods that override defaults before the 6509 // defaults. This means we don't need to do any trickery when creating the Miranda methods, since 6510 // they will already be null. This has the additional benefit that the declarer of a miranda 6511 // method will actually declare an abstract method. 6512 for (size_t i = ifcount; i != 0; ) { 6513 --i; 6514 6515 DCHECK_GE(i, 0u); 6516 DCHECK_LT(i, ifcount); 6517 6518 size_t num_methods = iftable->GetInterface(i)->NumDeclaredVirtualMethods(); 6519 if (num_methods > 0) { 6520 StackHandleScope<2> hs2(self); 6521 const bool is_super = i < super_ifcount; 6522 const bool super_interface = is_super && extend_super_iftable; 6523 // We don't actually create or fill these tables for interfaces, we just copy some methods for 6524 // conflict methods. Just set this as nullptr in those cases. 6525 Handle<mirror::PointerArray> method_array(fill_tables 6526 ? hs2.NewHandle(iftable->GetMethodArray(i)) 6527 : hs2.NewHandle<mirror::PointerArray>(nullptr)); 6528 6529 ArraySlice<ArtMethod> input_virtual_methods; 6530 ScopedNullHandle<mirror::PointerArray> null_handle; 6531 Handle<mirror::PointerArray> input_vtable_array(null_handle); 6532 int32_t input_array_length = 0; 6533 6534 // TODO Cleanup Needed: In the presence of default methods this optimization is rather dirty 6535 // and confusing. Default methods should always look through all the superclasses 6536 // because they are the last choice of an implementation. We get around this by looking 6537 // at the super-classes iftable methods (copied into method_array previously) when we are 6538 // looking for the implementation of a super-interface method but that is rather dirty. 6539 bool using_virtuals; 6540 if (super_interface || is_interface) { 6541 // If we are overwriting a super class interface, try to only virtual methods instead of the 6542 // whole vtable. 6543 using_virtuals = true; 6544 input_virtual_methods = klass->GetDeclaredMethodsSlice(image_pointer_size_); 6545 input_array_length = input_virtual_methods.size(); 6546 } else { 6547 // For a new interface, however, we need the whole vtable in case a new 6548 // interface method is implemented in the whole superclass. 6549 using_virtuals = false; 6550 DCHECK(vtable.Get() != nullptr); 6551 input_vtable_array = vtable; 6552 input_array_length = input_vtable_array->GetLength(); 6553 } 6554 6555 // For each method in interface 6556 for (size_t j = 0; j < num_methods; ++j) { 6557 auto* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j, image_pointer_size_); 6558 MethodNameAndSignatureComparator interface_name_comparator( 6559 interface_method->GetInterfaceMethodIfProxy(image_pointer_size_)); 6560 uint32_t imt_index = GetIMTIndex(interface_method); 6561 ArtMethod** imt_ptr = &out_imt[imt_index]; 6562 // For each method listed in the interface's method list, find the 6563 // matching method in our class's method list. We want to favor the 6564 // subclass over the superclass, which just requires walking 6565 // back from the end of the vtable. (This only matters if the 6566 // superclass defines a private method and this class redefines 6567 // it -- otherwise it would use the same vtable slot. In .dex files 6568 // those don't end up in the virtual method table, so it shouldn't 6569 // matter which direction we go. We walk it backward anyway.) 6570 // 6571 // To find defaults we need to do the same but also go over interfaces. 6572 bool found_impl = false; 6573 ArtMethod* vtable_impl = nullptr; 6574 for (int32_t k = input_array_length - 1; k >= 0; --k) { 6575 ArtMethod* vtable_method = using_virtuals ? 6576 &input_virtual_methods[k] : 6577 input_vtable_array->GetElementPtrSize<ArtMethod*>(k, image_pointer_size_); 6578 ArtMethod* vtable_method_for_name_comparison = 6579 vtable_method->GetInterfaceMethodIfProxy(image_pointer_size_); 6580 if (interface_name_comparator.HasSameNameAndSignature( 6581 vtable_method_for_name_comparison)) { 6582 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) { 6583 // Must do EndAssertNoThreadSuspension before throw since the throw can cause 6584 // allocations. 6585 self->EndAssertNoThreadSuspension(old_cause); 6586 ThrowIllegalAccessError(klass.Get(), 6587 "Method '%s' implementing interface method '%s' is not public", 6588 PrettyMethod(vtable_method).c_str(), PrettyMethod(interface_method).c_str()); 6589 return false; 6590 } else if (UNLIKELY(vtable_method->IsOverridableByDefaultMethod())) { 6591 // We might have a newer, better, default method for this, so we just skip it. If we 6592 // are still using this we will select it again when scanning for default methods. To 6593 // obviate the need to copy the method again we will make a note that we already found 6594 // a default here. 6595 // TODO This should be much cleaner. 6596 vtable_impl = vtable_method; 6597 break; 6598 } else { 6599 found_impl = true; 6600 if (LIKELY(fill_tables)) { 6601 method_array->SetElementPtrSize(j, vtable_method, image_pointer_size_); 6602 // Place method in imt if entry is empty, place conflict otherwise. 6603 SetIMTRef(unimplemented_method, 6604 imt_conflict_method, 6605 vtable_method, 6606 /*out*/imt_ptr); 6607 } 6608 break; 6609 } 6610 } 6611 } 6612 // Continue on to the next method if we are done. 6613 if (LIKELY(found_impl)) { 6614 continue; 6615 } else if (LIKELY(super_interface)) { 6616 // Don't look for a default implementation when the super-method is implemented directly 6617 // by the class. 6618 // 6619 // See if we can use the superclasses method and skip searching everything else. 6620 // Note: !found_impl && super_interface 6621 CHECK(extend_super_iftable); 6622 // If this is a super_interface method it is possible we shouldn't override it because a 6623 // superclass could have implemented it directly. We get the method the superclass used 6624 // to implement this to know if we can override it with a default method. Doing this is 6625 // safe since we know that the super_iftable is filled in so we can simply pull it from 6626 // there. We don't bother if this is not a super-classes interface since in that case we 6627 // have scanned the entire vtable anyway and would have found it. 6628 // TODO This is rather dirty but it is faster than searching through the entire vtable 6629 // every time. 6630 ArtMethod* supers_method = 6631 method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_); 6632 DCHECK(supers_method != nullptr); 6633 DCHECK(interface_name_comparator.HasSameNameAndSignature(supers_method)); 6634 if (LIKELY(!supers_method->IsOverridableByDefaultMethod())) { 6635 // The method is not overridable by a default method (i.e. it is directly implemented 6636 // in some class). Therefore move onto the next interface method. 6637 continue; 6638 } 6639 } 6640 // If we haven't found it yet we should search through the interfaces for default methods. 6641 ArtMethod* current_method = nullptr; 6642 switch (FindDefaultMethodImplementation(self, 6643 interface_method, 6644 klass, 6645 /*out*/¤t_method)) { 6646 case DefaultMethodSearchResult::kDefaultConflict: { 6647 // Default method conflict. 6648 DCHECK(current_method == nullptr); 6649 ArtMethod* default_conflict_method = nullptr; 6650 if (vtable_impl != nullptr && vtable_impl->IsDefaultConflicting()) { 6651 // We can reuse the method from the superclass, don't bother adding it to virtuals. 6652 default_conflict_method = vtable_impl; 6653 } else { 6654 // See if we already have a conflict method for this method. 6655 ArtMethod* preexisting_conflict = FindSameNameAndSignature(interface_name_comparator, 6656 default_conflict_methods); 6657 if (LIKELY(preexisting_conflict != nullptr)) { 6658 // We already have another conflict we can reuse. 6659 default_conflict_method = preexisting_conflict; 6660 } else { 6661 // Note that we do this even if we are an interface since we need to create this and 6662 // cannot reuse another classes. 6663 // Create a new conflict method for this to use. 6664 default_conflict_method = 6665 reinterpret_cast<ArtMethod*>(allocator.Alloc(method_size)); 6666 new(default_conflict_method) ArtMethod(interface_method, image_pointer_size_); 6667 default_conflict_methods.push_back(default_conflict_method); 6668 } 6669 } 6670 current_method = default_conflict_method; 6671 break; 6672 } // case kDefaultConflict 6673 case DefaultMethodSearchResult::kDefaultFound: { 6674 DCHECK(current_method != nullptr); 6675 // Found a default method. 6676 if (vtable_impl != nullptr && 6677 current_method->GetDeclaringClass() == vtable_impl->GetDeclaringClass()) { 6678 // We found a default method but it was the same one we already have from our 6679 // superclass. Don't bother adding it to our vtable again. 6680 current_method = vtable_impl; 6681 } else if (LIKELY(fill_tables)) { 6682 // Interfaces don't need to copy default methods since they don't have vtables. 6683 // Only record this default method if it is new to save space. 6684 // TODO It might be worthwhile to copy default methods on interfaces anyway since it 6685 // would make lookup for interface super much faster. (We would only need to scan 6686 // the iftable to find if there is a NSME or AME.) 6687 ArtMethod* old = FindSameNameAndSignature(interface_name_comparator, default_methods); 6688 if (old == nullptr) { 6689 // We found a default method implementation and there were no conflicts. 6690 // Save the default method. We need to add it to the vtable. 6691 default_methods.push_back(current_method); 6692 } else { 6693 CHECK(old == current_method) << "Multiple default implementations selected!"; 6694 } 6695 } 6696 break; 6697 } // case kDefaultFound 6698 case DefaultMethodSearchResult::kAbstractFound: { 6699 DCHECK(current_method == nullptr); 6700 // Abstract method masks all defaults. 6701 if (vtable_impl != nullptr && 6702 vtable_impl->IsAbstract() && 6703 !vtable_impl->IsDefaultConflicting()) { 6704 // We need to make this an abstract method but the version in the vtable already is so 6705 // don't do anything. 6706 current_method = vtable_impl; 6707 } 6708 break; 6709 } // case kAbstractFound 6710 } 6711 if (LIKELY(fill_tables)) { 6712 if (current_method == nullptr && !super_interface) { 6713 // We could not find an implementation for this method and since it is a brand new 6714 // interface we searched the entire vtable (and all default methods) for an 6715 // implementation but couldn't find one. We therefore need to make a miranda method. 6716 // 6717 // Find out if there is already a miranda method we can use. 6718 ArtMethod* miranda_method = FindSameNameAndSignature(interface_name_comparator, 6719 miranda_methods); 6720 if (miranda_method == nullptr) { 6721 DCHECK(interface_method->IsAbstract()) << PrettyMethod(interface_method); 6722 miranda_method = reinterpret_cast<ArtMethod*>(allocator.Alloc(method_size)); 6723 CHECK(miranda_method != nullptr); 6724 // Point the interface table at a phantom slot. 6725 new(miranda_method) ArtMethod(interface_method, image_pointer_size_); 6726 miranda_methods.push_back(miranda_method); 6727 } 6728 current_method = miranda_method; 6729 } 6730 6731 if (current_method != nullptr) { 6732 // We found a default method implementation. Record it in the iftable and IMT. 6733 method_array->SetElementPtrSize(j, current_method, image_pointer_size_); 6734 SetIMTRef(unimplemented_method, 6735 imt_conflict_method, 6736 current_method, 6737 /*out*/imt_ptr); 6738 } 6739 } 6740 } // For each method in interface end. 6741 } // if (num_methods > 0) 6742 } // For each interface. 6743 const bool has_new_virtuals = !(miranda_methods.empty() && 6744 default_methods.empty() && 6745 default_conflict_methods.empty()); 6746 // TODO don't extend virtuals of interface unless necessary (when is it?). 6747 if (has_new_virtuals) { 6748 DCHECK(!is_interface || (default_methods.empty() && miranda_methods.empty())) 6749 << "Interfaces should only have default-conflict methods appended to them."; 6750 VLOG(class_linker) << PrettyClass(klass.Get()) << ": miranda_methods=" << miranda_methods.size() 6751 << " default_methods=" << default_methods.size() 6752 << " default_conflict_methods=" << default_conflict_methods.size(); 6753 const size_t old_method_count = klass->NumMethods(); 6754 const size_t new_method_count = old_method_count + 6755 miranda_methods.size() + 6756 default_methods.size() + 6757 default_conflict_methods.size(); 6758 // Attempt to realloc to save RAM if possible. 6759 LengthPrefixedArray<ArtMethod>* old_methods = klass->GetMethodsPtr(); 6760 // The Realloced virtual methods aren't visible from the class roots, so there is no issue 6761 // where GCs could attempt to mark stale pointers due to memcpy. And since we overwrite the 6762 // realloced memory with out->CopyFrom, we are guaranteed to have objects in the to space since 6763 // CopyFrom has internal read barriers. 6764 // 6765 // TODO We should maybe move some of this into mirror::Class or at least into another method. 6766 const size_t old_size = LengthPrefixedArray<ArtMethod>::ComputeSize(old_method_count, 6767 method_size, 6768 method_alignment); 6769 const size_t new_size = LengthPrefixedArray<ArtMethod>::ComputeSize(new_method_count, 6770 method_size, 6771 method_alignment); 6772 const size_t old_methods_ptr_size = (old_methods != nullptr) ? old_size : 0; 6773 auto* methods = reinterpret_cast<LengthPrefixedArray<ArtMethod>*>( 6774 runtime->GetLinearAlloc()->Realloc(self, old_methods, old_methods_ptr_size, new_size)); 6775 if (UNLIKELY(methods == nullptr)) { 6776 self->AssertPendingOOMException(); 6777 self->EndAssertNoThreadSuspension(old_cause); 6778 return false; 6779 } 6780 ScopedArenaUnorderedMap<ArtMethod*, ArtMethod*> move_table(allocator.Adapter()); 6781 if (methods != old_methods) { 6782 // Maps from heap allocated miranda method to linear alloc miranda method. 6783 StrideIterator<ArtMethod> out = methods->begin(method_size, method_alignment); 6784 // Copy over the old methods. 6785 for (auto& m : klass->GetMethods(image_pointer_size_)) { 6786 move_table.emplace(&m, &*out); 6787 // The CopyFrom is only necessary to not miss read barriers since Realloc won't do read 6788 // barriers when it copies. 6789 out->CopyFrom(&m, image_pointer_size_); 6790 ++out; 6791 } 6792 } 6793 StrideIterator<ArtMethod> out(methods->begin(method_size, method_alignment) + old_method_count); 6794 // Copy over miranda methods before copying vtable since CopyOf may cause thread suspension and 6795 // we want the roots of the miranda methods to get visited. 6796 for (ArtMethod* mir_method : miranda_methods) { 6797 ArtMethod& new_method = *out; 6798 new_method.CopyFrom(mir_method, image_pointer_size_); 6799 new_method.SetAccessFlags(new_method.GetAccessFlags() | kAccMiranda | kAccCopied); 6800 DCHECK_NE(new_method.GetAccessFlags() & kAccAbstract, 0u) 6801 << "Miranda method should be abstract!"; 6802 move_table.emplace(mir_method, &new_method); 6803 ++out; 6804 } 6805 // We need to copy the default methods into our own method table since the runtime requires that 6806 // every method on a class's vtable be in that respective class's virtual method table. 6807 // NOTE This means that two classes might have the same implementation of a method from the same 6808 // interface but will have different ArtMethod*s for them. This also means we cannot compare a 6809 // default method found on a class with one found on the declaring interface directly and must 6810 // look at the declaring class to determine if they are the same. 6811 for (ArtMethod* def_method : default_methods) { 6812 ArtMethod& new_method = *out; 6813 new_method.CopyFrom(def_method, image_pointer_size_); 6814 // Clear the kAccSkipAccessChecks flag if it is present. Since this class hasn't been verified 6815 // yet it shouldn't have methods that are skipping access checks. 6816 // TODO This is rather arbitrary. We should maybe support classes where only some of its 6817 // methods are skip_access_checks. 6818 constexpr uint32_t kSetFlags = kAccDefault | kAccCopied; 6819 constexpr uint32_t kMaskFlags = ~kAccSkipAccessChecks; 6820 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags); 6821 move_table.emplace(def_method, &new_method); 6822 ++out; 6823 } 6824 for (ArtMethod* conf_method : default_conflict_methods) { 6825 ArtMethod& new_method = *out; 6826 new_method.CopyFrom(conf_method, image_pointer_size_); 6827 // This is a type of default method (there are default method impls, just a conflict) so mark 6828 // this as a default, non-abstract method, since thats what it is. Also clear the 6829 // kAccSkipAccessChecks bit since this class hasn't been verified yet it shouldn't have 6830 // methods that are skipping access checks. 6831 constexpr uint32_t kSetFlags = kAccDefault | kAccDefaultConflict | kAccCopied; 6832 constexpr uint32_t kMaskFlags = ~(kAccAbstract | kAccSkipAccessChecks); 6833 new_method.SetAccessFlags((new_method.GetAccessFlags() | kSetFlags) & kMaskFlags); 6834 DCHECK(new_method.IsDefaultConflicting()); 6835 // The actual method might or might not be marked abstract since we just copied it from a 6836 // (possibly default) interface method. We need to set it entry point to be the bridge so that 6837 // the compiler will not invoke the implementation of whatever method we copied from. 6838 EnsureThrowsInvocationError(&new_method); 6839 move_table.emplace(conf_method, &new_method); 6840 ++out; 6841 } 6842 methods->SetSize(new_method_count); 6843 UpdateClassMethods(klass.Get(), methods); 6844 // Done copying methods, they are all roots in the class now, so we can end the no thread 6845 // suspension assert. 6846 self->EndAssertNoThreadSuspension(old_cause); 6847 6848 if (fill_tables) { 6849 // Update the vtable to the new method structures. We can skip this for interfaces since they 6850 // do not have vtables. 6851 const size_t old_vtable_count = vtable->GetLength(); 6852 const size_t new_vtable_count = old_vtable_count + 6853 miranda_methods.size() + 6854 default_methods.size() + 6855 default_conflict_methods.size(); 6856 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, new_vtable_count))); 6857 if (UNLIKELY(vtable.Get() == nullptr)) { 6858 self->AssertPendingOOMException(); 6859 return false; 6860 } 6861 out = methods->begin(method_size, method_alignment) + old_method_count; 6862 size_t vtable_pos = old_vtable_count; 6863 // Update all the newly copied method's indexes so they denote their placement in the vtable. 6864 for (size_t i = old_method_count; i < new_method_count; ++i) { 6865 // Leave the declaring class alone the method's dex_code_item_offset_ and dex_method_index_ 6866 // fields are references into the dex file the method was defined in. Since the ArtMethod 6867 // does not store that information it uses declaring_class_->dex_cache_. 6868 out->SetMethodIndex(0xFFFF & vtable_pos); 6869 vtable->SetElementPtrSize(vtable_pos, &*out, image_pointer_size_); 6870 ++out; 6871 ++vtable_pos; 6872 } 6873 CHECK_EQ(vtable_pos, new_vtable_count); 6874 // Update old vtable methods. We use the default_translations map to figure out what each 6875 // vtable entry should be updated to, if they need to be at all. 6876 for (size_t i = 0; i < old_vtable_count; ++i) { 6877 ArtMethod* translated_method = vtable->GetElementPtrSize<ArtMethod*>( 6878 i, image_pointer_size_); 6879 // Try and find what we need to change this method to. 6880 auto translation_it = default_translations.find(i); 6881 bool found_translation = false; 6882 if (translation_it != default_translations.end()) { 6883 if (translation_it->second.IsInConflict()) { 6884 // Find which conflict method we are to use for this method. 6885 MethodNameAndSignatureComparator old_method_comparator( 6886 translated_method->GetInterfaceMethodIfProxy(image_pointer_size_)); 6887 ArtMethod* new_conflict_method = FindSameNameAndSignature(old_method_comparator, 6888 default_conflict_methods); 6889 CHECK(new_conflict_method != nullptr) << "Expected a conflict method!"; 6890 translated_method = new_conflict_method; 6891 } else if (translation_it->second.IsAbstract()) { 6892 // Find which miranda method we are to use for this method. 6893 MethodNameAndSignatureComparator old_method_comparator( 6894 translated_method->GetInterfaceMethodIfProxy(image_pointer_size_)); 6895 ArtMethod* miranda_method = FindSameNameAndSignature(old_method_comparator, 6896 miranda_methods); 6897 DCHECK(miranda_method != nullptr); 6898 translated_method = miranda_method; 6899 } else { 6900 // Normal default method (changed from an older default or abstract interface method). 6901 DCHECK(translation_it->second.IsTranslation()); 6902 translated_method = translation_it->second.GetTranslation(); 6903 } 6904 found_translation = true; 6905 } 6906 DCHECK(translated_method != nullptr); 6907 auto it = move_table.find(translated_method); 6908 if (it != move_table.end()) { 6909 auto* new_method = it->second; 6910 DCHECK(new_method != nullptr); 6911 vtable->SetElementPtrSize(i, new_method, image_pointer_size_); 6912 } else { 6913 // If it was not going to be updated we wouldn't have put it into the default_translations 6914 // map. 6915 CHECK(!found_translation) << "We were asked to update this vtable entry. Must not fail."; 6916 } 6917 } 6918 klass->SetVTable(vtable.Get()); 6919 6920 // Go fix up all the stale iftable pointers. 6921 for (size_t i = 0; i < ifcount; ++i) { 6922 for (size_t j = 0, count = iftable->GetMethodArrayCount(i); j < count; ++j) { 6923 auto* method_array = iftable->GetMethodArray(i); 6924 auto* m = method_array->GetElementPtrSize<ArtMethod*>(j, image_pointer_size_); 6925 DCHECK(m != nullptr) << PrettyClass(klass.Get()); 6926 auto it = move_table.find(m); 6927 if (it != move_table.end()) { 6928 auto* new_m = it->second; 6929 DCHECK(new_m != nullptr) << PrettyClass(klass.Get()); 6930 method_array->SetElementPtrSize(j, new_m, image_pointer_size_); 6931 } 6932 } 6933 } 6934 6935 // Fix up IMT next 6936 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) { 6937 auto it = move_table.find(out_imt[i]); 6938 if (it != move_table.end()) { 6939 out_imt[i] = it->second; 6940 } 6941 } 6942 } 6943 6944 // Check that there are no stale methods are in the dex cache array. 6945 if (kIsDebugBuild) { 6946 auto* resolved_methods = klass->GetDexCache()->GetResolvedMethods(); 6947 for (size_t i = 0, count = klass->GetDexCache()->NumResolvedMethods(); i < count; ++i) { 6948 auto* m = mirror::DexCache::GetElementPtrSize(resolved_methods, i, image_pointer_size_); 6949 CHECK(move_table.find(m) == move_table.end() || 6950 // The original versions of copied methods will still be present so allow those too. 6951 // Note that if the first check passes this might fail to GetDeclaringClass(). 6952 std::find_if(m->GetDeclaringClass()->GetMethods(image_pointer_size_).begin(), 6953 m->GetDeclaringClass()->GetMethods(image_pointer_size_).end(), 6954 [m] (ArtMethod& meth) { 6955 return &meth == m; 6956 }) != m->GetDeclaringClass()->GetMethods(image_pointer_size_).end()) 6957 << "Obsolete methods " << PrettyMethod(m) << " is in dex cache!"; 6958 } 6959 } 6960 // Put some random garbage in old methods to help find stale pointers. 6961 if (methods != old_methods && old_methods != nullptr) { 6962 memset(old_methods, 0xFEu, old_size); 6963 } 6964 } else { 6965 self->EndAssertNoThreadSuspension(old_cause); 6966 } 6967 if (kIsDebugBuild && !is_interface) { 6968 SanityCheckVTable(klass, image_pointer_size_); 6969 } 6970 return true; 6971} 6972 6973bool ClassLinker::LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) { 6974 CHECK(klass.Get() != nullptr); 6975 return LinkFields(self, klass, false, nullptr); 6976} 6977 6978bool ClassLinker::LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) { 6979 CHECK(klass.Get() != nullptr); 6980 return LinkFields(self, klass, true, class_size); 6981} 6982 6983struct LinkFieldsComparator { 6984 explicit LinkFieldsComparator() SHARED_REQUIRES(Locks::mutator_lock_) { 6985 } 6986 // No thread safety analysis as will be called from STL. Checked lock held in constructor. 6987 bool operator()(ArtField* field1, ArtField* field2) 6988 NO_THREAD_SAFETY_ANALYSIS { 6989 // First come reference fields, then 64-bit, then 32-bit, and then 16-bit, then finally 8-bit. 6990 Primitive::Type type1 = field1->GetTypeAsPrimitiveType(); 6991 Primitive::Type type2 = field2->GetTypeAsPrimitiveType(); 6992 if (type1 != type2) { 6993 if (type1 == Primitive::kPrimNot) { 6994 // Reference always goes first. 6995 return true; 6996 } 6997 if (type2 == Primitive::kPrimNot) { 6998 // Reference always goes first. 6999 return false; 7000 } 7001 size_t size1 = Primitive::ComponentSize(type1); 7002 size_t size2 = Primitive::ComponentSize(type2); 7003 if (size1 != size2) { 7004 // Larger primitive types go first. 7005 return size1 > size2; 7006 } 7007 // Primitive types differ but sizes match. Arbitrarily order by primitive type. 7008 return type1 < type2; 7009 } 7010 // Same basic group? Then sort by dex field index. This is guaranteed to be sorted 7011 // by name and for equal names by type id index. 7012 // NOTE: This works also for proxies. Their static fields are assigned appropriate indexes. 7013 return field1->GetDexFieldIndex() < field2->GetDexFieldIndex(); 7014 } 7015}; 7016 7017bool ClassLinker::LinkFields(Thread* self, 7018 Handle<mirror::Class> klass, 7019 bool is_static, 7020 size_t* class_size) { 7021 self->AllowThreadSuspension(); 7022 const size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields(); 7023 LengthPrefixedArray<ArtField>* const fields = is_static ? klass->GetSFieldsPtr() : 7024 klass->GetIFieldsPtr(); 7025 7026 // Initialize field_offset 7027 MemberOffset field_offset(0); 7028 if (is_static) { 7029 field_offset = klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_); 7030 } else { 7031 mirror::Class* super_class = klass->GetSuperClass(); 7032 if (super_class != nullptr) { 7033 CHECK(super_class->IsResolved()) 7034 << PrettyClass(klass.Get()) << " " << PrettyClass(super_class); 7035 field_offset = MemberOffset(super_class->GetObjectSize()); 7036 } 7037 } 7038 7039 CHECK_EQ(num_fields == 0, fields == nullptr) << PrettyClass(klass.Get()); 7040 7041 // we want a relatively stable order so that adding new fields 7042 // minimizes disruption of C++ version such as Class and Method. 7043 // 7044 // The overall sort order order is: 7045 // 1) All object reference fields, sorted alphabetically. 7046 // 2) All java long (64-bit) integer fields, sorted alphabetically. 7047 // 3) All java double (64-bit) floating point fields, sorted alphabetically. 7048 // 4) All java int (32-bit) integer fields, sorted alphabetically. 7049 // 5) All java float (32-bit) floating point fields, sorted alphabetically. 7050 // 6) All java char (16-bit) integer fields, sorted alphabetically. 7051 // 7) All java short (16-bit) integer fields, sorted alphabetically. 7052 // 8) All java boolean (8-bit) integer fields, sorted alphabetically. 7053 // 9) All java byte (8-bit) integer fields, sorted alphabetically. 7054 // 7055 // Once the fields are sorted in this order we will attempt to fill any gaps that might be present 7056 // in the memory layout of the structure. See ShuffleForward for how this is done. 7057 std::deque<ArtField*> grouped_and_sorted_fields; 7058 const char* old_no_suspend_cause = self->StartAssertNoThreadSuspension( 7059 "Naked ArtField references in deque"); 7060 for (size_t i = 0; i < num_fields; i++) { 7061 grouped_and_sorted_fields.push_back(&fields->At(i)); 7062 } 7063 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(), 7064 LinkFieldsComparator()); 7065 7066 // References should be at the front. 7067 size_t current_field = 0; 7068 size_t num_reference_fields = 0; 7069 FieldGaps gaps; 7070 7071 for (; current_field < num_fields; current_field++) { 7072 ArtField* field = grouped_and_sorted_fields.front(); 7073 Primitive::Type type = field->GetTypeAsPrimitiveType(); 7074 bool isPrimitive = type != Primitive::kPrimNot; 7075 if (isPrimitive) { 7076 break; // past last reference, move on to the next phase 7077 } 7078 if (UNLIKELY(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>( 7079 field_offset.Uint32Value()))) { 7080 MemberOffset old_offset = field_offset; 7081 field_offset = MemberOffset(RoundUp(field_offset.Uint32Value(), 4)); 7082 AddFieldGap(old_offset.Uint32Value(), field_offset.Uint32Value(), &gaps); 7083 } 7084 DCHECK_ALIGNED(field_offset.Uint32Value(), sizeof(mirror::HeapReference<mirror::Object>)); 7085 grouped_and_sorted_fields.pop_front(); 7086 num_reference_fields++; 7087 field->SetOffset(field_offset); 7088 field_offset = MemberOffset(field_offset.Uint32Value() + 7089 sizeof(mirror::HeapReference<mirror::Object>)); 7090 } 7091 // Gaps are stored as a max heap which means that we must shuffle from largest to smallest 7092 // otherwise we could end up with suboptimal gap fills. 7093 ShuffleForward<8>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 7094 ShuffleForward<4>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 7095 ShuffleForward<2>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 7096 ShuffleForward<1>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 7097 CHECK(grouped_and_sorted_fields.empty()) << "Missed " << grouped_and_sorted_fields.size() << 7098 " fields."; 7099 self->EndAssertNoThreadSuspension(old_no_suspend_cause); 7100 7101 // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it. 7102 if (!is_static && klass->DescriptorEquals("Ljava/lang/ref/Reference;")) { 7103 // We know there are no non-reference fields in the Reference classes, and we know 7104 // that 'referent' is alphabetically last, so this is easy... 7105 CHECK_EQ(num_reference_fields, num_fields) << PrettyClass(klass.Get()); 7106 CHECK_STREQ(fields->At(num_fields - 1).GetName(), "referent") 7107 << PrettyClass(klass.Get()); 7108 --num_reference_fields; 7109 } 7110 7111 size_t size = field_offset.Uint32Value(); 7112 // Update klass 7113 if (is_static) { 7114 klass->SetNumReferenceStaticFields(num_reference_fields); 7115 *class_size = size; 7116 } else { 7117 klass->SetNumReferenceInstanceFields(num_reference_fields); 7118 mirror::Class* super_class = klass->GetSuperClass(); 7119 if (num_reference_fields == 0 || super_class == nullptr) { 7120 // object has one reference field, klass, but we ignore it since we always visit the class. 7121 // super_class is null iff the class is java.lang.Object. 7122 if (super_class == nullptr || 7123 (super_class->GetClassFlags() & mirror::kClassFlagNoReferenceFields) != 0) { 7124 klass->SetClassFlags(klass->GetClassFlags() | mirror::kClassFlagNoReferenceFields); 7125 } 7126 } 7127 if (kIsDebugBuild) { 7128 DCHECK_EQ(super_class == nullptr, klass->DescriptorEquals("Ljava/lang/Object;")); 7129 size_t total_reference_instance_fields = 0; 7130 mirror::Class* cur_super = klass.Get(); 7131 while (cur_super != nullptr) { 7132 total_reference_instance_fields += cur_super->NumReferenceInstanceFieldsDuringLinking(); 7133 cur_super = cur_super->GetSuperClass(); 7134 } 7135 if (super_class == nullptr) { 7136 CHECK_EQ(total_reference_instance_fields, 1u) << PrettyDescriptor(klass.Get()); 7137 } else { 7138 // Check that there is at least num_reference_fields other than Object.class. 7139 CHECK_GE(total_reference_instance_fields, 1u + num_reference_fields) 7140 << PrettyClass(klass.Get()); 7141 } 7142 } 7143 if (!klass->IsVariableSize()) { 7144 std::string temp; 7145 DCHECK_GE(size, sizeof(mirror::Object)) << klass->GetDescriptor(&temp); 7146 size_t previous_size = klass->GetObjectSize(); 7147 if (previous_size != 0) { 7148 // Make sure that we didn't originally have an incorrect size. 7149 CHECK_EQ(previous_size, size) << klass->GetDescriptor(&temp); 7150 } 7151 klass->SetObjectSize(size); 7152 } 7153 } 7154 7155 if (kIsDebugBuild) { 7156 // Make sure that the fields array is ordered by name but all reference 7157 // offsets are at the beginning as far as alignment allows. 7158 MemberOffset start_ref_offset = is_static 7159 ? klass->GetFirstReferenceStaticFieldOffsetDuringLinking(image_pointer_size_) 7160 : klass->GetFirstReferenceInstanceFieldOffset(); 7161 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() + 7162 num_reference_fields * 7163 sizeof(mirror::HeapReference<mirror::Object>)); 7164 MemberOffset current_ref_offset = start_ref_offset; 7165 for (size_t i = 0; i < num_fields; i++) { 7166 ArtField* field = &fields->At(i); 7167 VLOG(class_linker) << "LinkFields: " << (is_static ? "static" : "instance") 7168 << " class=" << PrettyClass(klass.Get()) << " field=" << PrettyField(field) << " offset=" 7169 << field->GetOffsetDuringLinking(); 7170 if (i != 0) { 7171 ArtField* const prev_field = &fields->At(i - 1); 7172 // NOTE: The field names can be the same. This is not possible in the Java language 7173 // but it's valid Java/dex bytecode and for example proguard can generate such bytecode. 7174 DCHECK_LE(strcmp(prev_field->GetName(), field->GetName()), 0); 7175 } 7176 Primitive::Type type = field->GetTypeAsPrimitiveType(); 7177 bool is_primitive = type != Primitive::kPrimNot; 7178 if (klass->DescriptorEquals("Ljava/lang/ref/Reference;") && 7179 strcmp("referent", field->GetName()) == 0) { 7180 is_primitive = true; // We lied above, so we have to expect a lie here. 7181 } 7182 MemberOffset offset = field->GetOffsetDuringLinking(); 7183 if (is_primitive) { 7184 if (offset.Uint32Value() < end_ref_offset.Uint32Value()) { 7185 // Shuffled before references. 7186 size_t type_size = Primitive::ComponentSize(type); 7187 CHECK_LT(type_size, sizeof(mirror::HeapReference<mirror::Object>)); 7188 CHECK_LT(offset.Uint32Value(), start_ref_offset.Uint32Value()); 7189 CHECK_LE(offset.Uint32Value() + type_size, start_ref_offset.Uint32Value()); 7190 CHECK(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(offset.Uint32Value())); 7191 } 7192 } else { 7193 CHECK_EQ(current_ref_offset.Uint32Value(), offset.Uint32Value()); 7194 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() + 7195 sizeof(mirror::HeapReference<mirror::Object>)); 7196 } 7197 } 7198 CHECK_EQ(current_ref_offset.Uint32Value(), end_ref_offset.Uint32Value()); 7199 } 7200 return true; 7201} 7202 7203// Set the bitmap of reference instance field offsets. 7204void ClassLinker::CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) { 7205 uint32_t reference_offsets = 0; 7206 mirror::Class* super_class = klass->GetSuperClass(); 7207 // Leave the reference offsets as 0 for mirror::Object (the class field is handled specially). 7208 if (super_class != nullptr) { 7209 reference_offsets = super_class->GetReferenceInstanceOffsets(); 7210 // Compute reference offsets unless our superclass overflowed. 7211 if (reference_offsets != mirror::Class::kClassWalkSuper) { 7212 size_t num_reference_fields = klass->NumReferenceInstanceFieldsDuringLinking(); 7213 if (num_reference_fields != 0u) { 7214 // All of the fields that contain object references are guaranteed be grouped in memory 7215 // starting at an appropriately aligned address after super class object data. 7216 uint32_t start_offset = RoundUp(super_class->GetObjectSize(), 7217 sizeof(mirror::HeapReference<mirror::Object>)); 7218 uint32_t start_bit = (start_offset - mirror::kObjectHeaderSize) / 7219 sizeof(mirror::HeapReference<mirror::Object>); 7220 if (start_bit + num_reference_fields > 32) { 7221 reference_offsets = mirror::Class::kClassWalkSuper; 7222 } else { 7223 reference_offsets |= (0xffffffffu << start_bit) & 7224 (0xffffffffu >> (32 - (start_bit + num_reference_fields))); 7225 } 7226 } 7227 } 7228 } 7229 klass->SetReferenceInstanceOffsets(reference_offsets); 7230} 7231 7232mirror::String* ClassLinker::ResolveString(const DexFile& dex_file, 7233 uint32_t string_idx, 7234 Handle<mirror::DexCache> dex_cache) { 7235 DCHECK(dex_cache.Get() != nullptr); 7236 mirror::String* resolved = dex_cache->GetResolvedString(string_idx); 7237 if (resolved != nullptr) { 7238 return resolved; 7239 } 7240 uint32_t utf16_length; 7241 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length); 7242 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data); 7243 dex_cache->SetResolvedString(string_idx, string); 7244 return string; 7245} 7246 7247mirror::String* ClassLinker::LookupString(const DexFile& dex_file, 7248 uint32_t string_idx, 7249 Handle<mirror::DexCache> dex_cache) { 7250 DCHECK(dex_cache.Get() != nullptr); 7251 mirror::String* resolved = dex_cache->GetResolvedString(string_idx); 7252 if (resolved != nullptr) { 7253 return resolved; 7254 } 7255 uint32_t utf16_length; 7256 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length); 7257 mirror::String* string = intern_table_->LookupStrong(Thread::Current(), utf16_length, utf8_data); 7258 if (string != nullptr) { 7259 dex_cache->SetResolvedString(string_idx, string); 7260 } 7261 return string; 7262} 7263 7264mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, 7265 uint16_t type_idx, 7266 mirror::Class* referrer) { 7267 StackHandleScope<2> hs(Thread::Current()); 7268 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache())); 7269 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader())); 7270 return ResolveType(dex_file, type_idx, dex_cache, class_loader); 7271} 7272 7273mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, 7274 uint16_t type_idx, 7275 Handle<mirror::DexCache> dex_cache, 7276 Handle<mirror::ClassLoader> class_loader) { 7277 DCHECK(dex_cache.Get() != nullptr); 7278 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx); 7279 if (resolved == nullptr) { 7280 Thread* self = Thread::Current(); 7281 const char* descriptor = dex_file.StringByTypeIdx(type_idx); 7282 resolved = FindClass(self, descriptor, class_loader); 7283 if (resolved != nullptr) { 7284 // TODO: we used to throw here if resolved's class loader was not the 7285 // boot class loader. This was to permit different classes with the 7286 // same name to be loaded simultaneously by different loaders 7287 dex_cache->SetResolvedType(type_idx, resolved); 7288 } else { 7289 CHECK(self->IsExceptionPending()) 7290 << "Expected pending exception for failed resolution of: " << descriptor; 7291 // Convert a ClassNotFoundException to a NoClassDefFoundError. 7292 StackHandleScope<1> hs(self); 7293 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException())); 7294 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) { 7295 DCHECK(resolved == nullptr); // No Handle needed to preserve resolved. 7296 self->ClearException(); 7297 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor); 7298 self->GetException()->SetCause(cause.Get()); 7299 } 7300 } 7301 } 7302 DCHECK((resolved == nullptr) || resolved->IsResolved() || resolved->IsErroneous()) 7303 << PrettyDescriptor(resolved) << " " << resolved->GetStatus(); 7304 return resolved; 7305} 7306 7307template <ClassLinker::ResolveMode kResolveMode> 7308ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file, 7309 uint32_t method_idx, 7310 Handle<mirror::DexCache> dex_cache, 7311 Handle<mirror::ClassLoader> class_loader, 7312 ArtMethod* referrer, 7313 InvokeType type) { 7314 DCHECK(dex_cache.Get() != nullptr); 7315 // Check for hit in the dex cache. 7316 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_); 7317 if (resolved != nullptr && !resolved->IsRuntimeMethod()) { 7318 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex(); 7319 if (kResolveMode == ClassLinker::kForceICCECheck) { 7320 if (resolved->CheckIncompatibleClassChange(type)) { 7321 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer); 7322 return nullptr; 7323 } 7324 } 7325 return resolved; 7326 } 7327 // Fail, get the declaring class. 7328 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 7329 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader); 7330 if (klass == nullptr) { 7331 DCHECK(Thread::Current()->IsExceptionPending()); 7332 return nullptr; 7333 } 7334 // Scan using method_idx, this saves string compares but will only hit for matching dex 7335 // caches/files. 7336 switch (type) { 7337 case kDirect: // Fall-through. 7338 case kStatic: 7339 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7340 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr); 7341 break; 7342 case kInterface: 7343 // We have to check whether the method id really belongs to an interface (dex static bytecode 7344 // constraint A15). Otherwise you must not invoke-interface on it. 7345 // 7346 // This is not symmetric to A12-A14 (direct, static, virtual), as using FindInterfaceMethod 7347 // assumes that the given type is an interface, and will check the interface table if the 7348 // method isn't declared in the class. So it may find an interface method (usually by name 7349 // in the handling below, but we do the constraint check early). In that case, 7350 // CheckIncompatibleClassChange will succeed (as it is called on an interface method) 7351 // unexpectedly. 7352 // Example: 7353 // interface I { 7354 // foo() 7355 // } 7356 // class A implements I { 7357 // ... 7358 // } 7359 // class B extends A { 7360 // ... 7361 // } 7362 // invoke-interface B.foo 7363 // -> FindInterfaceMethod finds I.foo (interface method), not A.foo (miranda method) 7364 if (UNLIKELY(!klass->IsInterface())) { 7365 ThrowIncompatibleClassChangeError(klass, 7366 "Found class %s, but interface was expected", 7367 PrettyDescriptor(klass).c_str()); 7368 return nullptr; 7369 } else { 7370 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7371 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface()); 7372 } 7373 break; 7374 case kSuper: 7375 if (klass->IsInterface()) { 7376 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7377 } else { 7378 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7379 } 7380 break; 7381 case kVirtual: 7382 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7383 break; 7384 default: 7385 LOG(FATAL) << "Unreachable - invocation type: " << type; 7386 UNREACHABLE(); 7387 } 7388 if (resolved == nullptr) { 7389 // Search by name, which works across dex files. 7390 const char* name = dex_file.StringDataByIdx(method_id.name_idx_); 7391 const Signature signature = dex_file.GetMethodSignature(method_id); 7392 switch (type) { 7393 case kDirect: // Fall-through. 7394 case kStatic: 7395 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_); 7396 DCHECK(resolved == nullptr || resolved->GetDeclaringClassUnchecked() != nullptr); 7397 break; 7398 case kInterface: 7399 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_); 7400 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface()); 7401 break; 7402 case kSuper: 7403 if (klass->IsInterface()) { 7404 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_); 7405 } else { 7406 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_); 7407 } 7408 break; 7409 case kVirtual: 7410 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_); 7411 break; 7412 } 7413 } 7414 // If we found a method, check for incompatible class changes. 7415 if (LIKELY(resolved != nullptr && !resolved->CheckIncompatibleClassChange(type))) { 7416 // Be a good citizen and update the dex cache to speed subsequent calls. 7417 dex_cache->SetResolvedMethod(method_idx, resolved, image_pointer_size_); 7418 return resolved; 7419 } else { 7420 // If we had a method, it's an incompatible-class-change error. 7421 if (resolved != nullptr) { 7422 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer); 7423 } else { 7424 // We failed to find the method which means either an access error, an incompatible class 7425 // change, or no such method. First try to find the method among direct and virtual methods. 7426 const char* name = dex_file.StringDataByIdx(method_id.name_idx_); 7427 const Signature signature = dex_file.GetMethodSignature(method_id); 7428 switch (type) { 7429 case kDirect: 7430 case kStatic: 7431 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_); 7432 // Note: kDirect and kStatic are also mutually exclusive, but in that case we would 7433 // have had a resolved method before, which triggers the "true" branch above. 7434 break; 7435 case kInterface: 7436 case kVirtual: 7437 case kSuper: 7438 resolved = klass->FindDirectMethod(name, signature, image_pointer_size_); 7439 break; 7440 } 7441 7442 // If we found something, check that it can be accessed by the referrer. 7443 bool exception_generated = false; 7444 if (resolved != nullptr && referrer != nullptr) { 7445 mirror::Class* methods_class = resolved->GetDeclaringClass(); 7446 mirror::Class* referring_class = referrer->GetDeclaringClass(); 7447 if (!referring_class->CanAccess(methods_class)) { 7448 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, 7449 methods_class, 7450 resolved, 7451 type); 7452 exception_generated = true; 7453 } else if (!referring_class->CanAccessMember(methods_class, resolved->GetAccessFlags())) { 7454 ThrowIllegalAccessErrorMethod(referring_class, resolved); 7455 exception_generated = true; 7456 } 7457 } 7458 if (!exception_generated) { 7459 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check 7460 // interface methods and throw if we find the method there. If we find nothing, throw a 7461 // NoSuchMethodError. 7462 switch (type) { 7463 case kDirect: 7464 case kStatic: 7465 if (resolved != nullptr) { 7466 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer); 7467 } else { 7468 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_); 7469 if (resolved != nullptr) { 7470 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer); 7471 } else { 7472 ThrowNoSuchMethodError(type, klass, name, signature); 7473 } 7474 } 7475 break; 7476 case kInterface: 7477 if (resolved != nullptr) { 7478 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer); 7479 } else { 7480 resolved = klass->FindVirtualMethod(name, signature, image_pointer_size_); 7481 if (resolved != nullptr) { 7482 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer); 7483 } else { 7484 ThrowNoSuchMethodError(type, klass, name, signature); 7485 } 7486 } 7487 break; 7488 case kSuper: 7489 if (resolved != nullptr) { 7490 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer); 7491 } else { 7492 ThrowNoSuchMethodError(type, klass, name, signature); 7493 } 7494 break; 7495 case kVirtual: 7496 if (resolved != nullptr) { 7497 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer); 7498 } else { 7499 resolved = klass->FindInterfaceMethod(name, signature, image_pointer_size_); 7500 if (resolved != nullptr) { 7501 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer); 7502 } else { 7503 ThrowNoSuchMethodError(type, klass, name, signature); 7504 } 7505 } 7506 break; 7507 } 7508 } 7509 } 7510 Thread::Current()->AssertPendingException(); 7511 return nullptr; 7512 } 7513} 7514 7515ArtMethod* ClassLinker::ResolveMethodWithoutInvokeType(const DexFile& dex_file, 7516 uint32_t method_idx, 7517 Handle<mirror::DexCache> dex_cache, 7518 Handle<mirror::ClassLoader> class_loader) { 7519 ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, image_pointer_size_); 7520 if (resolved != nullptr && !resolved->IsRuntimeMethod()) { 7521 DCHECK(resolved->GetDeclaringClassUnchecked() != nullptr) << resolved->GetDexMethodIndex(); 7522 return resolved; 7523 } 7524 // Fail, get the declaring class. 7525 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 7526 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader); 7527 if (klass == nullptr) { 7528 Thread::Current()->AssertPendingException(); 7529 return nullptr; 7530 } 7531 if (klass->IsInterface()) { 7532 LOG(FATAL) << "ResolveAmbiguousMethod: unexpected method in interface: " << PrettyClass(klass); 7533 return nullptr; 7534 } 7535 7536 // Search both direct and virtual methods 7537 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7538 if (resolved == nullptr) { 7539 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx, image_pointer_size_); 7540 } 7541 7542 return resolved; 7543} 7544 7545ArtField* ClassLinker::ResolveField(const DexFile& dex_file, 7546 uint32_t field_idx, 7547 Handle<mirror::DexCache> dex_cache, 7548 Handle<mirror::ClassLoader> class_loader, 7549 bool is_static) { 7550 DCHECK(dex_cache.Get() != nullptr); 7551 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_); 7552 if (resolved != nullptr) { 7553 return resolved; 7554 } 7555 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 7556 Thread* const self = Thread::Current(); 7557 StackHandleScope<1> hs(self); 7558 Handle<mirror::Class> klass( 7559 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader))); 7560 if (klass.Get() == nullptr) { 7561 DCHECK(Thread::Current()->IsExceptionPending()); 7562 return nullptr; 7563 } 7564 7565 if (is_static) { 7566 resolved = mirror::Class::FindStaticField(self, klass, dex_cache.Get(), field_idx); 7567 } else { 7568 resolved = klass->FindInstanceField(dex_cache.Get(), field_idx); 7569 } 7570 7571 if (resolved == nullptr) { 7572 const char* name = dex_file.GetFieldName(field_id); 7573 const char* type = dex_file.GetFieldTypeDescriptor(field_id); 7574 if (is_static) { 7575 resolved = mirror::Class::FindStaticField(self, klass, name, type); 7576 } else { 7577 resolved = klass->FindInstanceField(name, type); 7578 } 7579 if (resolved == nullptr) { 7580 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass.Get(), type, name); 7581 return nullptr; 7582 } 7583 } 7584 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_); 7585 return resolved; 7586} 7587 7588ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file, 7589 uint32_t field_idx, 7590 Handle<mirror::DexCache> dex_cache, 7591 Handle<mirror::ClassLoader> class_loader) { 7592 DCHECK(dex_cache.Get() != nullptr); 7593 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_); 7594 if (resolved != nullptr) { 7595 return resolved; 7596 } 7597 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 7598 Thread* self = Thread::Current(); 7599 StackHandleScope<1> hs(self); 7600 Handle<mirror::Class> klass( 7601 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader))); 7602 if (klass.Get() == nullptr) { 7603 DCHECK(Thread::Current()->IsExceptionPending()); 7604 return nullptr; 7605 } 7606 7607 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_)); 7608 StringPiece type(dex_file.StringDataByIdx( 7609 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_)); 7610 resolved = mirror::Class::FindField(self, klass, name, type); 7611 if (resolved != nullptr) { 7612 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_); 7613 } else { 7614 ThrowNoSuchFieldError("", klass.Get(), type, name); 7615 } 7616 return resolved; 7617} 7618 7619const char* ClassLinker::MethodShorty(uint32_t method_idx, 7620 ArtMethod* referrer, 7621 uint32_t* length) { 7622 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 7623 mirror::DexCache* dex_cache = declaring_class->GetDexCache(); 7624 const DexFile& dex_file = *dex_cache->GetDexFile(); 7625 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 7626 return dex_file.GetMethodShorty(method_id, length); 7627} 7628 7629class DumpClassVisitor : public ClassVisitor { 7630 public: 7631 explicit DumpClassVisitor(int flags) : flags_(flags) {} 7632 7633 bool operator()(mirror::Class* klass) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) { 7634 klass->DumpClass(LOG(ERROR), flags_); 7635 return true; 7636 } 7637 7638 private: 7639 const int flags_; 7640}; 7641 7642void ClassLinker::DumpAllClasses(int flags) { 7643 DumpClassVisitor visitor(flags); 7644 VisitClasses(&visitor); 7645} 7646 7647static OatFile::OatMethod CreateOatMethod(const void* code) { 7648 CHECK(code != nullptr); 7649 const uint8_t* base = reinterpret_cast<const uint8_t*>(code); // Base of data points at code. 7650 base -= sizeof(void*); // Move backward so that code_offset != 0. 7651 const uint32_t code_offset = sizeof(void*); 7652 return OatFile::OatMethod(base, code_offset); 7653} 7654 7655bool ClassLinker::IsQuickResolutionStub(const void* entry_point) const { 7656 return (entry_point == GetQuickResolutionStub()) || 7657 (quick_resolution_trampoline_ == entry_point); 7658} 7659 7660bool ClassLinker::IsQuickToInterpreterBridge(const void* entry_point) const { 7661 return (entry_point == GetQuickToInterpreterBridge()) || 7662 (quick_to_interpreter_bridge_trampoline_ == entry_point); 7663} 7664 7665bool ClassLinker::IsQuickGenericJniStub(const void* entry_point) const { 7666 return (entry_point == GetQuickGenericJniStub()) || 7667 (quick_generic_jni_trampoline_ == entry_point); 7668} 7669 7670const void* ClassLinker::GetRuntimeQuickGenericJniStub() const { 7671 return GetQuickGenericJniStub(); 7672} 7673 7674void ClassLinker::SetEntryPointsToCompiledCode(ArtMethod* method, 7675 const void* method_code) const { 7676 OatFile::OatMethod oat_method = CreateOatMethod(method_code); 7677 oat_method.LinkMethod(method); 7678} 7679 7680void ClassLinker::SetEntryPointsToInterpreter(ArtMethod* method) const { 7681 if (!method->IsNative()) { 7682 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge()); 7683 } else { 7684 const void* quick_method_code = GetQuickGenericJniStub(); 7685 OatFile::OatMethod oat_method = CreateOatMethod(quick_method_code); 7686 oat_method.LinkMethod(method); 7687 } 7688} 7689 7690void ClassLinker::DumpForSigQuit(std::ostream& os) { 7691 ScopedObjectAccess soa(Thread::Current()); 7692 if (dex_cache_boot_image_class_lookup_required_) { 7693 AddBootImageClassesToClassTable(); 7694 } 7695 ReaderMutexLock mu(soa.Self(), *Locks::classlinker_classes_lock_); 7696 os << "Zygote loaded classes=" << NumZygoteClasses() << " post zygote classes=" 7697 << NumNonZygoteClasses() << "\n"; 7698} 7699 7700class CountClassesVisitor : public ClassLoaderVisitor { 7701 public: 7702 CountClassesVisitor() : num_zygote_classes(0), num_non_zygote_classes(0) {} 7703 7704 void Visit(mirror::ClassLoader* class_loader) 7705 SHARED_REQUIRES(Locks::classlinker_classes_lock_, Locks::mutator_lock_) OVERRIDE { 7706 ClassTable* const class_table = class_loader->GetClassTable(); 7707 if (class_table != nullptr) { 7708 num_zygote_classes += class_table->NumZygoteClasses(); 7709 num_non_zygote_classes += class_table->NumNonZygoteClasses(); 7710 } 7711 } 7712 7713 size_t num_zygote_classes; 7714 size_t num_non_zygote_classes; 7715}; 7716 7717size_t ClassLinker::NumZygoteClasses() const { 7718 CountClassesVisitor visitor; 7719 VisitClassLoaders(&visitor); 7720 return visitor.num_zygote_classes + boot_class_table_.NumZygoteClasses(); 7721} 7722 7723size_t ClassLinker::NumNonZygoteClasses() const { 7724 CountClassesVisitor visitor; 7725 VisitClassLoaders(&visitor); 7726 return visitor.num_non_zygote_classes + boot_class_table_.NumNonZygoteClasses(); 7727} 7728 7729size_t ClassLinker::NumLoadedClasses() { 7730 if (dex_cache_boot_image_class_lookup_required_) { 7731 AddBootImageClassesToClassTable(); 7732 } 7733 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 7734 // Only return non zygote classes since these are the ones which apps which care about. 7735 return NumNonZygoteClasses(); 7736} 7737 7738pid_t ClassLinker::GetClassesLockOwner() { 7739 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid(); 7740} 7741 7742pid_t ClassLinker::GetDexLockOwner() { 7743 return dex_lock_.GetExclusiveOwnerTid(); 7744} 7745 7746void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) { 7747 DCHECK(!init_done_); 7748 7749 DCHECK(klass != nullptr); 7750 DCHECK(klass->GetClassLoader() == nullptr); 7751 7752 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read(); 7753 DCHECK(class_roots != nullptr); 7754 DCHECK(class_roots->Get(class_root) == nullptr); 7755 class_roots->Set<false>(class_root, klass); 7756} 7757 7758const char* ClassLinker::GetClassRootDescriptor(ClassRoot class_root) { 7759 static const char* class_roots_descriptors[] = { 7760 "Ljava/lang/Class;", 7761 "Ljava/lang/Object;", 7762 "[Ljava/lang/Class;", 7763 "[Ljava/lang/Object;", 7764 "Ljava/lang/String;", 7765 "Ljava/lang/DexCache;", 7766 "Ljava/lang/ref/Reference;", 7767 "Ljava/lang/reflect/Constructor;", 7768 "Ljava/lang/reflect/Field;", 7769 "Ljava/lang/reflect/Method;", 7770 "Ljava/lang/reflect/Proxy;", 7771 "[Ljava/lang/String;", 7772 "[Ljava/lang/reflect/Constructor;", 7773 "[Ljava/lang/reflect/Field;", 7774 "[Ljava/lang/reflect/Method;", 7775 "Ljava/lang/ClassLoader;", 7776 "Ljava/lang/Throwable;", 7777 "Ljava/lang/ClassNotFoundException;", 7778 "Ljava/lang/StackTraceElement;", 7779 "Z", 7780 "B", 7781 "C", 7782 "D", 7783 "F", 7784 "I", 7785 "J", 7786 "S", 7787 "V", 7788 "[Z", 7789 "[B", 7790 "[C", 7791 "[D", 7792 "[F", 7793 "[I", 7794 "[J", 7795 "[S", 7796 "[Ljava/lang/StackTraceElement;", 7797 }; 7798 static_assert(arraysize(class_roots_descriptors) == size_t(kClassRootsMax), 7799 "Mismatch between class descriptors and class-root enum"); 7800 7801 const char* descriptor = class_roots_descriptors[class_root]; 7802 CHECK(descriptor != nullptr); 7803 return descriptor; 7804} 7805 7806jobject ClassLinker::CreatePathClassLoader(Thread* self, 7807 const std::vector<const DexFile*>& dex_files) { 7808 // SOAAlreadyRunnable is protected, and we need something to add a global reference. 7809 // We could move the jobject to the callers, but all call-sites do this... 7810 ScopedObjectAccessUnchecked soa(self); 7811 7812 // For now, create a libcore-level DexFile for each ART DexFile. This "explodes" multidex. 7813 StackHandleScope<10> hs(self); 7814 7815 ArtField* dex_elements_field = 7816 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements); 7817 7818 mirror::Class* dex_elements_class = dex_elements_field->GetType<true>(); 7819 DCHECK(dex_elements_class != nullptr); 7820 DCHECK(dex_elements_class->IsArrayClass()); 7821 Handle<mirror::ObjectArray<mirror::Object>> h_dex_elements(hs.NewHandle( 7822 mirror::ObjectArray<mirror::Object>::Alloc(self, dex_elements_class, dex_files.size()))); 7823 Handle<mirror::Class> h_dex_element_class = 7824 hs.NewHandle(dex_elements_class->GetComponentType()); 7825 7826 ArtField* element_file_field = 7827 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile); 7828 DCHECK_EQ(h_dex_element_class.Get(), element_file_field->GetDeclaringClass()); 7829 7830 ArtField* cookie_field = soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_cookie); 7831 DCHECK_EQ(cookie_field->GetDeclaringClass(), element_file_field->GetType<false>()); 7832 7833 ArtField* file_name_field = soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_fileName); 7834 DCHECK_EQ(file_name_field->GetDeclaringClass(), element_file_field->GetType<false>()); 7835 7836 // Fill the elements array. 7837 int32_t index = 0; 7838 for (const DexFile* dex_file : dex_files) { 7839 StackHandleScope<4> hs2(self); 7840 7841 // CreatePathClassLoader is only used by gtests. Index 0 of h_long_array is supposed to be the 7842 // oat file but we can leave it null. 7843 Handle<mirror::LongArray> h_long_array = hs2.NewHandle(mirror::LongArray::Alloc( 7844 self, 7845 kDexFileIndexStart + 1)); 7846 DCHECK(h_long_array.Get() != nullptr); 7847 h_long_array->Set(kDexFileIndexStart, reinterpret_cast<intptr_t>(dex_file)); 7848 7849 Handle<mirror::Object> h_dex_file = hs2.NewHandle( 7850 cookie_field->GetDeclaringClass()->AllocObject(self)); 7851 DCHECK(h_dex_file.Get() != nullptr); 7852 cookie_field->SetObject<false>(h_dex_file.Get(), h_long_array.Get()); 7853 7854 Handle<mirror::String> h_file_name = hs2.NewHandle( 7855 mirror::String::AllocFromModifiedUtf8(self, dex_file->GetLocation().c_str())); 7856 DCHECK(h_file_name.Get() != nullptr); 7857 file_name_field->SetObject<false>(h_dex_file.Get(), h_file_name.Get()); 7858 7859 Handle<mirror::Object> h_element = hs2.NewHandle(h_dex_element_class->AllocObject(self)); 7860 DCHECK(h_element.Get() != nullptr); 7861 element_file_field->SetObject<false>(h_element.Get(), h_dex_file.Get()); 7862 7863 h_dex_elements->Set(index, h_element.Get()); 7864 index++; 7865 } 7866 DCHECK_EQ(index, h_dex_elements->GetLength()); 7867 7868 // Create DexPathList. 7869 Handle<mirror::Object> h_dex_path_list = hs.NewHandle( 7870 dex_elements_field->GetDeclaringClass()->AllocObject(self)); 7871 DCHECK(h_dex_path_list.Get() != nullptr); 7872 // Set elements. 7873 dex_elements_field->SetObject<false>(h_dex_path_list.Get(), h_dex_elements.Get()); 7874 7875 // Create PathClassLoader. 7876 Handle<mirror::Class> h_path_class_class = hs.NewHandle( 7877 soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader)); 7878 Handle<mirror::Object> h_path_class_loader = hs.NewHandle( 7879 h_path_class_class->AllocObject(self)); 7880 DCHECK(h_path_class_loader.Get() != nullptr); 7881 // Set DexPathList. 7882 ArtField* path_list_field = 7883 soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList); 7884 DCHECK(path_list_field != nullptr); 7885 path_list_field->SetObject<false>(h_path_class_loader.Get(), h_dex_path_list.Get()); 7886 7887 // Make a pretend boot-classpath. 7888 // TODO: Should we scan the image? 7889 ArtField* const parent_field = 7890 mirror::Class::FindField(self, hs.NewHandle(h_path_class_loader->GetClass()), "parent", 7891 "Ljava/lang/ClassLoader;"); 7892 DCHECK(parent_field != nullptr); 7893 mirror::Object* boot_cl = 7894 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader)->AllocObject(self); 7895 parent_field->SetObject<false>(h_path_class_loader.Get(), boot_cl); 7896 7897 // Make it a global ref and return. 7898 ScopedLocalRef<jobject> local_ref( 7899 soa.Env(), soa.Env()->AddLocalReference<jobject>(h_path_class_loader.Get())); 7900 return soa.Env()->NewGlobalRef(local_ref.get()); 7901} 7902 7903ArtMethod* ClassLinker::CreateRuntimeMethod(LinearAlloc* linear_alloc) { 7904 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size_); 7905 const size_t method_size = ArtMethod::Size(image_pointer_size_); 7906 LengthPrefixedArray<ArtMethod>* method_array = AllocArtMethodArray( 7907 Thread::Current(), 7908 linear_alloc, 7909 1); 7910 ArtMethod* method = &method_array->At(0, method_size, method_alignment); 7911 CHECK(method != nullptr); 7912 method->SetDexMethodIndex(DexFile::kDexNoIndex); 7913 CHECK(method->IsRuntimeMethod()); 7914 return method; 7915} 7916 7917void ClassLinker::DropFindArrayClassCache() { 7918 std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr)); 7919 find_array_class_cache_next_victim_ = 0; 7920} 7921 7922void ClassLinker::VisitClassLoaders(ClassLoaderVisitor* visitor) const { 7923 Thread* const self = Thread::Current(); 7924 for (const ClassLoaderData& data : class_loaders_) { 7925 // Need to use DecodeJObject so that we get null for cleared JNI weak globals. 7926 auto* const class_loader = down_cast<mirror::ClassLoader*>(self->DecodeJObject(data.weak_root)); 7927 if (class_loader != nullptr) { 7928 visitor->Visit(class_loader); 7929 } 7930 } 7931} 7932 7933void ClassLinker::InsertDexFileInToClassLoader(mirror::Object* dex_file, 7934 mirror::ClassLoader* class_loader) { 7935 DCHECK(dex_file != nullptr); 7936 Thread* const self = Thread::Current(); 7937 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 7938 ClassTable* const table = ClassTableForClassLoader(class_loader); 7939 DCHECK(table != nullptr); 7940 if (table->InsertDexFile(dex_file) && class_loader != nullptr) { 7941 // It was not already inserted, perform the write barrier to let the GC know the class loader's 7942 // class table was modified. 7943 Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(class_loader); 7944 } 7945} 7946 7947void ClassLinker::CleanupClassLoaders() { 7948 Thread* const self = Thread::Current(); 7949 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 7950 for (auto it = class_loaders_.begin(); it != class_loaders_.end(); ) { 7951 const ClassLoaderData& data = *it; 7952 // Need to use DecodeJObject so that we get null for cleared JNI weak globals. 7953 auto* const class_loader = down_cast<mirror::ClassLoader*>(self->DecodeJObject(data.weak_root)); 7954 if (class_loader != nullptr) { 7955 ++it; 7956 } else { 7957 VLOG(class_linker) << "Freeing class loader"; 7958 DeleteClassLoader(self, data); 7959 it = class_loaders_.erase(it); 7960 } 7961 } 7962} 7963 7964std::set<DexCacheResolvedClasses> ClassLinker::GetResolvedClasses(bool ignore_boot_classes) { 7965 ScopedTrace trace(__PRETTY_FUNCTION__); 7966 ScopedObjectAccess soa(Thread::Current()); 7967 ScopedAssertNoThreadSuspension ants(soa.Self(), __FUNCTION__); 7968 std::set<DexCacheResolvedClasses> ret; 7969 VLOG(class_linker) << "Collecting resolved classes"; 7970 const uint64_t start_time = NanoTime(); 7971 ReaderMutexLock mu(soa.Self(), *DexLock()); 7972 // Loop through all the dex caches and inspect resolved classes. 7973 for (const ClassLinker::DexCacheData& data : GetDexCachesData()) { 7974 if (soa.Self()->IsJWeakCleared(data.weak_root)) { 7975 continue; 7976 } 7977 mirror::DexCache* dex_cache = 7978 down_cast<mirror::DexCache*>(soa.Self()->DecodeJObject(data.weak_root)); 7979 if (dex_cache == nullptr) { 7980 continue; 7981 } 7982 const DexFile* dex_file = dex_cache->GetDexFile(); 7983 const std::string& location = dex_file->GetLocation(); 7984 const size_t num_class_defs = dex_file->NumClassDefs(); 7985 // Use the resolved types, this will miss array classes. 7986 const size_t num_types = dex_file->NumTypeIds(); 7987 VLOG(class_linker) << "Collecting class profile for dex file " << location 7988 << " types=" << num_types << " class_defs=" << num_class_defs; 7989 DexCacheResolvedClasses resolved_classes(dex_file->GetLocation(), 7990 dex_file->GetLocationChecksum()); 7991 size_t num_resolved = 0; 7992 std::unordered_set<uint16_t> class_set; 7993 CHECK_EQ(num_types, dex_cache->NumResolvedTypes()); 7994 for (size_t i = 0; i < num_types; ++i) { 7995 mirror::Class* klass = dex_cache->GetResolvedType(i); 7996 // Filter out null class loader since that is the boot class loader. 7997 if (klass == nullptr || (ignore_boot_classes && klass->GetClassLoader() == nullptr)) { 7998 continue; 7999 } 8000 ++num_resolved; 8001 DCHECK(!klass->IsProxyClass()); 8002 if (!klass->IsResolved()) { 8003 DCHECK(klass->IsErroneous()); 8004 continue; 8005 } 8006 mirror::DexCache* klass_dex_cache = klass->GetDexCache(); 8007 if (klass_dex_cache == dex_cache) { 8008 const size_t class_def_idx = klass->GetDexClassDefIndex(); 8009 DCHECK(klass->IsResolved()); 8010 CHECK_LT(class_def_idx, num_class_defs); 8011 class_set.insert(class_def_idx); 8012 } 8013 } 8014 8015 if (!class_set.empty()) { 8016 auto it = ret.find(resolved_classes); 8017 if (it != ret.end()) { 8018 // Already have the key, union the class def idxs. 8019 it->AddClasses(class_set.begin(), class_set.end()); 8020 } else { 8021 resolved_classes.AddClasses(class_set.begin(), class_set.end()); 8022 ret.insert(resolved_classes); 8023 } 8024 } 8025 8026 VLOG(class_linker) << "Dex location " << location << " has " << num_resolved << " / " 8027 << num_class_defs << " resolved classes"; 8028 } 8029 VLOG(class_linker) << "Collecting class profile took " << PrettyDuration(NanoTime() - start_time); 8030 return ret; 8031} 8032 8033std::unordered_set<std::string> ClassLinker::GetClassDescriptorsForProfileKeys( 8034 const std::set<DexCacheResolvedClasses>& classes) { 8035 ScopedTrace trace(__PRETTY_FUNCTION__); 8036 std::unordered_set<std::string> ret; 8037 Thread* const self = Thread::Current(); 8038 std::unordered_map<std::string, const DexFile*> location_to_dex_file; 8039 ScopedObjectAccess soa(self); 8040 ScopedAssertNoThreadSuspension ants(soa.Self(), __FUNCTION__); 8041 ReaderMutexLock mu(self, *DexLock()); 8042 for (const ClassLinker::DexCacheData& data : GetDexCachesData()) { 8043 if (!self->IsJWeakCleared(data.weak_root)) { 8044 mirror::DexCache* dex_cache = 8045 down_cast<mirror::DexCache*>(soa.Self()->DecodeJObject(data.weak_root)); 8046 if (dex_cache != nullptr) { 8047 const DexFile* dex_file = dex_cache->GetDexFile(); 8048 // There could be duplicates if two dex files with the same location are mapped. 8049 location_to_dex_file.emplace( 8050 ProfileCompilationInfo::GetProfileDexFileKey(dex_file->GetLocation()), dex_file); 8051 } 8052 } 8053 } 8054 for (const DexCacheResolvedClasses& info : classes) { 8055 const std::string& profile_key = info.GetDexLocation(); 8056 auto found = location_to_dex_file.find(profile_key); 8057 if (found != location_to_dex_file.end()) { 8058 const DexFile* dex_file = found->second; 8059 VLOG(profiler) << "Found opened dex file for " << dex_file->GetLocation() << " with " 8060 << info.GetClasses().size() << " classes"; 8061 DCHECK_EQ(dex_file->GetLocationChecksum(), info.GetLocationChecksum()); 8062 for (uint16_t class_def_idx : info.GetClasses()) { 8063 if (class_def_idx >= dex_file->NumClassDefs()) { 8064 LOG(WARNING) << "Class def index " << class_def_idx << " >= " << dex_file->NumClassDefs(); 8065 continue; 8066 } 8067 const DexFile::TypeId& type_id = dex_file->GetTypeId( 8068 dex_file->GetClassDef(class_def_idx).class_idx_); 8069 const char* descriptor = dex_file->GetTypeDescriptor(type_id); 8070 ret.insert(descriptor); 8071 } 8072 } else { 8073 VLOG(class_linker) << "Failed to find opened dex file for profile key " << profile_key; 8074 } 8075 } 8076 return ret; 8077} 8078 8079// Instantiate ResolveMethod. 8080template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kForceICCECheck>( 8081 const DexFile& dex_file, 8082 uint32_t method_idx, 8083 Handle<mirror::DexCache> dex_cache, 8084 Handle<mirror::ClassLoader> class_loader, 8085 ArtMethod* referrer, 8086 InvokeType type); 8087template ArtMethod* ClassLinker::ResolveMethod<ClassLinker::kNoICCECheckForCache>( 8088 const DexFile& dex_file, 8089 uint32_t method_idx, 8090 Handle<mirror::DexCache> dex_cache, 8091 Handle<mirror::ClassLoader> class_loader, 8092 ArtMethod* referrer, 8093 InvokeType type); 8094 8095} // namespace art 8096