class_linker.cc revision 848f70a3d73833fc1bf3032a9ff6812e429661d9
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 <deque> 20#include <iostream> 21#include <memory> 22#include <queue> 23#include <string> 24#include <unistd.h> 25#include <utility> 26#include <vector> 27 28#include "art_field-inl.h" 29#include "base/casts.h" 30#include "base/logging.h" 31#include "base/scoped_flock.h" 32#include "base/stl_util.h" 33#include "base/unix_file/fd_file.h" 34#include "base/value_object.h" 35#include "class_linker-inl.h" 36#include "compiler_callbacks.h" 37#include "debugger.h" 38#include "dex_file-inl.h" 39#include "entrypoints/runtime_asm_entrypoints.h" 40#include "gc_root-inl.h" 41#include "gc/accounting/card_table-inl.h" 42#include "gc/accounting/heap_bitmap.h" 43#include "gc/heap.h" 44#include "gc/space/image_space.h" 45#include "handle_scope.h" 46#include "intern_table.h" 47#include "interpreter/interpreter.h" 48#include "jit/jit.h" 49#include "jit/jit_code_cache.h" 50#include "leb128.h" 51#include "linear_alloc.h" 52#include "oat.h" 53#include "oat_file.h" 54#include "oat_file_assistant.h" 55#include "object_lock.h" 56#include "mirror/art_method-inl.h" 57#include "mirror/class.h" 58#include "mirror/class-inl.h" 59#include "mirror/class_loader.h" 60#include "mirror/dex_cache-inl.h" 61#include "mirror/field.h" 62#include "mirror/iftable-inl.h" 63#include "mirror/method.h" 64#include "mirror/object-inl.h" 65#include "mirror/object_array-inl.h" 66#include "mirror/proxy.h" 67#include "mirror/reference-inl.h" 68#include "mirror/stack_trace_element.h" 69#include "mirror/string-inl.h" 70#include "os.h" 71#include "runtime.h" 72#include "entrypoints/entrypoint_utils.h" 73#include "ScopedLocalRef.h" 74#include "scoped_thread_state_change.h" 75#include "handle_scope-inl.h" 76#include "thread-inl.h" 77#include "utils.h" 78#include "verifier/method_verifier.h" 79#include "well_known_classes.h" 80 81namespace art { 82 83static constexpr bool kSanityCheckObjects = kIsDebugBuild; 84 85// Do a simple class redefinition check in OpenDexFilesFromOat. This is a conservative check to 86// avoid problems with compile-time class-path != runtime class-path. 87static constexpr bool kCheckForDexCollisions = true; 88 89static void ThrowNoClassDefFoundError(const char* fmt, ...) 90 __attribute__((__format__(__printf__, 1, 2))) 91 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 92static void ThrowNoClassDefFoundError(const char* fmt, ...) { 93 va_list args; 94 va_start(args, fmt); 95 Thread* self = Thread::Current(); 96 self->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args); 97 va_end(args); 98} 99 100static bool HasInitWithString(Thread* self, ClassLinker* class_linker, const char* descriptor) 101 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 102 mirror::ArtMethod* method = self->GetCurrentMethod(nullptr); 103 StackHandleScope<1> hs(self); 104 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(method != nullptr ? 105 method->GetDeclaringClass()->GetClassLoader() 106 : nullptr)); 107 mirror::Class* exception_class = class_linker->FindClass(self, descriptor, class_loader); 108 109 if (exception_class == nullptr) { 110 // No exc class ~ no <init>-with-string. 111 CHECK(self->IsExceptionPending()); 112 self->ClearException(); 113 return false; 114 } 115 116 mirror::ArtMethod* exception_init_method = 117 exception_class->FindDeclaredDirectMethod("<init>", "(Ljava/lang/String;)V"); 118 return exception_init_method != nullptr; 119} 120 121void ClassLinker::ThrowEarlierClassFailure(mirror::Class* c) { 122 // The class failed to initialize on a previous attempt, so we want to throw 123 // a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we 124 // failed in verification, in which case v2 5.4.1 says we need to re-throw 125 // the previous error. 126 Runtime* const runtime = Runtime::Current(); 127 if (!runtime->IsAotCompiler()) { // Give info if this occurs at runtime. 128 LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c); 129 } 130 131 CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus(); 132 Thread* self = Thread::Current(); 133 if (runtime->IsAotCompiler()) { 134 // At compile time, accurate errors and NCDFE are disabled to speed compilation. 135 mirror::Throwable* pre_allocated = runtime->GetPreAllocatedNoClassDefFoundError(); 136 self->SetException(pre_allocated); 137 } else { 138 if (c->GetVerifyErrorClass() != nullptr) { 139 // TODO: change the verifier to store an _instance_, with a useful detail message? 140 // It's possible the exception doesn't have a <init>(String). 141 std::string temp; 142 const char* descriptor = c->GetVerifyErrorClass()->GetDescriptor(&temp); 143 144 if (HasInitWithString(self, this, descriptor)) { 145 self->ThrowNewException(descriptor, PrettyDescriptor(c).c_str()); 146 } else { 147 self->ThrowNewException(descriptor, nullptr); 148 } 149 } else { 150 self->ThrowNewException("Ljava/lang/NoClassDefFoundError;", 151 PrettyDescriptor(c).c_str()); 152 } 153 } 154} 155 156static void VlogClassInitializationFailure(Handle<mirror::Class> klass) 157 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 158 if (VLOG_IS_ON(class_linker)) { 159 std::string temp; 160 LOG(INFO) << "Failed to initialize class " << klass->GetDescriptor(&temp) << " from " 161 << klass->GetLocation() << "\n" << Thread::Current()->GetException()->Dump(); 162 } 163} 164 165static void WrapExceptionInInitializer(Handle<mirror::Class> klass) 166 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 167 Thread* self = Thread::Current(); 168 JNIEnv* env = self->GetJniEnv(); 169 170 ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred()); 171 CHECK(cause.get() != nullptr); 172 173 env->ExceptionClear(); 174 bool is_error = env->IsInstanceOf(cause.get(), WellKnownClasses::java_lang_Error); 175 env->Throw(cause.get()); 176 177 // We only wrap non-Error exceptions; an Error can just be used as-is. 178 if (!is_error) { 179 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", nullptr); 180 } 181 VlogClassInitializationFailure(klass); 182} 183 184// Gap between two fields in object layout. 185struct FieldGap { 186 uint32_t start_offset; // The offset from the start of the object. 187 uint32_t size; // The gap size of 1, 2, or 4 bytes. 188}; 189struct FieldGapsComparator { 190 explicit FieldGapsComparator() { 191 } 192 bool operator() (const FieldGap& lhs, const FieldGap& rhs) 193 NO_THREAD_SAFETY_ANALYSIS { 194 // Sort by gap size, largest first. Secondary sort by starting offset. 195 return lhs.size > rhs.size || (lhs.size == rhs.size && lhs.start_offset < rhs.start_offset); 196 } 197}; 198typedef std::priority_queue<FieldGap, std::vector<FieldGap>, FieldGapsComparator> FieldGaps; 199 200// Adds largest aligned gaps to queue of gaps. 201static void AddFieldGap(uint32_t gap_start, uint32_t gap_end, FieldGaps* gaps) { 202 DCHECK(gaps != nullptr); 203 204 uint32_t current_offset = gap_start; 205 while (current_offset != gap_end) { 206 size_t remaining = gap_end - current_offset; 207 if (remaining >= sizeof(uint32_t) && IsAligned<4>(current_offset)) { 208 gaps->push(FieldGap {current_offset, sizeof(uint32_t)}); 209 current_offset += sizeof(uint32_t); 210 } else if (remaining >= sizeof(uint16_t) && IsAligned<2>(current_offset)) { 211 gaps->push(FieldGap {current_offset, sizeof(uint16_t)}); 212 current_offset += sizeof(uint16_t); 213 } else { 214 gaps->push(FieldGap {current_offset, sizeof(uint8_t)}); 215 current_offset += sizeof(uint8_t); 216 } 217 DCHECK_LE(current_offset, gap_end) << "Overran gap"; 218 } 219} 220// Shuffle fields forward, making use of gaps whenever possible. 221template<int n> 222static void ShuffleForward(size_t* current_field_idx, 223 MemberOffset* field_offset, 224 std::deque<ArtField*>* grouped_and_sorted_fields, 225 FieldGaps* gaps) 226 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 227 DCHECK(current_field_idx != nullptr); 228 DCHECK(grouped_and_sorted_fields != nullptr); 229 DCHECK(gaps != nullptr); 230 DCHECK(field_offset != nullptr); 231 232 DCHECK(IsPowerOfTwo(n)); 233 while (!grouped_and_sorted_fields->empty()) { 234 ArtField* field = grouped_and_sorted_fields->front(); 235 Primitive::Type type = field->GetTypeAsPrimitiveType(); 236 if (Primitive::ComponentSize(type) < n) { 237 break; 238 } 239 if (!IsAligned<n>(field_offset->Uint32Value())) { 240 MemberOffset old_offset = *field_offset; 241 *field_offset = MemberOffset(RoundUp(field_offset->Uint32Value(), n)); 242 AddFieldGap(old_offset.Uint32Value(), field_offset->Uint32Value(), gaps); 243 } 244 CHECK(type != Primitive::kPrimNot) << PrettyField(field); // should be primitive types 245 grouped_and_sorted_fields->pop_front(); 246 if (!gaps->empty() && gaps->top().size >= n) { 247 FieldGap gap = gaps->top(); 248 gaps->pop(); 249 DCHECK(IsAligned<n>(gap.start_offset)); 250 field->SetOffset(MemberOffset(gap.start_offset)); 251 if (gap.size > n) { 252 AddFieldGap(gap.start_offset + n, gap.start_offset + gap.size, gaps); 253 } 254 } else { 255 DCHECK(IsAligned<n>(field_offset->Uint32Value())); 256 field->SetOffset(*field_offset); 257 *field_offset = MemberOffset(field_offset->Uint32Value() + n); 258 } 259 ++(*current_field_idx); 260 } 261} 262 263ClassLinker::ClassLinker(InternTable* intern_table) 264 // dex_lock_ is recursive as it may be used in stack dumping. 265 : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel), 266 dex_cache_image_class_lookup_required_(false), 267 failed_dex_cache_class_lookups_(0), 268 class_roots_(nullptr), 269 array_iftable_(nullptr), 270 find_array_class_cache_next_victim_(0), 271 init_done_(false), 272 log_new_dex_caches_roots_(false), 273 log_new_class_table_roots_(false), 274 intern_table_(intern_table), 275 quick_resolution_trampoline_(nullptr), 276 quick_imt_conflict_trampoline_(nullptr), 277 quick_generic_jni_trampoline_(nullptr), 278 quick_to_interpreter_bridge_trampoline_(nullptr), 279 image_pointer_size_(sizeof(void*)) { 280 CHECK(intern_table_ != nullptr); 281 for (size_t i = 0; i < kFindArrayCacheSize; ++i) { 282 find_array_class_cache_[i] = GcRoot<mirror::Class>(nullptr); 283 } 284} 285 286void ClassLinker::InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path) { 287 VLOG(startup) << "ClassLinker::Init"; 288 CHECK(!Runtime::Current()->GetHeap()->HasImageSpace()) << "Runtime has image. We should use it."; 289 290 CHECK(!init_done_); 291 292 // java_lang_Class comes first, it's needed for AllocClass 293 Thread* const self = Thread::Current(); 294 gc::Heap* const heap = Runtime::Current()->GetHeap(); 295 // The GC can't handle an object with a null class since we can't get the size of this object. 296 heap->IncrementDisableMovingGC(self); 297 StackHandleScope<64> hs(self); // 64 is picked arbitrarily. 298 Handle<mirror::Class> java_lang_Class(hs.NewHandle(down_cast<mirror::Class*>( 299 heap->AllocNonMovableObject<true>(self, nullptr, 300 mirror::Class::ClassClassSize(), 301 VoidFunctor())))); 302 CHECK(java_lang_Class.Get() != nullptr); 303 mirror::Class::SetClassClass(java_lang_Class.Get()); 304 java_lang_Class->SetClass(java_lang_Class.Get()); 305 if (kUseBakerOrBrooksReadBarrier) { 306 java_lang_Class->AssertReadBarrierPointer(); 307 } 308 java_lang_Class->SetClassSize(mirror::Class::ClassClassSize()); 309 java_lang_Class->SetPrimitiveType(Primitive::kPrimNot); 310 heap->DecrementDisableMovingGC(self); 311 // AllocClass(mirror::Class*) can now be used 312 313 // Class[] is used for reflection support. 314 Handle<mirror::Class> class_array_class(hs.NewHandle( 315 AllocClass(self, java_lang_Class.Get(), mirror::ObjectArray<mirror::Class>::ClassSize()))); 316 class_array_class->SetComponentType(java_lang_Class.Get()); 317 318 // java_lang_Object comes next so that object_array_class can be created. 319 Handle<mirror::Class> java_lang_Object(hs.NewHandle( 320 AllocClass(self, java_lang_Class.Get(), mirror::Object::ClassSize()))); 321 CHECK(java_lang_Object.Get() != nullptr); 322 // backfill Object as the super class of Class. 323 java_lang_Class->SetSuperClass(java_lang_Object.Get()); 324 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusLoaded, self); 325 326 // Object[] next to hold class roots. 327 Handle<mirror::Class> object_array_class(hs.NewHandle( 328 AllocClass(self, java_lang_Class.Get(), mirror::ObjectArray<mirror::Object>::ClassSize()))); 329 object_array_class->SetComponentType(java_lang_Object.Get()); 330 331 // Setup the char (primitive) class to be used for char[]. 332 Handle<mirror::Class> char_class(hs.NewHandle( 333 AllocClass(self, java_lang_Class.Get(), mirror::Class::PrimitiveClassSize()))); 334 // The primitive char class won't be initialized by 335 // InitializePrimitiveClass until line 459, but strings (and 336 // internal char arrays) will be allocated before that and the 337 // component size, which is computed from the primitive type, needs 338 // to be set here. 339 char_class->SetPrimitiveType(Primitive::kPrimChar); 340 341 // Setup the char[] class to be used for String. 342 Handle<mirror::Class> char_array_class(hs.NewHandle( 343 AllocClass(self, java_lang_Class.Get(), 344 mirror::Array::ClassSize()))); 345 char_array_class->SetComponentType(char_class.Get()); 346 mirror::CharArray::SetArrayClass(char_array_class.Get()); 347 348 // Setup String. 349 Handle<mirror::Class> java_lang_String(hs.NewHandle( 350 AllocClass(self, java_lang_Class.Get(), mirror::String::ClassSize()))); 351 mirror::String::SetClass(java_lang_String.Get()); 352 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusResolved, self); 353 java_lang_String->SetStringClass(); 354 355 // Setup java.lang.ref.Reference. 356 Handle<mirror::Class> java_lang_ref_Reference(hs.NewHandle( 357 AllocClass(self, java_lang_Class.Get(), mirror::Reference::ClassSize()))); 358 mirror::Reference::SetClass(java_lang_ref_Reference.Get()); 359 java_lang_ref_Reference->SetObjectSize(mirror::Reference::InstanceSize()); 360 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusResolved, self); 361 362 // Create storage for root classes, save away our work so far (requires descriptors). 363 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>( 364 mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.Get(), 365 kClassRootsMax)); 366 CHECK(!class_roots_.IsNull()); 367 SetClassRoot(kJavaLangClass, java_lang_Class.Get()); 368 SetClassRoot(kJavaLangObject, java_lang_Object.Get()); 369 SetClassRoot(kClassArrayClass, class_array_class.Get()); 370 SetClassRoot(kObjectArrayClass, object_array_class.Get()); 371 SetClassRoot(kCharArrayClass, char_array_class.Get()); 372 SetClassRoot(kJavaLangString, java_lang_String.Get()); 373 SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference.Get()); 374 375 // Setup the primitive type classes. 376 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean)); 377 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte)); 378 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort)); 379 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt)); 380 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong)); 381 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat)); 382 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble)); 383 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid)); 384 385 // Create array interface entries to populate once we can load system classes. 386 array_iftable_ = GcRoot<mirror::IfTable>(AllocIfTable(self, 2)); 387 388 // Create int array type for AllocDexCache (done in AppendToBootClassPath). 389 Handle<mirror::Class> int_array_class(hs.NewHandle( 390 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize()))); 391 int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt)); 392 mirror::IntArray::SetArrayClass(int_array_class.Get()); 393 SetClassRoot(kIntArrayClass, int_array_class.Get()); 394 395 // Create long array type for AllocDexCache (done in AppendToBootClassPath). 396 Handle<mirror::Class> long_array_class(hs.NewHandle( 397 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize()))); 398 long_array_class->SetComponentType(GetClassRoot(kPrimitiveLong)); 399 mirror::LongArray::SetArrayClass(long_array_class.Get()); 400 SetClassRoot(kLongArrayClass, long_array_class.Get()); 401 402 // now that these are registered, we can use AllocClass() and AllocObjectArray 403 404 // Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache. 405 Handle<mirror::Class> java_lang_DexCache(hs.NewHandle( 406 AllocClass(self, java_lang_Class.Get(), mirror::DexCache::ClassSize()))); 407 SetClassRoot(kJavaLangDexCache, java_lang_DexCache.Get()); 408 java_lang_DexCache->SetObjectSize(mirror::DexCache::InstanceSize()); 409 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusResolved, self); 410 411 // Constructor, Method, and AbstractMethod are necessary so 412 // that FindClass can link members. 413 414 Handle<mirror::Class> java_lang_reflect_ArtMethod(hs.NewHandle( 415 AllocClass(self, java_lang_Class.Get(), mirror::ArtMethod::ClassSize()))); 416 CHECK(java_lang_reflect_ArtMethod.Get() != nullptr); 417 size_t pointer_size = GetInstructionSetPointerSize(Runtime::Current()->GetInstructionSet()); 418 java_lang_reflect_ArtMethod->SetObjectSize(mirror::ArtMethod::InstanceSize(pointer_size)); 419 SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.Get()); 420 mirror::Class::SetStatus(java_lang_reflect_ArtMethod, mirror::Class::kStatusResolved, self); 421 mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.Get()); 422 423 // Set up array classes for string, field, method 424 Handle<mirror::Class> object_array_string(hs.NewHandle( 425 AllocClass(self, java_lang_Class.Get(), 426 mirror::ObjectArray<mirror::String>::ClassSize()))); 427 object_array_string->SetComponentType(java_lang_String.Get()); 428 SetClassRoot(kJavaLangStringArrayClass, object_array_string.Get()); 429 430 Handle<mirror::Class> object_array_art_method(hs.NewHandle( 431 AllocClass(self, java_lang_Class.Get(), 432 mirror::ObjectArray<mirror::ArtMethod>::ClassSize()))); 433 object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.Get()); 434 SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.Get()); 435 436 // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create 437 // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses 438 // these roots. 439 CHECK_NE(0U, boot_class_path.size()); 440 for (auto& dex_file : boot_class_path) { 441 CHECK(dex_file.get() != nullptr); 442 AppendToBootClassPath(self, *dex_file); 443 opened_dex_files_.push_back(std::move(dex_file)); 444 } 445 446 // now we can use FindSystemClass 447 448 // run char class through InitializePrimitiveClass to finish init 449 InitializePrimitiveClass(char_class.Get(), Primitive::kPrimChar); 450 SetClassRoot(kPrimitiveChar, char_class.Get()); // needs descriptor 451 452 // Create runtime resolution and imt conflict methods. Also setup the default imt. 453 Runtime* runtime = Runtime::Current(); 454 runtime->SetResolutionMethod(runtime->CreateResolutionMethod()); 455 runtime->SetImtConflictMethod(runtime->CreateImtConflictMethod()); 456 runtime->SetImtUnimplementedMethod(runtime->CreateImtConflictMethod()); 457 runtime->SetDefaultImt(runtime->CreateDefaultImt(this)); 458 459 // Set up GenericJNI entrypoint. That is mainly a hack for common_compiler_test.h so that 460 // we do not need friend classes or a publicly exposed setter. 461 quick_generic_jni_trampoline_ = GetQuickGenericJniStub(); 462 if (!runtime->IsAotCompiler()) { 463 // We need to set up the generic trampolines since we don't have an image. 464 quick_resolution_trampoline_ = GetQuickResolutionStub(); 465 quick_imt_conflict_trampoline_ = GetQuickImtConflictStub(); 466 quick_to_interpreter_bridge_trampoline_ = GetQuickToInterpreterBridge(); 467 } 468 469 // Object, String and DexCache need to be rerun through FindSystemClass to finish init 470 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusNotReady, self); 471 CHECK_EQ(java_lang_Object.Get(), FindSystemClass(self, "Ljava/lang/Object;")); 472 CHECK_EQ(java_lang_Object->GetObjectSize(), mirror::Object::InstanceSize()); 473 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusNotReady, self); 474 mirror::Class* String_class = FindSystemClass(self, "Ljava/lang/String;"); 475 if (java_lang_String.Get() != String_class) { 476 std::ostringstream os1, os2; 477 java_lang_String->DumpClass(os1, mirror::Class::kDumpClassFullDetail); 478 String_class->DumpClass(os2, mirror::Class::kDumpClassFullDetail); 479 LOG(FATAL) << os1.str() << "\n\n" << os2.str(); 480 } 481 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusNotReady, self); 482 CHECK_EQ(java_lang_DexCache.Get(), FindSystemClass(self, "Ljava/lang/DexCache;")); 483 CHECK_EQ(java_lang_DexCache->GetObjectSize(), mirror::DexCache::InstanceSize()); 484 485 // Setup the primitive array type classes - can't be done until Object has a vtable. 486 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z")); 487 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass)); 488 489 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B")); 490 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass)); 491 492 CHECK_EQ(char_array_class.Get(), FindSystemClass(self, "[C")); 493 494 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S")); 495 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass)); 496 497 CHECK_EQ(int_array_class.Get(), FindSystemClass(self, "[I")); 498 499 CHECK_EQ(long_array_class.Get(), FindSystemClass(self, "[J")); 500 501 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F")); 502 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass)); 503 504 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D")); 505 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass)); 506 507 CHECK_EQ(class_array_class.Get(), FindSystemClass(self, "[Ljava/lang/Class;")); 508 509 CHECK_EQ(object_array_class.Get(), FindSystemClass(self, "[Ljava/lang/Object;")); 510 511 // Setup the single, global copy of "iftable". 512 auto java_lang_Cloneable = hs.NewHandle(FindSystemClass(self, "Ljava/lang/Cloneable;")); 513 CHECK(java_lang_Cloneable.Get() != nullptr); 514 auto java_io_Serializable = hs.NewHandle(FindSystemClass(self, "Ljava/io/Serializable;")); 515 CHECK(java_io_Serializable.Get() != nullptr); 516 // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to 517 // crawl up and explicitly list all of the supers as well. 518 array_iftable_.Read()->SetInterface(0, java_lang_Cloneable.Get()); 519 array_iftable_.Read()->SetInterface(1, java_io_Serializable.Get()); 520 521 // Sanity check Class[] and Object[]'s interfaces. GetDirectInterface may cause thread 522 // suspension. 523 CHECK_EQ(java_lang_Cloneable.Get(), 524 mirror::Class::GetDirectInterface(self, class_array_class, 0)); 525 CHECK_EQ(java_io_Serializable.Get(), 526 mirror::Class::GetDirectInterface(self, class_array_class, 1)); 527 CHECK_EQ(java_lang_Cloneable.Get(), 528 mirror::Class::GetDirectInterface(self, object_array_class, 0)); 529 CHECK_EQ(java_io_Serializable.Get(), 530 mirror::Class::GetDirectInterface(self, object_array_class, 1)); 531 // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their 532 // dex_cache_ fields and register them in class_table_. 533 CHECK_EQ(java_lang_Class.Get(), FindSystemClass(self, "Ljava/lang/Class;")); 534 535 mirror::Class::SetStatus(java_lang_reflect_ArtMethod, mirror::Class::kStatusNotReady, self); 536 CHECK_EQ(java_lang_reflect_ArtMethod.Get(), 537 FindSystemClass(self, "Ljava/lang/reflect/ArtMethod;")); 538 CHECK_EQ(object_array_string.Get(), 539 FindSystemClass(self, GetClassRootDescriptor(kJavaLangStringArrayClass))); 540 CHECK_EQ(object_array_art_method.Get(), 541 FindSystemClass(self, GetClassRootDescriptor(kJavaLangReflectArtMethodArrayClass))); 542 543 // End of special init trickery, subsequent classes may be loaded via FindSystemClass. 544 545 // Create java.lang.reflect.Proxy root. 546 SetClassRoot(kJavaLangReflectProxy, FindSystemClass(self, "Ljava/lang/reflect/Proxy;")); 547 548 // Create java.lang.reflect.Field.class root. 549 auto* class_root = FindSystemClass(self, "Ljava/lang/reflect/Field;"); 550 CHECK(class_root != nullptr); 551 SetClassRoot(kJavaLangReflectField, class_root); 552 mirror::Field::SetClass(class_root); 553 554 // Create java.lang.reflect.Field array root. 555 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Field;"); 556 CHECK(class_root != nullptr); 557 SetClassRoot(kJavaLangReflectFieldArrayClass, class_root); 558 mirror::Field::SetArrayClass(class_root); 559 560 // Create java.lang.reflect.Constructor.class root and array root. 561 class_root = FindSystemClass(self, "Ljava/lang/reflect/Constructor;"); 562 CHECK(class_root != nullptr); 563 SetClassRoot(kJavaLangReflectConstructor, class_root); 564 mirror::Constructor::SetClass(class_root); 565 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Constructor;"); 566 CHECK(class_root != nullptr); 567 SetClassRoot(kJavaLangReflectConstructorArrayClass, class_root); 568 mirror::Constructor::SetArrayClass(class_root); 569 570 // Create java.lang.reflect.Method.class root and array root. 571 class_root = FindSystemClass(self, "Ljava/lang/reflect/Method;"); 572 CHECK(class_root != nullptr); 573 SetClassRoot(kJavaLangReflectMethod, class_root); 574 mirror::Method::SetClass(class_root); 575 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Method;"); 576 CHECK(class_root != nullptr); 577 SetClassRoot(kJavaLangReflectMethodArrayClass, class_root); 578 mirror::Method::SetArrayClass(class_root); 579 580 // java.lang.ref classes need to be specially flagged, but otherwise are normal classes 581 // finish initializing Reference class 582 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusNotReady, self); 583 CHECK_EQ(java_lang_ref_Reference.Get(), FindSystemClass(self, "Ljava/lang/ref/Reference;")); 584 CHECK_EQ(java_lang_ref_Reference->GetObjectSize(), mirror::Reference::InstanceSize()); 585 CHECK_EQ(java_lang_ref_Reference->GetClassSize(), mirror::Reference::ClassSize()); 586 class_root = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"); 587 class_root->SetAccessFlags(class_root->GetAccessFlags() | 588 kAccClassIsReference | kAccClassIsFinalizerReference); 589 class_root = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;"); 590 class_root->SetAccessFlags(class_root->GetAccessFlags() | kAccClassIsReference | 591 kAccClassIsPhantomReference); 592 class_root = FindSystemClass(self, "Ljava/lang/ref/SoftReference;"); 593 class_root->SetAccessFlags(class_root->GetAccessFlags() | kAccClassIsReference); 594 class_root = FindSystemClass(self, "Ljava/lang/ref/WeakReference;"); 595 class_root->SetAccessFlags(class_root->GetAccessFlags() | kAccClassIsReference | 596 kAccClassIsWeakReference); 597 598 // Setup the ClassLoader, verifying the object_size_. 599 class_root = FindSystemClass(self, "Ljava/lang/ClassLoader;"); 600 CHECK_EQ(class_root->GetObjectSize(), mirror::ClassLoader::InstanceSize()); 601 SetClassRoot(kJavaLangClassLoader, class_root); 602 603 // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and 604 // java.lang.StackTraceElement as a convenience. 605 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;")); 606 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable)); 607 SetClassRoot(kJavaLangClassNotFoundException, 608 FindSystemClass(self, "Ljava/lang/ClassNotFoundException;")); 609 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;")); 610 SetClassRoot(kJavaLangStackTraceElementArrayClass, 611 FindSystemClass(self, "[Ljava/lang/StackTraceElement;")); 612 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement)); 613 614 // Ensure void type is resolved in the core's dex cache so java.lang.Void is correctly 615 // initialized. 616 { 617 const DexFile& dex_file = java_lang_Object->GetDexFile(); 618 const DexFile::StringId* void_string_id = dex_file.FindStringId("V"); 619 CHECK(void_string_id != nullptr); 620 uint32_t void_string_index = dex_file.GetIndexForStringId(*void_string_id); 621 const DexFile::TypeId* void_type_id = dex_file.FindTypeId(void_string_index); 622 CHECK(void_type_id != nullptr); 623 uint16_t void_type_idx = dex_file.GetIndexForTypeId(*void_type_id); 624 // Now we resolve void type so the dex cache contains it. We use java.lang.Object class 625 // as referrer so the used dex cache is core's one. 626 mirror::Class* resolved_type = ResolveType(dex_file, void_type_idx, java_lang_Object.Get()); 627 CHECK_EQ(resolved_type, GetClassRoot(kPrimitiveVoid)); 628 self->AssertNoPendingException(); 629 } 630 631 FinishInit(self); 632 633 VLOG(startup) << "ClassLinker::InitFromCompiler exiting"; 634} 635 636void ClassLinker::FinishInit(Thread* self) { 637 VLOG(startup) << "ClassLinker::FinishInit entering"; 638 639 // Let the heap know some key offsets into java.lang.ref instances 640 // Note: we hard code the field indexes here rather than using FindInstanceField 641 // as the types of the field can't be resolved prior to the runtime being 642 // fully initialized 643 mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference); 644 mirror::Class* java_lang_ref_FinalizerReference = 645 FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"); 646 647 ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0); 648 CHECK_STREQ(pendingNext->GetName(), "pendingNext"); 649 CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;"); 650 651 ArtField* queue = java_lang_ref_Reference->GetInstanceField(1); 652 CHECK_STREQ(queue->GetName(), "queue"); 653 CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;"); 654 655 ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2); 656 CHECK_STREQ(queueNext->GetName(), "queueNext"); 657 CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;"); 658 659 ArtField* referent = java_lang_ref_Reference->GetInstanceField(3); 660 CHECK_STREQ(referent->GetName(), "referent"); 661 CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;"); 662 663 ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2); 664 CHECK_STREQ(zombie->GetName(), "zombie"); 665 CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;"); 666 667 // ensure all class_roots_ are initialized 668 for (size_t i = 0; i < kClassRootsMax; i++) { 669 ClassRoot class_root = static_cast<ClassRoot>(i); 670 mirror::Class* klass = GetClassRoot(class_root); 671 CHECK(klass != nullptr); 672 DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != nullptr); 673 // note SetClassRoot does additional validation. 674 // if possible add new checks there to catch errors early 675 } 676 677 CHECK(!array_iftable_.IsNull()); 678 679 // disable the slow paths in FindClass and CreatePrimitiveClass now 680 // that Object, Class, and Object[] are setup 681 init_done_ = true; 682 683 VLOG(startup) << "ClassLinker::FinishInit exiting"; 684} 685 686void ClassLinker::RunRootClinits() { 687 Thread* self = Thread::Current(); 688 for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) { 689 mirror::Class* c = GetClassRoot(ClassRoot(i)); 690 if (!c->IsArrayClass() && !c->IsPrimitive()) { 691 StackHandleScope<1> hs(self); 692 Handle<mirror::Class> h_class(hs.NewHandle(GetClassRoot(ClassRoot(i)))); 693 EnsureInitialized(self, h_class, true, true); 694 self->AssertNoPendingException(); 695 } 696 } 697} 698 699const OatFile* ClassLinker::RegisterOatFile(const OatFile* oat_file) { 700 WriterMutexLock mu(Thread::Current(), dex_lock_); 701 if (kIsDebugBuild) { 702 for (size_t i = 0; i < oat_files_.size(); ++i) { 703 CHECK_NE(oat_file, oat_files_[i]) << oat_file->GetLocation(); 704 } 705 } 706 VLOG(class_linker) << "Registering " << oat_file->GetLocation(); 707 oat_files_.push_back(oat_file); 708 return oat_file; 709} 710 711OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) { 712 VLOG(startup) << "ClassLinker::GetImageOatFile entering"; 713 OatFile* oat_file = space->ReleaseOatFile(); 714 CHECK_EQ(RegisterOatFile(oat_file), oat_file); 715 VLOG(startup) << "ClassLinker::GetImageOatFile exiting"; 716 return *oat_file; 717} 718 719class DexFileAndClassPair : ValueObject { 720 public: 721 DexFileAndClassPair(const DexFile* dex_file, size_t current_class_index, bool from_loaded_oat) 722 : cached_descriptor_(GetClassDescriptor(dex_file, current_class_index)), 723 dex_file_(dex_file), 724 current_class_index_(current_class_index), 725 from_loaded_oat_(from_loaded_oat) {} 726 727 DexFileAndClassPair(const DexFileAndClassPair&) = default; 728 729 DexFileAndClassPair& operator=(const DexFileAndClassPair& rhs) { 730 cached_descriptor_ = rhs.cached_descriptor_; 731 dex_file_ = rhs.dex_file_; 732 current_class_index_ = rhs.current_class_index_; 733 from_loaded_oat_ = rhs.from_loaded_oat_; 734 return *this; 735 } 736 737 const char* GetCachedDescriptor() const { 738 return cached_descriptor_; 739 } 740 741 bool operator<(const DexFileAndClassPair& rhs) const { 742 const char* lhsDescriptor = cached_descriptor_; 743 const char* rhsDescriptor = rhs.cached_descriptor_; 744 int cmp = strcmp(lhsDescriptor, rhsDescriptor); 745 if (cmp != 0) { 746 return cmp > 0; 747 } 748 return dex_file_ < rhs.dex_file_; 749 } 750 751 bool DexFileHasMoreClasses() const { 752 return current_class_index_ + 1 < dex_file_->NumClassDefs(); 753 } 754 755 DexFileAndClassPair GetNext() const { 756 return DexFileAndClassPair(dex_file_, current_class_index_ + 1, from_loaded_oat_); 757 } 758 759 size_t GetCurrentClassIndex() const { 760 return current_class_index_; 761 } 762 763 bool FromLoadedOat() const { 764 return from_loaded_oat_; 765 } 766 767 const DexFile* GetDexFile() const { 768 return dex_file_; 769 } 770 771 private: 772 static const char* GetClassDescriptor(const DexFile* dex_file, size_t index) { 773 const DexFile::ClassDef& class_def = dex_file->GetClassDef(static_cast<uint16_t>(index)); 774 return dex_file->StringByTypeIdx(class_def.class_idx_); 775 } 776 777 const char* cached_descriptor_; 778 const DexFile* dex_file_; 779 size_t current_class_index_; 780 bool from_loaded_oat_; // We only need to compare mismatches between what we load now 781 // and what was loaded before. Any old duplicates must have been 782 // OK, and any new "internal" duplicates are as well (they must 783 // be from multidex, which resolves correctly). 784}; 785 786static void AddDexFilesFromOat(const OatFile* oat_file, bool already_loaded, 787 std::priority_queue<DexFileAndClassPair>* heap) { 788 const std::vector<const OatDexFile*>& oat_dex_files = oat_file->GetOatDexFiles(); 789 for (const OatDexFile* oat_dex_file : oat_dex_files) { 790 std::string error; 791 std::unique_ptr<const DexFile> dex_file = oat_dex_file->OpenDexFile(&error); 792 if (dex_file.get() == nullptr) { 793 LOG(WARNING) << "Could not create dex file from oat file: " << error; 794 } else { 795 if (dex_file->NumClassDefs() > 0U) { 796 heap->emplace(dex_file.release(), 0U, already_loaded); 797 } 798 } 799 } 800} 801 802static void AddNext(const DexFileAndClassPair& original, 803 std::priority_queue<DexFileAndClassPair>* heap) { 804 if (original.DexFileHasMoreClasses()) { 805 heap->push(original.GetNext()); 806 } else { 807 // Need to delete the dex file. 808 delete original.GetDexFile(); 809 } 810} 811 812static void FreeDexFilesInHeap(std::priority_queue<DexFileAndClassPair>* heap) { 813 while (!heap->empty()) { 814 delete heap->top().GetDexFile(); 815 heap->pop(); 816 } 817} 818 819// Check for class-def collisions in dex files. 820// 821// This works by maintaining a heap with one class from each dex file, sorted by the class 822// descriptor. Then a dex-file/class pair is continually removed from the heap and compared 823// against the following top element. If the descriptor is the same, it is now checked whether 824// the two elements agree on whether their dex file was from an already-loaded oat-file or the 825// new oat file. Any disagreement indicates a collision. 826bool ClassLinker::HasCollisions(const OatFile* oat_file, std::string* error_msg) { 827 if (!kCheckForDexCollisions) { 828 return false; 829 } 830 831 // Dex files are registered late - once a class is actually being loaded. We have to compare 832 // against the open oat files. 833 ReaderMutexLock mu(Thread::Current(), dex_lock_); 834 835 std::priority_queue<DexFileAndClassPair> heap; 836 837 // Add dex files from already loaded oat files, but skip boot. 838 { 839 // To grab the boot oat, look at the dex files in the boot classpath. 840 const OatFile* boot_oat = nullptr; 841 if (!boot_class_path_.empty()) { 842 const DexFile* boot_dex_file = boot_class_path_[0]; 843 // Is it from an oat file? 844 if (boot_dex_file->GetOatDexFile() != nullptr) { 845 boot_oat = boot_dex_file->GetOatDexFile()->GetOatFile(); 846 } 847 } 848 849 for (const OatFile* loaded_oat_file : oat_files_) { 850 if (loaded_oat_file == boot_oat) { 851 continue; 852 } 853 AddDexFilesFromOat(loaded_oat_file, true, &heap); 854 } 855 } 856 857 if (heap.empty()) { 858 // No other oat files, return early. 859 return false; 860 } 861 862 // Add dex files from the oat file to check. 863 AddDexFilesFromOat(oat_file, false, &heap); 864 865 // Now drain the heap. 866 while (!heap.empty()) { 867 DexFileAndClassPair compare_pop = heap.top(); 868 heap.pop(); 869 870 // Compare against the following elements. 871 while (!heap.empty()) { 872 DexFileAndClassPair top = heap.top(); 873 874 if (strcmp(compare_pop.GetCachedDescriptor(), top.GetCachedDescriptor()) == 0) { 875 // Same descriptor. Check whether it's crossing old-oat-files to new-oat-files. 876 if (compare_pop.FromLoadedOat() != top.FromLoadedOat()) { 877 *error_msg = 878 StringPrintf("Found duplicated class when checking oat files: '%s' in %s and %s", 879 compare_pop.GetCachedDescriptor(), 880 compare_pop.GetDexFile()->GetLocation().c_str(), 881 top.GetDexFile()->GetLocation().c_str()); 882 FreeDexFilesInHeap(&heap); 883 return true; 884 } 885 // Pop it. 886 heap.pop(); 887 AddNext(top, &heap); 888 } else { 889 // Something else. Done here. 890 break; 891 } 892 } 893 AddNext(compare_pop, &heap); 894 } 895 896 return false; 897} 898 899std::vector<std::unique_ptr<const DexFile>> ClassLinker::OpenDexFilesFromOat( 900 const char* dex_location, const char* oat_location, 901 std::vector<std::string>* error_msgs) { 902 CHECK(error_msgs != nullptr); 903 904 // Verify we aren't holding the mutator lock, which could starve GC if we 905 // have to generate or relocate an oat file. 906 Locks::mutator_lock_->AssertNotHeld(Thread::Current()); 907 908 OatFileAssistant oat_file_assistant(dex_location, oat_location, kRuntimeISA, 909 !Runtime::Current()->IsAotCompiler()); 910 911 // Lock the target oat location to avoid races generating and loading the 912 // oat file. 913 std::string error_msg; 914 if (!oat_file_assistant.Lock(&error_msg)) { 915 // Don't worry too much if this fails. If it does fail, it's unlikely we 916 // can generate an oat file anyway. 917 VLOG(class_linker) << "OatFileAssistant::Lock: " << error_msg; 918 } 919 920 // Check if we already have an up-to-date oat file open. 921 const OatFile* source_oat_file = nullptr; 922 { 923 ReaderMutexLock mu(Thread::Current(), dex_lock_); 924 for (const OatFile* oat_file : oat_files_) { 925 CHECK(oat_file != nullptr); 926 if (oat_file_assistant.GivenOatFileIsUpToDate(*oat_file)) { 927 source_oat_file = oat_file; 928 break; 929 } 930 } 931 } 932 933 // If we didn't have an up-to-date oat file open, try to load one from disk. 934 if (source_oat_file == nullptr) { 935 // Update the oat file on disk if we can. This may fail, but that's okay. 936 // Best effort is all that matters here. 937 if (!oat_file_assistant.MakeUpToDate(&error_msg)) { 938 LOG(WARNING) << error_msg; 939 } 940 941 // Get the oat file on disk. 942 std::unique_ptr<OatFile> oat_file = oat_file_assistant.GetBestOatFile(); 943 if (oat_file.get() != nullptr) { 944 // Take the file only if it has no collisions. 945 if (!HasCollisions(oat_file.get(), &error_msg)) { 946 source_oat_file = oat_file.release(); 947 RegisterOatFile(source_oat_file); 948 } else { 949 if (Runtime::Current()->IsDexFileFallbackEnabled()) { 950 LOG(WARNING) << "Found duplicate classes, falling back to interpreter mode for " 951 << dex_location; 952 } else { 953 LOG(WARNING) << "Found duplicate classes, dex-file-fallback disabled, will be failing to " 954 " load classes for " << dex_location; 955 } 956 LOG(WARNING) << error_msg; 957 } 958 } 959 } 960 961 std::vector<std::unique_ptr<const DexFile>> dex_files; 962 963 // Load the dex files from the oat file. 964 if (source_oat_file != nullptr) { 965 dex_files = oat_file_assistant.LoadDexFiles(*source_oat_file, dex_location); 966 if (dex_files.empty()) { 967 error_msgs->push_back("Failed to open dex files from " 968 + source_oat_file->GetLocation()); 969 } 970 } 971 972 // Fall back to running out of the original dex file if we couldn't load any 973 // dex_files from the oat file. 974 if (dex_files.empty()) { 975 if (Runtime::Current()->IsDexFileFallbackEnabled()) { 976 if (!DexFile::Open(dex_location, dex_location, &error_msg, &dex_files)) { 977 LOG(WARNING) << error_msg; 978 error_msgs->push_back("Failed to open dex files from " 979 + std::string(dex_location)); 980 } 981 } else { 982 error_msgs->push_back("Fallback mode disabled, skipping dex files."); 983 } 984 } 985 return dex_files; 986} 987 988const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) { 989 ReaderMutexLock mu(Thread::Current(), dex_lock_); 990 for (size_t i = 0; i < oat_files_.size(); i++) { 991 const OatFile* oat_file = oat_files_[i]; 992 DCHECK(oat_file != nullptr); 993 if (oat_file->GetLocation() == oat_location) { 994 return oat_file; 995 } 996 } 997 return nullptr; 998} 999 1000void ClassLinker::InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg) { 1001 ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg); 1002 DCHECK(obj != nullptr); 1003 DCHECK(class_linker != nullptr); 1004 if (obj->IsArtMethod()) { 1005 mirror::ArtMethod* method = obj->AsArtMethod(); 1006 if (!method->IsNative()) { 1007 const size_t pointer_size = class_linker->image_pointer_size_; 1008 method->SetEntryPointFromInterpreterPtrSize(artInterpreterToInterpreterBridge, pointer_size); 1009 if (!method->IsRuntimeMethod() && method != Runtime::Current()->GetResolutionMethod()) { 1010 method->SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(), 1011 pointer_size); 1012 } 1013 } 1014 } 1015} 1016 1017void SanityCheckObjectsCallback(mirror::Object* obj, void* arg ATTRIBUTE_UNUSED) 1018 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 1019 DCHECK(obj != nullptr); 1020 CHECK(obj->GetClass() != nullptr) << "Null class " << obj; 1021 CHECK(obj->GetClass()->GetClass() != nullptr) << "Null class class " << obj; 1022 if (obj->IsClass()) { 1023 auto klass = obj->AsClass(); 1024 ArtField* fields[2] = { klass->GetSFields(), klass->GetIFields() }; 1025 size_t num_fields[2] = { klass->NumStaticFields(), klass->NumInstanceFields() }; 1026 for (size_t i = 0; i < 2; ++i) { 1027 for (size_t j = 0; j < num_fields[i]; ++j) { 1028 CHECK_EQ(fields[i][j].GetDeclaringClass(), klass); 1029 } 1030 } 1031 } 1032} 1033 1034void ClassLinker::InitFromImage() { 1035 VLOG(startup) << "ClassLinker::InitFromImage entering"; 1036 CHECK(!init_done_); 1037 1038 Runtime* const runtime = Runtime::Current(); 1039 Thread* const self = Thread::Current(); 1040 gc::Heap* const heap = runtime->GetHeap(); 1041 gc::space::ImageSpace* const space = heap->GetImageSpace(); 1042 dex_cache_image_class_lookup_required_ = true; 1043 CHECK(space != nullptr); 1044 OatFile& oat_file = GetImageOatFile(space); 1045 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U); 1046 CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U); 1047 const char* image_file_location = oat_file.GetOatHeader(). 1048 GetStoreValueByKey(OatHeader::kImageLocationKey); 1049 CHECK(image_file_location == nullptr || *image_file_location == 0); 1050 quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline(); 1051 quick_imt_conflict_trampoline_ = oat_file.GetOatHeader().GetQuickImtConflictTrampoline(); 1052 quick_generic_jni_trampoline_ = oat_file.GetOatHeader().GetQuickGenericJniTrampoline(); 1053 quick_to_interpreter_bridge_trampoline_ = oat_file.GetOatHeader().GetQuickToInterpreterBridge(); 1054 mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches); 1055 mirror::ObjectArray<mirror::DexCache>* dex_caches = 1056 dex_caches_object->AsObjectArray<mirror::DexCache>(); 1057 1058 StackHandleScope<1> hs(self); 1059 Handle<mirror::ObjectArray<mirror::Class>> class_roots(hs.NewHandle( 1060 space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)-> 1061 AsObjectArray<mirror::Class>())); 1062 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(class_roots.Get()); 1063 1064 // Special case of setting up the String class early so that we can test arbitrary objects 1065 // as being Strings or not 1066 mirror::String::SetClass(GetClassRoot(kJavaLangString)); 1067 1068 CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(), 1069 static_cast<uint32_t>(dex_caches->GetLength())); 1070 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 1071 StackHandleScope<1> hs2(self); 1072 Handle<mirror::DexCache> dex_cache(hs2.NewHandle(dex_caches->Get(i))); 1073 const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8()); 1074 const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location.c_str(), 1075 nullptr); 1076 CHECK(oat_dex_file != nullptr) << oat_file.GetLocation() << " " << dex_file_location; 1077 std::string error_msg; 1078 std::unique_ptr<const DexFile> dex_file = oat_dex_file->OpenDexFile(&error_msg); 1079 if (dex_file.get() == nullptr) { 1080 LOG(FATAL) << "Failed to open dex file " << dex_file_location 1081 << " from within oat file " << oat_file.GetLocation() 1082 << " error '" << error_msg << "'"; 1083 UNREACHABLE(); 1084 } 1085 1086 CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum()); 1087 1088 AppendToBootClassPath(*dex_file.get(), dex_cache); 1089 opened_dex_files_.push_back(std::move(dex_file)); 1090 } 1091 1092 // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live 1093 // bitmap walk. 1094 mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod)); 1095 size_t art_method_object_size = mirror::ArtMethod::GetJavaLangReflectArtMethod()->GetObjectSize(); 1096 if (!runtime->IsAotCompiler()) { 1097 // Aot compiler supports having an image with a different pointer size than the runtime. This 1098 // happens on the host for compile 32 bit tests since we use a 64 bit libart compiler. We may 1099 // also use 32 bit dex2oat on a system with 64 bit apps. 1100 CHECK_EQ(art_method_object_size, mirror::ArtMethod::InstanceSize(sizeof(void*))) 1101 << sizeof(void*); 1102 } 1103 if (art_method_object_size == mirror::ArtMethod::InstanceSize(4)) { 1104 image_pointer_size_ = 4; 1105 } else { 1106 CHECK_EQ(art_method_object_size, mirror::ArtMethod::InstanceSize(8)); 1107 image_pointer_size_ = 8; 1108 } 1109 1110 // Set entry point to interpreter if in InterpretOnly mode. 1111 if (!runtime->IsAotCompiler() && runtime->GetInstrumentation()->InterpretOnly()) { 1112 heap->VisitObjects(InitFromImageInterpretOnlyCallback, this); 1113 } 1114 if (kSanityCheckObjects) { 1115 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 1116 auto* dex_cache = dex_caches->Get(i); 1117 for (size_t j = 0; j < dex_cache->NumResolvedFields(); ++j) { 1118 auto* field = dex_cache->GetResolvedField(j, image_pointer_size_); 1119 if (field != nullptr) { 1120 CHECK(field->GetDeclaringClass()->GetClass() != nullptr); 1121 } 1122 } 1123 } 1124 heap->VisitObjects(SanityCheckObjectsCallback, nullptr); 1125 } 1126 1127 // reinit class_roots_ 1128 mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass)); 1129 class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(class_roots.Get()); 1130 1131 // reinit array_iftable_ from any array class instance, they should be == 1132 array_iftable_ = GcRoot<mirror::IfTable>(GetClassRoot(kObjectArrayClass)->GetIfTable()); 1133 DCHECK_EQ(array_iftable_.Read(), GetClassRoot(kBooleanArrayClass)->GetIfTable()); 1134 // String class root was set above 1135 mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField)); 1136 mirror::Field::SetArrayClass(GetClassRoot(kJavaLangReflectFieldArrayClass)); 1137 mirror::Constructor::SetClass(GetClassRoot(kJavaLangReflectConstructor)); 1138 mirror::Constructor::SetArrayClass(GetClassRoot(kJavaLangReflectConstructorArrayClass)); 1139 mirror::Method::SetClass(GetClassRoot(kJavaLangReflectMethod)); 1140 mirror::Method::SetArrayClass(GetClassRoot(kJavaLangReflectMethodArrayClass)); 1141 mirror::Reference::SetClass(GetClassRoot(kJavaLangRefReference)); 1142 mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass)); 1143 mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass)); 1144 mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass)); 1145 mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass)); 1146 mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass)); 1147 mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass)); 1148 mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass)); 1149 mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass)); 1150 mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable)); 1151 mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement)); 1152 1153 FinishInit(self); 1154 1155 VLOG(startup) << "ClassLinker::InitFromImage exiting"; 1156} 1157 1158void ClassLinker::VisitClassRoots(RootVisitor* visitor, VisitRootFlags flags) { 1159 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 1160 BufferedRootVisitor<kDefaultBufferedRootCount> buffered_visitor( 1161 visitor, RootInfo(kRootStickyClass)); 1162 if ((flags & kVisitRootFlagAllRoots) != 0) { 1163 for (GcRoot<mirror::Class>& root : class_table_) { 1164 buffered_visitor.VisitRoot(root); 1165 root.Read()->VisitFieldRoots(buffered_visitor); 1166 } 1167 // PreZygote classes can't move so we won't need to update fields' declaring classes. 1168 for (GcRoot<mirror::Class>& root : pre_zygote_class_table_) { 1169 buffered_visitor.VisitRoot(root); 1170 root.Read()->VisitFieldRoots(buffered_visitor); 1171 } 1172 } else if ((flags & kVisitRootFlagNewRoots) != 0) { 1173 for (auto& root : new_class_roots_) { 1174 mirror::Class* old_ref = root.Read<kWithoutReadBarrier>(); 1175 old_ref->VisitFieldRoots(buffered_visitor); 1176 root.VisitRoot(visitor, RootInfo(kRootStickyClass)); 1177 mirror::Class* new_ref = root.Read<kWithoutReadBarrier>(); 1178 if (UNLIKELY(new_ref != old_ref)) { 1179 // Uh ohes, GC moved a root in the log. Need to search the class_table and update the 1180 // corresponding object. This is slow, but luckily for us, this may only happen with a 1181 // concurrent moving GC. 1182 auto it = class_table_.Find(GcRoot<mirror::Class>(old_ref)); 1183 DCHECK(it != class_table_.end()); 1184 *it = GcRoot<mirror::Class>(new_ref); 1185 } 1186 } 1187 } 1188 buffered_visitor.Flush(); // Flush before clearing new_class_roots_. 1189 if ((flags & kVisitRootFlagClearRootLog) != 0) { 1190 new_class_roots_.clear(); 1191 } 1192 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) { 1193 log_new_class_table_roots_ = true; 1194 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) { 1195 log_new_class_table_roots_ = false; 1196 } 1197 // We deliberately ignore the class roots in the image since we 1198 // handle image roots by using the MS/CMS rescanning of dirty cards. 1199} 1200 1201// Keep in sync with InitCallback. Anything we visit, we need to 1202// reinit references to when reinitializing a ClassLinker from a 1203// mapped image. 1204void ClassLinker::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) { 1205 class_roots_.VisitRoot(visitor, RootInfo(kRootVMInternal)); 1206 Thread* const self = Thread::Current(); 1207 { 1208 ReaderMutexLock mu(self, dex_lock_); 1209 if ((flags & kVisitRootFlagAllRoots) != 0) { 1210 for (GcRoot<mirror::DexCache>& dex_cache : dex_caches_) { 1211 dex_cache.VisitRoot(visitor, RootInfo(kRootVMInternal)); 1212 } 1213 } else if ((flags & kVisitRootFlagNewRoots) != 0) { 1214 for (size_t index : new_dex_cache_roots_) { 1215 dex_caches_[index].VisitRoot(visitor, RootInfo(kRootVMInternal)); 1216 } 1217 } 1218 if ((flags & kVisitRootFlagClearRootLog) != 0) { 1219 new_dex_cache_roots_.clear(); 1220 } 1221 if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) { 1222 log_new_dex_caches_roots_ = true; 1223 } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) { 1224 log_new_dex_caches_roots_ = false; 1225 } 1226 } 1227 VisitClassRoots(visitor, flags); 1228 array_iftable_.VisitRoot(visitor, RootInfo(kRootVMInternal)); 1229 for (size_t i = 0; i < kFindArrayCacheSize; ++i) { 1230 find_array_class_cache_[i].VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal)); 1231 } 1232} 1233 1234void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) { 1235 if (dex_cache_image_class_lookup_required_) { 1236 MoveImageClassesToClassTable(); 1237 } 1238 // TODO: why isn't this a ReaderMutexLock? 1239 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 1240 for (GcRoot<mirror::Class>& root : class_table_) { 1241 if (!visitor(root.Read(), arg)) { 1242 return; 1243 } 1244 } 1245 for (GcRoot<mirror::Class>& root : pre_zygote_class_table_) { 1246 if (!visitor(root.Read(), arg)) { 1247 return; 1248 } 1249 } 1250} 1251 1252static bool GetClassesVisitorSet(mirror::Class* c, void* arg) { 1253 std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg); 1254 classes->insert(c); 1255 return true; 1256} 1257 1258struct GetClassesVisitorArrayArg { 1259 Handle<mirror::ObjectArray<mirror::Class>>* classes; 1260 int32_t index; 1261 bool success; 1262}; 1263 1264static bool GetClassesVisitorArray(mirror::Class* c, void* varg) 1265 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 1266 GetClassesVisitorArrayArg* arg = reinterpret_cast<GetClassesVisitorArrayArg*>(varg); 1267 if (arg->index < (*arg->classes)->GetLength()) { 1268 (*arg->classes)->Set(arg->index, c); 1269 arg->index++; 1270 return true; 1271 } else { 1272 arg->success = false; 1273 return false; 1274 } 1275} 1276 1277void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) { 1278 // TODO: it may be possible to avoid secondary storage if we iterate over dex caches. The problem 1279 // is avoiding duplicates. 1280 if (!kMovingClasses) { 1281 std::set<mirror::Class*> classes; 1282 VisitClasses(GetClassesVisitorSet, &classes); 1283 for (mirror::Class* klass : classes) { 1284 if (!visitor(klass, arg)) { 1285 return; 1286 } 1287 } 1288 } else { 1289 Thread* self = Thread::Current(); 1290 StackHandleScope<1> hs(self); 1291 MutableHandle<mirror::ObjectArray<mirror::Class>> classes = 1292 hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr); 1293 GetClassesVisitorArrayArg local_arg; 1294 local_arg.classes = &classes; 1295 local_arg.success = false; 1296 // We size the array assuming classes won't be added to the class table during the visit. 1297 // If this assumption fails we iterate again. 1298 while (!local_arg.success) { 1299 size_t class_table_size; 1300 { 1301 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 1302 class_table_size = class_table_.Size() + pre_zygote_class_table_.Size(); 1303 } 1304 mirror::Class* class_type = mirror::Class::GetJavaLangClass(); 1305 mirror::Class* array_of_class = FindArrayClass(self, &class_type); 1306 classes.Assign( 1307 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size)); 1308 CHECK(classes.Get() != nullptr); // OOME. 1309 local_arg.index = 0; 1310 local_arg.success = true; 1311 VisitClasses(GetClassesVisitorArray, &local_arg); 1312 } 1313 for (int32_t i = 0; i < classes->GetLength(); ++i) { 1314 // If the class table shrank during creation of the clases array we expect null elements. If 1315 // the class table grew then the loop repeats. If classes are created after the loop has 1316 // finished then we don't visit. 1317 mirror::Class* klass = classes->Get(i); 1318 if (klass != nullptr && !visitor(klass, arg)) { 1319 return; 1320 } 1321 } 1322 } 1323} 1324 1325ClassLinker::~ClassLinker() { 1326 mirror::ArtMethod::ResetClass(); 1327 mirror::Class::ResetClass(); 1328 mirror::Constructor::ResetClass(); 1329 mirror::Field::ResetClass(); 1330 mirror::Method::ResetClass(); 1331 mirror::Reference::ResetClass(); 1332 mirror::StackTraceElement::ResetClass(); 1333 mirror::String::ResetClass(); 1334 mirror::Throwable::ResetClass(); 1335 mirror::BooleanArray::ResetArrayClass(); 1336 mirror::ByteArray::ResetArrayClass(); 1337 mirror::CharArray::ResetArrayClass(); 1338 mirror::Constructor::ResetArrayClass(); 1339 mirror::DoubleArray::ResetArrayClass(); 1340 mirror::Field::ResetArrayClass(); 1341 mirror::FloatArray::ResetArrayClass(); 1342 mirror::Method::ResetArrayClass(); 1343 mirror::IntArray::ResetArrayClass(); 1344 mirror::LongArray::ResetArrayClass(); 1345 mirror::ShortArray::ResetArrayClass(); 1346 STLDeleteElements(&oat_files_); 1347} 1348 1349mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) { 1350 gc::Heap* const heap = Runtime::Current()->GetHeap(); 1351 StackHandleScope<16> hs(self); 1352 Handle<mirror::Class> dex_cache_class(hs.NewHandle(GetClassRoot(kJavaLangDexCache))); 1353 Handle<mirror::DexCache> dex_cache( 1354 hs.NewHandle(down_cast<mirror::DexCache*>( 1355 heap->AllocObject<true>(self, dex_cache_class.Get(), dex_cache_class->GetObjectSize(), 1356 VoidFunctor())))); 1357 if (dex_cache.Get() == nullptr) { 1358 return nullptr; 1359 } 1360 Handle<mirror::String> 1361 location(hs.NewHandle(intern_table_->InternStrong(dex_file.GetLocation().c_str()))); 1362 if (location.Get() == nullptr) { 1363 return nullptr; 1364 } 1365 Handle<mirror::ObjectArray<mirror::String>> 1366 strings(hs.NewHandle(AllocStringArray(self, dex_file.NumStringIds()))); 1367 if (strings.Get() == nullptr) { 1368 return nullptr; 1369 } 1370 Handle<mirror::ObjectArray<mirror::Class>> 1371 types(hs.NewHandle(AllocClassArray(self, dex_file.NumTypeIds()))); 1372 if (types.Get() == nullptr) { 1373 return nullptr; 1374 } 1375 Handle<mirror::ObjectArray<mirror::ArtMethod>> 1376 methods(hs.NewHandle(AllocArtMethodArray(self, dex_file.NumMethodIds()))); 1377 if (methods.Get() == nullptr) { 1378 return nullptr; 1379 } 1380 Handle<mirror::Array> fields; 1381 if (image_pointer_size_ == 8) { 1382 fields = hs.NewHandle<mirror::Array>(mirror::LongArray::Alloc(self, dex_file.NumFieldIds())); 1383 } else { 1384 fields = hs.NewHandle<mirror::Array>(mirror::IntArray::Alloc(self, dex_file.NumFieldIds())); 1385 } 1386 if (fields.Get() == nullptr) { 1387 return nullptr; 1388 } 1389 dex_cache->Init(&dex_file, location.Get(), strings.Get(), types.Get(), methods.Get(), 1390 fields.Get()); 1391 return dex_cache.Get(); 1392} 1393 1394mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class, 1395 uint32_t class_size) { 1396 DCHECK_GE(class_size, sizeof(mirror::Class)); 1397 gc::Heap* heap = Runtime::Current()->GetHeap(); 1398 mirror::Class::InitializeClassVisitor visitor(class_size); 1399 mirror::Object* k = kMovingClasses ? 1400 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) : 1401 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor); 1402 if (UNLIKELY(k == nullptr)) { 1403 CHECK(self->IsExceptionPending()); // OOME. 1404 return nullptr; 1405 } 1406 return k->AsClass(); 1407} 1408 1409mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) { 1410 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size); 1411} 1412 1413mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) { 1414 return down_cast<mirror::ArtMethod*>( 1415 GetClassRoot(kJavaLangReflectArtMethod)->AllocNonMovableObject(self)); 1416} 1417 1418mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray( 1419 Thread* self, size_t length) { 1420 return mirror::ObjectArray<mirror::StackTraceElement>::Alloc( 1421 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length); 1422} 1423 1424mirror::Class* ClassLinker::EnsureResolved(Thread* self, const char* descriptor, 1425 mirror::Class* klass) { 1426 DCHECK(klass != nullptr); 1427 1428 // For temporary classes we must wait for them to be retired. 1429 if (init_done_ && klass->IsTemp()) { 1430 CHECK(!klass->IsResolved()); 1431 if (klass->IsErroneous()) { 1432 ThrowEarlierClassFailure(klass); 1433 return nullptr; 1434 } 1435 StackHandleScope<1> hs(self); 1436 Handle<mirror::Class> h_class(hs.NewHandle(klass)); 1437 ObjectLock<mirror::Class> lock(self, h_class); 1438 // Loop and wait for the resolving thread to retire this class. 1439 while (!h_class->IsRetired() && !h_class->IsErroneous()) { 1440 lock.WaitIgnoringInterrupts(); 1441 } 1442 if (h_class->IsErroneous()) { 1443 ThrowEarlierClassFailure(h_class.Get()); 1444 return nullptr; 1445 } 1446 CHECK(h_class->IsRetired()); 1447 // Get the updated class from class table. 1448 klass = LookupClass(self, descriptor, ComputeModifiedUtf8Hash(descriptor), 1449 h_class.Get()->GetClassLoader()); 1450 } 1451 1452 // Wait for the class if it has not already been linked. 1453 if (!klass->IsResolved() && !klass->IsErroneous()) { 1454 StackHandleScope<1> hs(self); 1455 HandleWrapper<mirror::Class> h_class(hs.NewHandleWrapper(&klass)); 1456 ObjectLock<mirror::Class> lock(self, h_class); 1457 // Check for circular dependencies between classes. 1458 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) { 1459 ThrowClassCircularityError(h_class.Get()); 1460 mirror::Class::SetStatus(h_class, mirror::Class::kStatusError, self); 1461 return nullptr; 1462 } 1463 // Wait for the pending initialization to complete. 1464 while (!h_class->IsResolved() && !h_class->IsErroneous()) { 1465 lock.WaitIgnoringInterrupts(); 1466 } 1467 } 1468 1469 if (klass->IsErroneous()) { 1470 ThrowEarlierClassFailure(klass); 1471 return nullptr; 1472 } 1473 // Return the loaded class. No exceptions should be pending. 1474 CHECK(klass->IsResolved()) << PrettyClass(klass); 1475 self->AssertNoPendingException(); 1476 return klass; 1477} 1478 1479typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry; 1480 1481// Search a collection of DexFiles for a descriptor 1482ClassPathEntry FindInClassPath(const char* descriptor, 1483 size_t hash, const std::vector<const DexFile*>& class_path) { 1484 for (const DexFile* dex_file : class_path) { 1485 const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor, hash); 1486 if (dex_class_def != nullptr) { 1487 return ClassPathEntry(dex_file, dex_class_def); 1488 } 1489 } 1490 return ClassPathEntry(nullptr, nullptr); 1491} 1492 1493static bool IsBootClassLoader(ScopedObjectAccessAlreadyRunnable& soa, 1494 mirror::ClassLoader* class_loader) 1495 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 1496 return class_loader == nullptr || 1497 class_loader->GetClass() == 1498 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader); 1499} 1500 1501bool ClassLinker::FindClassInPathClassLoader(ScopedObjectAccessAlreadyRunnable& soa, 1502 Thread* self, const char* descriptor, 1503 size_t hash, 1504 Handle<mirror::ClassLoader> class_loader, 1505 mirror::Class** result) { 1506 // Termination case: boot class-loader. 1507 if (IsBootClassLoader(soa, class_loader.Get())) { 1508 // The boot class loader, search the boot class path. 1509 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_); 1510 if (pair.second != nullptr) { 1511 mirror::Class* klass = LookupClass(self, descriptor, hash, nullptr); 1512 if (klass != nullptr) { 1513 *result = EnsureResolved(self, descriptor, klass); 1514 } else { 1515 *result = DefineClass(self, descriptor, hash, NullHandle<mirror::ClassLoader>(), 1516 *pair.first, *pair.second); 1517 } 1518 if (*result == nullptr) { 1519 CHECK(self->IsExceptionPending()) << descriptor; 1520 self->ClearException(); 1521 } 1522 } else { 1523 *result = nullptr; 1524 } 1525 return true; 1526 } 1527 1528 // Unsupported class-loader? 1529 if (class_loader->GetClass() != 1530 soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader)) { 1531 *result = nullptr; 1532 return false; 1533 } 1534 1535 // Handles as RegisterDexFile may allocate dex caches (and cause thread suspension). 1536 StackHandleScope<4> hs(self); 1537 Handle<mirror::ClassLoader> h_parent(hs.NewHandle(class_loader->GetParent())); 1538 bool recursive_result = FindClassInPathClassLoader(soa, self, descriptor, hash, h_parent, result); 1539 1540 if (!recursive_result) { 1541 // Something wrong up the chain. 1542 return false; 1543 } 1544 1545 if (*result != nullptr) { 1546 // Found the class up the chain. 1547 return true; 1548 } 1549 1550 // Handle this step. 1551 // Handle as if this is the child PathClassLoader. 1552 // The class loader is a PathClassLoader which inherits from BaseDexClassLoader. 1553 // We need to get the DexPathList and loop through it. 1554 ArtField* const cookie_field = soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_cookie); 1555 ArtField* const dex_file_field = 1556 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile); 1557 mirror::Object* dex_path_list = 1558 soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList)-> 1559 GetObject(class_loader.Get()); 1560 if (dex_path_list != nullptr && dex_file_field != nullptr && cookie_field != nullptr) { 1561 // DexPathList has an array dexElements of Elements[] which each contain a dex file. 1562 mirror::Object* dex_elements_obj = 1563 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements)-> 1564 GetObject(dex_path_list); 1565 // Loop through each dalvik.system.DexPathList$Element's dalvik.system.DexFile and look 1566 // at the mCookie which is a DexFile vector. 1567 if (dex_elements_obj != nullptr) { 1568 Handle<mirror::ObjectArray<mirror::Object>> dex_elements = 1569 hs.NewHandle(dex_elements_obj->AsObjectArray<mirror::Object>()); 1570 for (int32_t i = 0; i < dex_elements->GetLength(); ++i) { 1571 mirror::Object* element = dex_elements->GetWithoutChecks(i); 1572 if (element == nullptr) { 1573 // Should never happen, fall back to java code to throw a NPE. 1574 break; 1575 } 1576 mirror::Object* dex_file = dex_file_field->GetObject(element); 1577 if (dex_file != nullptr) { 1578 mirror::LongArray* long_array = cookie_field->GetObject(dex_file)->AsLongArray(); 1579 if (long_array == nullptr) { 1580 // This should never happen so log a warning. 1581 LOG(WARNING) << "Null DexFile::mCookie for " << descriptor; 1582 break; 1583 } 1584 int32_t long_array_size = long_array->GetLength(); 1585 for (int32_t j = 0; j < long_array_size; ++j) { 1586 const DexFile* cp_dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>( 1587 long_array->GetWithoutChecks(j))); 1588 const DexFile::ClassDef* dex_class_def = cp_dex_file->FindClassDef(descriptor, hash); 1589 if (dex_class_def != nullptr) { 1590 RegisterDexFile(*cp_dex_file); 1591 mirror::Class* klass = DefineClass(self, descriptor, hash, class_loader, 1592 *cp_dex_file, *dex_class_def); 1593 if (klass == nullptr) { 1594 CHECK(self->IsExceptionPending()) << descriptor; 1595 self->ClearException(); 1596 // TODO: Is it really right to break here, and not check the other dex files? 1597 return true; 1598 } 1599 *result = klass; 1600 return true; 1601 } 1602 } 1603 } 1604 } 1605 } 1606 self->AssertNoPendingException(); 1607 } 1608 1609 // Result is still null from the parent call, no need to set it again... 1610 return true; 1611} 1612 1613mirror::Class* ClassLinker::FindClass(Thread* self, const char* descriptor, 1614 Handle<mirror::ClassLoader> class_loader) { 1615 DCHECK_NE(*descriptor, '\0') << "descriptor is empty string"; 1616 DCHECK(self != nullptr); 1617 self->AssertNoPendingException(); 1618 if (descriptor[1] == '\0') { 1619 // only the descriptors of primitive types should be 1 character long, also avoid class lookup 1620 // for primitive classes that aren't backed by dex files. 1621 return FindPrimitiveClass(descriptor[0]); 1622 } 1623 const size_t hash = ComputeModifiedUtf8Hash(descriptor); 1624 // Find the class in the loaded classes table. 1625 mirror::Class* klass = LookupClass(self, descriptor, hash, class_loader.Get()); 1626 if (klass != nullptr) { 1627 return EnsureResolved(self, descriptor, klass); 1628 } 1629 // Class is not yet loaded. 1630 if (descriptor[0] == '[') { 1631 return CreateArrayClass(self, descriptor, hash, class_loader); 1632 } else if (class_loader.Get() == nullptr) { 1633 // The boot class loader, search the boot class path. 1634 ClassPathEntry pair = FindInClassPath(descriptor, hash, boot_class_path_); 1635 if (pair.second != nullptr) { 1636 return DefineClass(self, descriptor, hash, NullHandle<mirror::ClassLoader>(), *pair.first, 1637 *pair.second); 1638 } else { 1639 // The boot class loader is searched ahead of the application class loader, failures are 1640 // expected and will be wrapped in a ClassNotFoundException. Use the pre-allocated error to 1641 // trigger the chaining with a proper stack trace. 1642 mirror::Throwable* pre_allocated = Runtime::Current()->GetPreAllocatedNoClassDefFoundError(); 1643 self->SetException(pre_allocated); 1644 return nullptr; 1645 } 1646 } else { 1647 ScopedObjectAccessUnchecked soa(self); 1648 mirror::Class* cp_klass; 1649 if (FindClassInPathClassLoader(soa, self, descriptor, hash, class_loader, &cp_klass)) { 1650 // The chain was understood. So the value in cp_klass is either the class we were looking 1651 // for, or not found. 1652 if (cp_klass != nullptr) { 1653 return cp_klass; 1654 } 1655 // TODO: We handle the boot classpath loader in FindClassInPathClassLoader. Try to unify this 1656 // and the branch above. TODO: throw the right exception here. 1657 1658 // We'll let the Java-side rediscover all this and throw the exception with the right stack 1659 // trace. 1660 } 1661 1662 if (Runtime::Current()->IsAotCompiler()) { 1663 // Oops, compile-time, can't run actual class-loader code. 1664 mirror::Throwable* pre_allocated = Runtime::Current()->GetPreAllocatedNoClassDefFoundError(); 1665 self->SetException(pre_allocated); 1666 return nullptr; 1667 } 1668 1669 ScopedLocalRef<jobject> class_loader_object(soa.Env(), 1670 soa.AddLocalReference<jobject>(class_loader.Get())); 1671 std::string class_name_string(DescriptorToDot(descriptor)); 1672 ScopedLocalRef<jobject> result(soa.Env(), nullptr); 1673 { 1674 ScopedThreadStateChange tsc(self, kNative); 1675 ScopedLocalRef<jobject> class_name_object(soa.Env(), 1676 soa.Env()->NewStringUTF(class_name_string.c_str())); 1677 if (class_name_object.get() == nullptr) { 1678 DCHECK(self->IsExceptionPending()); // OOME. 1679 return nullptr; 1680 } 1681 CHECK(class_loader_object.get() != nullptr); 1682 result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(), 1683 WellKnownClasses::java_lang_ClassLoader_loadClass, 1684 class_name_object.get())); 1685 } 1686 if (self->IsExceptionPending()) { 1687 // If the ClassLoader threw, pass that exception up. 1688 return nullptr; 1689 } else if (result.get() == nullptr) { 1690 // broken loader - throw NPE to be compatible with Dalvik 1691 ThrowNullPointerException(StringPrintf("ClassLoader.loadClass returned null for %s", 1692 class_name_string.c_str()).c_str()); 1693 return nullptr; 1694 } else { 1695 // success, return mirror::Class* 1696 return soa.Decode<mirror::Class*>(result.get()); 1697 } 1698 } 1699 UNREACHABLE(); 1700} 1701 1702mirror::Class* ClassLinker::DefineClass(Thread* self, const char* descriptor, size_t hash, 1703 Handle<mirror::ClassLoader> class_loader, 1704 const DexFile& dex_file, 1705 const DexFile::ClassDef& dex_class_def) { 1706 StackHandleScope<3> hs(self); 1707 auto klass = hs.NewHandle<mirror::Class>(nullptr); 1708 1709 // Load the class from the dex file. 1710 if (UNLIKELY(!init_done_)) { 1711 // finish up init of hand crafted class_roots_ 1712 if (strcmp(descriptor, "Ljava/lang/Object;") == 0) { 1713 klass.Assign(GetClassRoot(kJavaLangObject)); 1714 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) { 1715 klass.Assign(GetClassRoot(kJavaLangClass)); 1716 } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) { 1717 klass.Assign(GetClassRoot(kJavaLangString)); 1718 } else if (strcmp(descriptor, "Ljava/lang/ref/Reference;") == 0) { 1719 klass.Assign(GetClassRoot(kJavaLangRefReference)); 1720 } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) { 1721 klass.Assign(GetClassRoot(kJavaLangDexCache)); 1722 } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) { 1723 klass.Assign(GetClassRoot(kJavaLangReflectArtMethod)); 1724 } 1725 } 1726 1727 if (klass.Get() == nullptr) { 1728 // Allocate a class with the status of not ready. 1729 // Interface object should get the right size here. Regular class will 1730 // figure out the right size later and be replaced with one of the right 1731 // size when the class becomes resolved. 1732 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def))); 1733 } 1734 if (UNLIKELY(klass.Get() == nullptr)) { 1735 CHECK(self->IsExceptionPending()); // Expect an OOME. 1736 return nullptr; 1737 } 1738 klass->SetDexCache(FindDexCache(dex_file)); 1739 1740 SetupClass(dex_file, dex_class_def, klass, class_loader.Get()); 1741 1742 // Mark the string class by setting its access flag. 1743 if (UNLIKELY(!init_done_)) { 1744 if (strcmp(descriptor, "Ljava/lang/String;") == 0) { 1745 klass->SetStringClass(); 1746 } 1747 } 1748 1749 ObjectLock<mirror::Class> lock(self, klass); 1750 klass->SetClinitThreadId(self->GetTid()); 1751 1752 // Add the newly loaded class to the loaded classes table. 1753 mirror::Class* existing = InsertClass(descriptor, klass.Get(), hash); 1754 if (existing != nullptr) { 1755 // We failed to insert because we raced with another thread. Calling EnsureResolved may cause 1756 // this thread to block. 1757 return EnsureResolved(self, descriptor, existing); 1758 } 1759 1760 // Load the fields and other things after we are inserted in the table. This is so that we don't 1761 // end up allocating unfree-able linear alloc resources and then lose the race condition. The 1762 // other reason is that the field roots are only visited from the class table. So we need to be 1763 // inserted before we allocate / fill in these fields. 1764 LoadClass(self, dex_file, dex_class_def, klass); 1765 if (self->IsExceptionPending()) { 1766 // An exception occured during load, set status to erroneous while holding klass' lock in case 1767 // notification is necessary. 1768 if (!klass->IsErroneous()) { 1769 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 1770 } 1771 return nullptr; 1772 } 1773 1774 // Finish loading (if necessary) by finding parents 1775 CHECK(!klass->IsLoaded()); 1776 if (!LoadSuperAndInterfaces(klass, dex_file)) { 1777 // Loading failed. 1778 if (!klass->IsErroneous()) { 1779 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 1780 } 1781 return nullptr; 1782 } 1783 CHECK(klass->IsLoaded()); 1784 // Link the class (if necessary) 1785 CHECK(!klass->IsResolved()); 1786 // TODO: Use fast jobjects? 1787 auto interfaces = hs.NewHandle<mirror::ObjectArray<mirror::Class>>(nullptr); 1788 1789 mirror::Class* new_class = nullptr; 1790 if (!LinkClass(self, descriptor, klass, interfaces, &new_class)) { 1791 // Linking failed. 1792 if (!klass->IsErroneous()) { 1793 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 1794 } 1795 return nullptr; 1796 } 1797 self->AssertNoPendingException(); 1798 CHECK(new_class != nullptr) << descriptor; 1799 CHECK(new_class->IsResolved()) << descriptor; 1800 1801 Handle<mirror::Class> new_class_h(hs.NewHandle(new_class)); 1802 1803 // Instrumentation may have updated entrypoints for all methods of all 1804 // classes. However it could not update methods of this class while we 1805 // were loading it. Now the class is resolved, we can update entrypoints 1806 // as required by instrumentation. 1807 if (Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) { 1808 // We must be in the kRunnable state to prevent instrumentation from 1809 // suspending all threads to update entrypoints while we are doing it 1810 // for this class. 1811 DCHECK_EQ(self->GetState(), kRunnable); 1812 Runtime::Current()->GetInstrumentation()->InstallStubsForClass(new_class_h.Get()); 1813 } 1814 1815 /* 1816 * We send CLASS_PREPARE events to the debugger from here. The 1817 * definition of "preparation" is creating the static fields for a 1818 * class and initializing them to the standard default values, but not 1819 * executing any code (that comes later, during "initialization"). 1820 * 1821 * We did the static preparation in LinkClass. 1822 * 1823 * The class has been prepared and resolved but possibly not yet verified 1824 * at this point. 1825 */ 1826 Dbg::PostClassPrepare(new_class_h.Get()); 1827 1828 return new_class_h.Get(); 1829} 1830 1831uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file, 1832 const DexFile::ClassDef& dex_class_def) { 1833 const uint8_t* class_data = dex_file.GetClassData(dex_class_def); 1834 size_t num_ref = 0; 1835 size_t num_8 = 0; 1836 size_t num_16 = 0; 1837 size_t num_32 = 0; 1838 size_t num_64 = 0; 1839 if (class_data != nullptr) { 1840 for (ClassDataItemIterator it(dex_file, class_data); it.HasNextStaticField(); it.Next()) { 1841 const DexFile::FieldId& field_id = dex_file.GetFieldId(it.GetMemberIndex()); 1842 const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id); 1843 char c = descriptor[0]; 1844 switch (c) { 1845 case 'L': 1846 case '[': 1847 num_ref++; 1848 break; 1849 case 'J': 1850 case 'D': 1851 num_64++; 1852 break; 1853 case 'I': 1854 case 'F': 1855 num_32++; 1856 break; 1857 case 'S': 1858 case 'C': 1859 num_16++; 1860 break; 1861 case 'B': 1862 case 'Z': 1863 num_8++; 1864 break; 1865 default: 1866 LOG(FATAL) << "Unknown descriptor: " << c; 1867 UNREACHABLE(); 1868 } 1869 } 1870 } 1871 return mirror::Class::ComputeClassSize(false, 0, num_8, num_16, num_32, num_64, num_ref); 1872} 1873 1874OatFile::OatClass ClassLinker::FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, 1875 bool* found) { 1876 DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16); 1877 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 1878 if (oat_dex_file == nullptr) { 1879 *found = false; 1880 return OatFile::OatClass::Invalid(); 1881 } 1882 *found = true; 1883 return oat_dex_file->GetOatClass(class_def_idx); 1884} 1885 1886static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint16_t class_def_idx, 1887 uint32_t method_idx) { 1888 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx); 1889 const uint8_t* class_data = dex_file.GetClassData(class_def); 1890 CHECK(class_data != nullptr); 1891 ClassDataItemIterator it(dex_file, class_data); 1892 // Skip fields 1893 while (it.HasNextStaticField()) { 1894 it.Next(); 1895 } 1896 while (it.HasNextInstanceField()) { 1897 it.Next(); 1898 } 1899 // Process methods 1900 size_t class_def_method_index = 0; 1901 while (it.HasNextDirectMethod()) { 1902 if (it.GetMemberIndex() == method_idx) { 1903 return class_def_method_index; 1904 } 1905 class_def_method_index++; 1906 it.Next(); 1907 } 1908 while (it.HasNextVirtualMethod()) { 1909 if (it.GetMemberIndex() == method_idx) { 1910 return class_def_method_index; 1911 } 1912 class_def_method_index++; 1913 it.Next(); 1914 } 1915 DCHECK(!it.HasNext()); 1916 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation(); 1917 UNREACHABLE(); 1918} 1919 1920const OatFile::OatMethod ClassLinker::FindOatMethodFor(mirror::ArtMethod* method, bool* found) { 1921 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution 1922 // method for direct methods (or virtual methods made direct). 1923 mirror::Class* declaring_class = method->GetDeclaringClass(); 1924 size_t oat_method_index; 1925 if (method->IsStatic() || method->IsDirect()) { 1926 // Simple case where the oat method index was stashed at load time. 1927 oat_method_index = method->GetMethodIndex(); 1928 } else { 1929 // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index 1930 // by search for its position in the declared virtual methods. 1931 oat_method_index = declaring_class->NumDirectMethods(); 1932 size_t end = declaring_class->NumVirtualMethods(); 1933 bool found_virtual = false; 1934 for (size_t i = 0; i < end; i++) { 1935 // Check method index instead of identity in case of duplicate method definitions. 1936 if (method->GetDexMethodIndex() == 1937 declaring_class->GetVirtualMethod(i)->GetDexMethodIndex()) { 1938 found_virtual = true; 1939 break; 1940 } 1941 oat_method_index++; 1942 } 1943 CHECK(found_virtual) << "Didn't find oat method index for virtual method: " 1944 << PrettyMethod(method); 1945 } 1946 DCHECK_EQ(oat_method_index, 1947 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(), 1948 method->GetDeclaringClass()->GetDexClassDefIndex(), 1949 method->GetDexMethodIndex())); 1950 OatFile::OatClass oat_class = FindOatClass(*declaring_class->GetDexCache()->GetDexFile(), 1951 declaring_class->GetDexClassDefIndex(), 1952 found); 1953 if (!(*found)) { 1954 return OatFile::OatMethod::Invalid(); 1955 } 1956 return oat_class.GetOatMethod(oat_method_index); 1957} 1958 1959// Special case to get oat code without overwriting a trampoline. 1960const void* ClassLinker::GetQuickOatCodeFor(mirror::ArtMethod* method) { 1961 CHECK(!method->IsAbstract()) << PrettyMethod(method); 1962 if (method->IsProxyMethod()) { 1963 return GetQuickProxyInvokeHandler(); 1964 } 1965 bool found; 1966 OatFile::OatMethod oat_method = FindOatMethodFor(method, &found); 1967 if (found) { 1968 auto* code = oat_method.GetQuickCode(); 1969 if (code != nullptr) { 1970 return code; 1971 } 1972 } 1973 jit::Jit* const jit = Runtime::Current()->GetJit(); 1974 if (jit != nullptr) { 1975 auto* code = jit->GetCodeCache()->GetCodeFor(method); 1976 if (code != nullptr) { 1977 return code; 1978 } 1979 } 1980 if (method->IsNative()) { 1981 // No code and native? Use generic trampoline. 1982 return GetQuickGenericJniStub(); 1983 } 1984 return GetQuickToInterpreterBridge(); 1985} 1986 1987const void* ClassLinker::GetOatMethodQuickCodeFor(mirror::ArtMethod* method) { 1988 if (method->IsNative() || method->IsAbstract() || method->IsProxyMethod()) { 1989 return nullptr; 1990 } 1991 bool found; 1992 OatFile::OatMethod oat_method = FindOatMethodFor(method, &found); 1993 if (found) { 1994 return oat_method.GetQuickCode(); 1995 } 1996 jit::Jit* jit = Runtime::Current()->GetJit(); 1997 if (jit != nullptr) { 1998 auto* code = jit->GetCodeCache()->GetCodeFor(method); 1999 if (code != nullptr) { 2000 return code; 2001 } 2002 } 2003 return nullptr; 2004} 2005 2006const void* ClassLinker::GetQuickOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, 2007 uint32_t method_idx) { 2008 bool found; 2009 OatFile::OatClass oat_class = FindOatClass(dex_file, class_def_idx, &found); 2010 if (!found) { 2011 return nullptr; 2012 } 2013 uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx); 2014 return oat_class.GetOatMethod(oat_method_idx).GetQuickCode(); 2015} 2016 2017// Returns true if the method must run with interpreter, false otherwise. 2018static bool NeedsInterpreter(mirror::ArtMethod* method, const void* quick_code) 2019 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 2020 if (quick_code == nullptr) { 2021 // No code: need interpreter. 2022 // May return true for native code, in the case of generic JNI 2023 // DCHECK(!method->IsNative()); 2024 return true; 2025 } 2026 // If interpreter mode is enabled, every method (except native and proxy) must 2027 // be run with interpreter. 2028 return Runtime::Current()->GetInstrumentation()->InterpretOnly() && 2029 !method->IsNative() && !method->IsProxyMethod(); 2030} 2031 2032void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) { 2033 DCHECK(klass->IsInitialized()) << PrettyDescriptor(klass); 2034 if (klass->NumDirectMethods() == 0) { 2035 return; // No direct methods => no static methods. 2036 } 2037 Runtime* runtime = Runtime::Current(); 2038 if (!runtime->IsStarted()) { 2039 if (runtime->IsAotCompiler() || runtime->GetHeap()->HasImageSpace()) { 2040 return; // OAT file unavailable. 2041 } 2042 } 2043 2044 const DexFile& dex_file = klass->GetDexFile(); 2045 const DexFile::ClassDef* dex_class_def = klass->GetClassDef(); 2046 CHECK(dex_class_def != nullptr); 2047 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def); 2048 // There should always be class data if there were direct methods. 2049 CHECK(class_data != nullptr) << PrettyDescriptor(klass); 2050 ClassDataItemIterator it(dex_file, class_data); 2051 // Skip fields 2052 while (it.HasNextStaticField()) { 2053 it.Next(); 2054 } 2055 while (it.HasNextInstanceField()) { 2056 it.Next(); 2057 } 2058 bool has_oat_class; 2059 OatFile::OatClass oat_class = FindOatClass(dex_file, klass->GetDexClassDefIndex(), 2060 &has_oat_class); 2061 // Link the code of methods skipped by LinkCode. 2062 for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) { 2063 mirror::ArtMethod* method = klass->GetDirectMethod(method_index); 2064 if (!method->IsStatic()) { 2065 // Only update static methods. 2066 continue; 2067 } 2068 const void* quick_code = nullptr; 2069 if (has_oat_class) { 2070 OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index); 2071 quick_code = oat_method.GetQuickCode(); 2072 } 2073 const bool enter_interpreter = NeedsInterpreter(method, quick_code); 2074 if (enter_interpreter) { 2075 // Use interpreter entry point. 2076 // Check whether the method is native, in which case it's generic JNI. 2077 if (quick_code == nullptr && method->IsNative()) { 2078 quick_code = GetQuickGenericJniStub(); 2079 } else { 2080 quick_code = GetQuickToInterpreterBridge(); 2081 } 2082 } 2083 runtime->GetInstrumentation()->UpdateMethodsCode(method, quick_code); 2084 } 2085 // Ignore virtual methods on the iterator. 2086} 2087 2088void ClassLinker::LinkCode(Handle<mirror::ArtMethod> method, 2089 const OatFile::OatClass* oat_class, 2090 uint32_t class_def_method_index) { 2091 Runtime* runtime = Runtime::Current(); 2092 if (runtime->IsAotCompiler()) { 2093 // The following code only applies to a non-compiler runtime. 2094 return; 2095 } 2096 // Method shouldn't have already been linked. 2097 DCHECK(method->GetEntryPointFromQuickCompiledCode() == nullptr); 2098 if (oat_class != nullptr) { 2099 // Every kind of method should at least get an invoke stub from the oat_method. 2100 // non-abstract methods also get their code pointers. 2101 const OatFile::OatMethod oat_method = oat_class->GetOatMethod(class_def_method_index); 2102 oat_method.LinkMethod(method.Get()); 2103 } 2104 2105 // Install entry point from interpreter. 2106 bool enter_interpreter = NeedsInterpreter(method.Get(), 2107 method->GetEntryPointFromQuickCompiledCode()); 2108 if (enter_interpreter && !method->IsNative()) { 2109 method->SetEntryPointFromInterpreter(artInterpreterToInterpreterBridge); 2110 } else { 2111 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge); 2112 } 2113 2114 if (method->IsAbstract()) { 2115 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge()); 2116 return; 2117 } 2118 2119 if (method->IsStatic() && !method->IsConstructor()) { 2120 // For static methods excluding the class initializer, install the trampoline. 2121 // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines 2122 // after initializing class (see ClassLinker::InitializeClass method). 2123 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub()); 2124 } else if (enter_interpreter) { 2125 if (!method->IsNative()) { 2126 // Set entry point from compiled code if there's no code or in interpreter only mode. 2127 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge()); 2128 } else { 2129 method->SetEntryPointFromQuickCompiledCode(GetQuickGenericJniStub()); 2130 } 2131 } 2132 2133 if (method->IsNative()) { 2134 // Unregistering restores the dlsym lookup stub. 2135 method->UnregisterNative(); 2136 2137 if (enter_interpreter) { 2138 // We have a native method here without code. Then it should have either the generic JNI 2139 // trampoline as entrypoint (non-static), or the resolution trampoline (static). 2140 // TODO: this doesn't handle all the cases where trampolines may be installed. 2141 const void* entry_point = method->GetEntryPointFromQuickCompiledCode(); 2142 DCHECK(IsQuickGenericJniStub(entry_point) || IsQuickResolutionStub(entry_point)); 2143 } 2144 } 2145} 2146 2147void ClassLinker::SetupClass(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, 2148 Handle<mirror::Class> klass, mirror::ClassLoader* class_loader) { 2149 CHECK(klass.Get() != nullptr); 2150 CHECK(klass->GetDexCache() != nullptr); 2151 CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus()); 2152 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def); 2153 CHECK(descriptor != nullptr); 2154 2155 klass->SetClass(GetClassRoot(kJavaLangClass)); 2156 uint32_t access_flags = dex_class_def.GetJavaAccessFlags(); 2157 CHECK_EQ(access_flags & ~kAccJavaFlagsMask, 0U); 2158 klass->SetAccessFlags(access_flags); 2159 klass->SetClassLoader(class_loader); 2160 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot); 2161 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, nullptr); 2162 2163 klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def)); 2164 klass->SetDexTypeIndex(dex_class_def.class_idx_); 2165 CHECK(klass->GetDexCacheStrings() != nullptr); 2166} 2167 2168void ClassLinker::LoadClass(Thread* self, const DexFile& dex_file, 2169 const DexFile::ClassDef& dex_class_def, 2170 Handle<mirror::Class> klass) { 2171 const uint8_t* class_data = dex_file.GetClassData(dex_class_def); 2172 if (class_data == nullptr) { 2173 return; // no fields or methods - for example a marker interface 2174 } 2175 bool has_oat_class = false; 2176 if (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler()) { 2177 OatFile::OatClass oat_class = FindOatClass(dex_file, klass->GetDexClassDefIndex(), 2178 &has_oat_class); 2179 if (has_oat_class) { 2180 LoadClassMembers(self, dex_file, class_data, klass, &oat_class); 2181 } 2182 } 2183 if (!has_oat_class) { 2184 LoadClassMembers(self, dex_file, class_data, klass, nullptr); 2185 } 2186} 2187 2188ArtField* ClassLinker::AllocArtFieldArray(Thread* self, size_t length) { 2189 auto* const la = Runtime::Current()->GetLinearAlloc(); 2190 auto* ptr = reinterpret_cast<ArtField*>(la->AllocArray<ArtField>(self, length)); 2191 CHECK(ptr!= nullptr); 2192 std::uninitialized_fill_n(ptr, length, ArtField()); 2193 return ptr; 2194} 2195 2196void ClassLinker::LoadClassMembers(Thread* self, const DexFile& dex_file, 2197 const uint8_t* class_data, 2198 Handle<mirror::Class> klass, 2199 const OatFile::OatClass* oat_class) { 2200 // Load static fields. 2201 ClassDataItemIterator it(dex_file, class_data); 2202 const size_t num_sfields = it.NumStaticFields(); 2203 ArtField* sfields = num_sfields != 0 ? AllocArtFieldArray(self, num_sfields) : nullptr; 2204 for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) { 2205 CHECK_LT(i, num_sfields); 2206 LoadField(it, klass, &sfields[i]); 2207 } 2208 klass->SetSFields(sfields); 2209 klass->SetNumStaticFields(num_sfields); 2210 DCHECK_EQ(klass->NumStaticFields(), num_sfields); 2211 // Load instance fields. 2212 const size_t num_ifields = it.NumInstanceFields(); 2213 ArtField* ifields = num_ifields != 0 ? AllocArtFieldArray(self, num_ifields) : nullptr; 2214 for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) { 2215 CHECK_LT(i, num_ifields); 2216 LoadField(it, klass, &ifields[i]); 2217 } 2218 klass->SetIFields(ifields); 2219 klass->SetNumInstanceFields(num_ifields); 2220 DCHECK_EQ(klass->NumInstanceFields(), num_ifields); 2221 // Note: We cannot have thread suspension until the field arrays are setup or else 2222 // Class::VisitFieldRoots may miss some fields. 2223 self->AllowThreadSuspension(); 2224 // Load methods. 2225 if (it.NumDirectMethods() != 0) { 2226 // TODO: append direct methods to class object 2227 mirror::ObjectArray<mirror::ArtMethod>* directs = 2228 AllocArtMethodArray(self, it.NumDirectMethods()); 2229 if (UNLIKELY(directs == nullptr)) { 2230 CHECK(self->IsExceptionPending()); // OOME. 2231 return; 2232 } 2233 klass->SetDirectMethods(directs); 2234 } 2235 if (it.NumVirtualMethods() != 0) { 2236 // TODO: append direct methods to class object 2237 mirror::ObjectArray<mirror::ArtMethod>* virtuals = 2238 AllocArtMethodArray(self, it.NumVirtualMethods()); 2239 if (UNLIKELY(virtuals == nullptr)) { 2240 CHECK(self->IsExceptionPending()); // OOME. 2241 return; 2242 } 2243 klass->SetVirtualMethods(virtuals); 2244 } 2245 size_t class_def_method_index = 0; 2246 uint32_t last_dex_method_index = DexFile::kDexNoIndex; 2247 size_t last_class_def_method_index = 0; 2248 for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) { 2249 self->AllowThreadSuspension(); 2250 StackHandleScope<1> hs(self); 2251 Handle<mirror::ArtMethod> method(hs.NewHandle(LoadMethod(self, dex_file, it, klass))); 2252 if (UNLIKELY(method.Get() == nullptr)) { 2253 CHECK(self->IsExceptionPending()); // OOME. 2254 return; 2255 } 2256 klass->SetDirectMethod(i, method.Get()); 2257 LinkCode(method, oat_class, class_def_method_index); 2258 uint32_t it_method_index = it.GetMemberIndex(); 2259 if (last_dex_method_index == it_method_index) { 2260 // duplicate case 2261 method->SetMethodIndex(last_class_def_method_index); 2262 } else { 2263 method->SetMethodIndex(class_def_method_index); 2264 last_dex_method_index = it_method_index; 2265 last_class_def_method_index = class_def_method_index; 2266 } 2267 class_def_method_index++; 2268 } 2269 for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) { 2270 self->AllowThreadSuspension(); 2271 StackHandleScope<1> hs(self); 2272 Handle<mirror::ArtMethod> method(hs.NewHandle(LoadMethod(self, dex_file, it, klass))); 2273 if (UNLIKELY(method.Get() == nullptr)) { 2274 CHECK(self->IsExceptionPending()); // OOME. 2275 return; 2276 } 2277 klass->SetVirtualMethod(i, method.Get()); 2278 DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i); 2279 LinkCode(method, oat_class, class_def_method_index); 2280 class_def_method_index++; 2281 } 2282 DCHECK(!it.HasNext()); 2283} 2284 2285void ClassLinker::LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, 2286 ArtField* dst) { 2287 const uint32_t field_idx = it.GetMemberIndex(); 2288 dst->SetDexFieldIndex(field_idx); 2289 dst->SetDeclaringClass(klass.Get()); 2290 dst->SetAccessFlags(it.GetFieldAccessFlags()); 2291} 2292 2293mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file, 2294 const ClassDataItemIterator& it, 2295 Handle<mirror::Class> klass) { 2296 uint32_t dex_method_idx = it.GetMemberIndex(); 2297 const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx); 2298 const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_); 2299 2300 mirror::ArtMethod* dst = AllocArtMethod(self); 2301 if (UNLIKELY(dst == nullptr)) { 2302 CHECK(self->IsExceptionPending()); // OOME. 2303 return nullptr; 2304 } 2305 DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass()); 2306 2307 ScopedAssertNoThreadSuspension ants(self, "LoadMethod"); 2308 dst->SetDexMethodIndex(dex_method_idx); 2309 dst->SetDeclaringClass(klass.Get()); 2310 dst->SetCodeItemOffset(it.GetMethodCodeItemOffset()); 2311 2312 dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods()); 2313 dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes()); 2314 2315 uint32_t access_flags = it.GetMethodAccessFlags(); 2316 2317 if (UNLIKELY(strcmp("finalize", method_name) == 0)) { 2318 // Set finalizable flag on declaring class. 2319 if (strcmp("V", dex_file.GetShorty(method_id.proto_idx_)) == 0) { 2320 // Void return type. 2321 if (klass->GetClassLoader() != nullptr) { // All non-boot finalizer methods are flagged. 2322 klass->SetFinalizable(); 2323 } else { 2324 std::string temp; 2325 const char* klass_descriptor = klass->GetDescriptor(&temp); 2326 // The Enum class declares a "final" finalize() method to prevent subclasses from 2327 // introducing a finalizer. We don't want to set the finalizable flag for Enum or its 2328 // subclasses, so we exclude it here. 2329 // We also want to avoid setting the flag on Object, where we know that finalize() is 2330 // empty. 2331 if (strcmp(klass_descriptor, "Ljava/lang/Object;") != 0 && 2332 strcmp(klass_descriptor, "Ljava/lang/Enum;") != 0) { 2333 klass->SetFinalizable(); 2334 } 2335 } 2336 } 2337 } else if (method_name[0] == '<') { 2338 // Fix broken access flags for initializers. Bug 11157540. 2339 bool is_init = (strcmp("<init>", method_name) == 0); 2340 bool is_clinit = !is_init && (strcmp("<clinit>", method_name) == 0); 2341 if (UNLIKELY(!is_init && !is_clinit)) { 2342 LOG(WARNING) << "Unexpected '<' at start of method name " << method_name; 2343 } else { 2344 if (UNLIKELY((access_flags & kAccConstructor) == 0)) { 2345 LOG(WARNING) << method_name << " didn't have expected constructor access flag in class " 2346 << PrettyDescriptor(klass.Get()) << " in dex file " << dex_file.GetLocation(); 2347 access_flags |= kAccConstructor; 2348 } 2349 } 2350 } 2351 dst->SetAccessFlags(access_flags); 2352 2353 return dst; 2354} 2355 2356void ClassLinker::AppendToBootClassPath(Thread* self, const DexFile& dex_file) { 2357 StackHandleScope<1> hs(self); 2358 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache(self, dex_file))); 2359 CHECK(dex_cache.Get() != nullptr) << "Failed to allocate dex cache for " 2360 << dex_file.GetLocation(); 2361 AppendToBootClassPath(dex_file, dex_cache); 2362} 2363 2364void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, 2365 Handle<mirror::DexCache> dex_cache) { 2366 CHECK(dex_cache.Get() != nullptr) << dex_file.GetLocation(); 2367 boot_class_path_.push_back(&dex_file); 2368 RegisterDexFile(dex_file, dex_cache); 2369} 2370 2371bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) { 2372 dex_lock_.AssertSharedHeld(Thread::Current()); 2373 for (size_t i = 0; i != dex_caches_.size(); ++i) { 2374 mirror::DexCache* dex_cache = GetDexCache(i); 2375 if (dex_cache->GetDexFile() == &dex_file) { 2376 return true; 2377 } 2378 } 2379 return false; 2380} 2381 2382bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) { 2383 ReaderMutexLock mu(Thread::Current(), dex_lock_); 2384 return IsDexFileRegisteredLocked(dex_file); 2385} 2386 2387void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, 2388 Handle<mirror::DexCache> dex_cache) { 2389 dex_lock_.AssertExclusiveHeld(Thread::Current()); 2390 CHECK(dex_cache.Get() != nullptr) << dex_file.GetLocation(); 2391 CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation())) 2392 << dex_cache->GetLocation()->ToModifiedUtf8() << " " << dex_file.GetLocation(); 2393 dex_caches_.push_back(GcRoot<mirror::DexCache>(dex_cache.Get())); 2394 dex_cache->SetDexFile(&dex_file); 2395 if (log_new_dex_caches_roots_) { 2396 // TODO: This is not safe if we can remove dex caches. 2397 new_dex_cache_roots_.push_back(dex_caches_.size() - 1); 2398 } 2399} 2400 2401void ClassLinker::RegisterDexFile(const DexFile& dex_file) { 2402 Thread* self = Thread::Current(); 2403 { 2404 ReaderMutexLock mu(self, dex_lock_); 2405 if (IsDexFileRegisteredLocked(dex_file)) { 2406 return; 2407 } 2408 } 2409 // Don't alloc while holding the lock, since allocation may need to 2410 // suspend all threads and another thread may need the dex_lock_ to 2411 // get to a suspend point. 2412 StackHandleScope<1> hs(self); 2413 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache(self, dex_file))); 2414 CHECK(dex_cache.Get() != nullptr) << "Failed to allocate dex cache for " 2415 << dex_file.GetLocation(); 2416 { 2417 WriterMutexLock mu(self, dex_lock_); 2418 if (IsDexFileRegisteredLocked(dex_file)) { 2419 return; 2420 } 2421 RegisterDexFileLocked(dex_file, dex_cache); 2422 } 2423} 2424 2425void ClassLinker::RegisterDexFile(const DexFile& dex_file, 2426 Handle<mirror::DexCache> dex_cache) { 2427 WriterMutexLock mu(Thread::Current(), dex_lock_); 2428 RegisterDexFileLocked(dex_file, dex_cache); 2429} 2430 2431mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) { 2432 ReaderMutexLock mu(Thread::Current(), dex_lock_); 2433 // Search assuming unique-ness of dex file. 2434 for (size_t i = 0; i != dex_caches_.size(); ++i) { 2435 mirror::DexCache* dex_cache = GetDexCache(i); 2436 if (dex_cache->GetDexFile() == &dex_file) { 2437 return dex_cache; 2438 } 2439 } 2440 // Search matching by location name. 2441 std::string location(dex_file.GetLocation()); 2442 for (size_t i = 0; i != dex_caches_.size(); ++i) { 2443 mirror::DexCache* dex_cache = GetDexCache(i); 2444 if (dex_cache->GetDexFile()->GetLocation() == location) { 2445 return dex_cache; 2446 } 2447 } 2448 // Failure, dump diagnostic and abort. 2449 for (size_t i = 0; i != dex_caches_.size(); ++i) { 2450 mirror::DexCache* dex_cache = GetDexCache(i); 2451 LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation(); 2452 } 2453 LOG(FATAL) << "Failed to find DexCache for DexFile " << location; 2454 UNREACHABLE(); 2455} 2456 2457void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) { 2458 ReaderMutexLock mu(Thread::Current(), dex_lock_); 2459 for (size_t i = 0; i != dex_caches_.size(); ++i) { 2460 mirror::DexCache* dex_cache = GetDexCache(i); 2461 dex_cache->Fixup(resolution_method); 2462 } 2463} 2464 2465mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) { 2466 mirror::Class* klass = AllocClass(self, mirror::Class::PrimitiveClassSize()); 2467 if (UNLIKELY(klass == nullptr)) { 2468 return nullptr; 2469 } 2470 return InitializePrimitiveClass(klass, type); 2471} 2472 2473mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, 2474 Primitive::Type type) { 2475 CHECK(primitive_class != nullptr); 2476 // Must hold lock on object when initializing. 2477 Thread* self = Thread::Current(); 2478 StackHandleScope<1> hs(self); 2479 Handle<mirror::Class> h_class(hs.NewHandle(primitive_class)); 2480 ObjectLock<mirror::Class> lock(self, h_class); 2481 h_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract); 2482 h_class->SetPrimitiveType(type); 2483 mirror::Class::SetStatus(h_class, mirror::Class::kStatusInitialized, self); 2484 const char* descriptor = Primitive::Descriptor(type); 2485 mirror::Class* existing = InsertClass(descriptor, h_class.Get(), 2486 ComputeModifiedUtf8Hash(descriptor)); 2487 CHECK(existing == nullptr) << "InitPrimitiveClass(" << type << ") failed"; 2488 return h_class.Get(); 2489} 2490 2491// Create an array class (i.e. the class object for the array, not the 2492// array itself). "descriptor" looks like "[C" or "[[[[B" or 2493// "[Ljava/lang/String;". 2494// 2495// If "descriptor" refers to an array of primitives, look up the 2496// primitive type's internally-generated class object. 2497// 2498// "class_loader" is the class loader of the class that's referring to 2499// us. It's used to ensure that we're looking for the element type in 2500// the right context. It does NOT become the class loader for the 2501// array class; that always comes from the base element class. 2502// 2503// Returns null with an exception raised on failure. 2504mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor, size_t hash, 2505 Handle<mirror::ClassLoader> class_loader) { 2506 // Identify the underlying component type 2507 CHECK_EQ('[', descriptor[0]); 2508 StackHandleScope<2> hs(self); 2509 MutableHandle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1, 2510 class_loader))); 2511 if (component_type.Get() == nullptr) { 2512 DCHECK(self->IsExceptionPending()); 2513 // We need to accept erroneous classes as component types. 2514 const size_t component_hash = ComputeModifiedUtf8Hash(descriptor + 1); 2515 component_type.Assign(LookupClass(self, descriptor + 1, component_hash, class_loader.Get())); 2516 if (component_type.Get() == nullptr) { 2517 DCHECK(self->IsExceptionPending()); 2518 return nullptr; 2519 } else { 2520 self->ClearException(); 2521 } 2522 } 2523 if (UNLIKELY(component_type->IsPrimitiveVoid())) { 2524 ThrowNoClassDefFoundError("Attempt to create array of void primitive type"); 2525 return nullptr; 2526 } 2527 // See if the component type is already loaded. Array classes are 2528 // always associated with the class loader of their underlying 2529 // element type -- an array of Strings goes with the loader for 2530 // java/lang/String -- so we need to look for it there. (The 2531 // caller should have checked for the existence of the class 2532 // before calling here, but they did so with *their* class loader, 2533 // not the component type's loader.) 2534 // 2535 // If we find it, the caller adds "loader" to the class' initiating 2536 // loader list, which should prevent us from going through this again. 2537 // 2538 // This call is unnecessary if "loader" and "component_type->GetClassLoader()" 2539 // are the same, because our caller (FindClass) just did the 2540 // lookup. (Even if we get this wrong we still have correct behavior, 2541 // because we effectively do this lookup again when we add the new 2542 // class to the hash table --- necessary because of possible races with 2543 // other threads.) 2544 if (class_loader.Get() != component_type->GetClassLoader()) { 2545 mirror::Class* new_class = LookupClass(self, descriptor, hash, component_type->GetClassLoader()); 2546 if (new_class != nullptr) { 2547 return new_class; 2548 } 2549 } 2550 2551 // Fill out the fields in the Class. 2552 // 2553 // It is possible to execute some methods against arrays, because 2554 // all arrays are subclasses of java_lang_Object_, so we need to set 2555 // up a vtable. We can just point at the one in java_lang_Object_. 2556 // 2557 // Array classes are simple enough that we don't need to do a full 2558 // link step. 2559 auto new_class = hs.NewHandle<mirror::Class>(nullptr); 2560 if (UNLIKELY(!init_done_)) { 2561 // Classes that were hand created, ie not by FindSystemClass 2562 if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) { 2563 new_class.Assign(GetClassRoot(kClassArrayClass)); 2564 } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) { 2565 new_class.Assign(GetClassRoot(kObjectArrayClass)); 2566 } else if (strcmp(descriptor, GetClassRootDescriptor(kJavaLangStringArrayClass)) == 0) { 2567 new_class.Assign(GetClassRoot(kJavaLangStringArrayClass)); 2568 } else if (strcmp(descriptor, 2569 GetClassRootDescriptor(kJavaLangReflectArtMethodArrayClass)) == 0) { 2570 new_class.Assign(GetClassRoot(kJavaLangReflectArtMethodArrayClass)); 2571 } else if (strcmp(descriptor, "[C") == 0) { 2572 new_class.Assign(GetClassRoot(kCharArrayClass)); 2573 } else if (strcmp(descriptor, "[I") == 0) { 2574 new_class.Assign(GetClassRoot(kIntArrayClass)); 2575 } else if (strcmp(descriptor, "[J") == 0) { 2576 new_class.Assign(GetClassRoot(kLongArrayClass)); 2577 } 2578 } 2579 if (new_class.Get() == nullptr) { 2580 new_class.Assign(AllocClass(self, mirror::Array::ClassSize())); 2581 if (new_class.Get() == nullptr) { 2582 return nullptr; 2583 } 2584 new_class->SetComponentType(component_type.Get()); 2585 } 2586 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing. 2587 DCHECK(new_class->GetComponentType() != nullptr); 2588 mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject); 2589 new_class->SetSuperClass(java_lang_Object); 2590 new_class->SetVTable(java_lang_Object->GetVTable()); 2591 new_class->SetPrimitiveType(Primitive::kPrimNot); 2592 new_class->SetClassLoader(component_type->GetClassLoader()); 2593 mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self); 2594 { 2595 StackHandleScope<mirror::Class::kImtSize> hs2(self, 2596 Runtime::Current()->GetImtUnimplementedMethod()); 2597 new_class->PopulateEmbeddedImtAndVTable(&hs2); 2598 } 2599 mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self); 2600 // don't need to set new_class->SetObjectSize(..) 2601 // because Object::SizeOf delegates to Array::SizeOf 2602 2603 2604 // All arrays have java/lang/Cloneable and java/io/Serializable as 2605 // interfaces. We need to set that up here, so that stuff like 2606 // "instanceof" works right. 2607 // 2608 // Note: The GC could run during the call to FindSystemClass, 2609 // so we need to make sure the class object is GC-valid while we're in 2610 // there. Do this by clearing the interface list so the GC will just 2611 // think that the entries are null. 2612 2613 2614 // Use the single, global copies of "interfaces" and "iftable" 2615 // (remember not to free them for arrays). 2616 { 2617 mirror::IfTable* array_iftable = array_iftable_.Read(); 2618 CHECK(array_iftable != nullptr); 2619 new_class->SetIfTable(array_iftable); 2620 } 2621 2622 // Inherit access flags from the component type. 2623 int access_flags = new_class->GetComponentType()->GetAccessFlags(); 2624 // Lose any implementation detail flags; in particular, arrays aren't finalizable. 2625 access_flags &= kAccJavaFlagsMask; 2626 // Arrays can't be used as a superclass or interface, so we want to add "abstract final" 2627 // and remove "interface". 2628 access_flags |= kAccAbstract | kAccFinal; 2629 access_flags &= ~kAccInterface; 2630 2631 new_class->SetAccessFlags(access_flags); 2632 2633 mirror::Class* existing = InsertClass(descriptor, new_class.Get(), hash); 2634 if (existing == nullptr) { 2635 return new_class.Get(); 2636 } 2637 // Another thread must have loaded the class after we 2638 // started but before we finished. Abandon what we've 2639 // done. 2640 // 2641 // (Yes, this happens.) 2642 2643 return existing; 2644} 2645 2646mirror::Class* ClassLinker::FindPrimitiveClass(char type) { 2647 switch (type) { 2648 case 'B': 2649 return GetClassRoot(kPrimitiveByte); 2650 case 'C': 2651 return GetClassRoot(kPrimitiveChar); 2652 case 'D': 2653 return GetClassRoot(kPrimitiveDouble); 2654 case 'F': 2655 return GetClassRoot(kPrimitiveFloat); 2656 case 'I': 2657 return GetClassRoot(kPrimitiveInt); 2658 case 'J': 2659 return GetClassRoot(kPrimitiveLong); 2660 case 'S': 2661 return GetClassRoot(kPrimitiveShort); 2662 case 'Z': 2663 return GetClassRoot(kPrimitiveBoolean); 2664 case 'V': 2665 return GetClassRoot(kPrimitiveVoid); 2666 default: 2667 break; 2668 } 2669 std::string printable_type(PrintableChar(type)); 2670 ThrowNoClassDefFoundError("Not a primitive type: %s", printable_type.c_str()); 2671 return nullptr; 2672} 2673 2674mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass, 2675 size_t hash) { 2676 if (VLOG_IS_ON(class_linker)) { 2677 mirror::DexCache* dex_cache = klass->GetDexCache(); 2678 std::string source; 2679 if (dex_cache != nullptr) { 2680 source += " from "; 2681 source += dex_cache->GetLocation()->ToModifiedUtf8(); 2682 } 2683 LOG(INFO) << "Loaded class " << descriptor << source; 2684 } 2685 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 2686 mirror::Class* existing = LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash); 2687 if (existing != nullptr) { 2688 return existing; 2689 } 2690 if (kIsDebugBuild && !klass->IsTemp() && klass->GetClassLoader() == nullptr && 2691 dex_cache_image_class_lookup_required_) { 2692 // Check a class loaded with the system class loader matches one in the image if the class 2693 // is in the image. 2694 existing = LookupClassFromImage(descriptor); 2695 if (existing != nullptr) { 2696 CHECK_EQ(klass, existing); 2697 } 2698 } 2699 VerifyObject(klass); 2700 class_table_.InsertWithHash(GcRoot<mirror::Class>(klass), hash); 2701 if (log_new_class_table_roots_) { 2702 new_class_roots_.push_back(GcRoot<mirror::Class>(klass)); 2703 } 2704 return nullptr; 2705} 2706 2707mirror::Class* ClassLinker::UpdateClass(const char* descriptor, mirror::Class* klass, 2708 size_t hash) { 2709 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 2710 auto existing_it = class_table_.FindWithHash(std::make_pair(descriptor, klass->GetClassLoader()), 2711 hash); 2712 if (existing_it == class_table_.end()) { 2713 CHECK(klass->IsProxyClass()); 2714 return nullptr; 2715 } 2716 2717 mirror::Class* existing = existing_it->Read(); 2718 CHECK_NE(existing, klass) << descriptor; 2719 CHECK(!existing->IsResolved()) << descriptor; 2720 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusResolving) << descriptor; 2721 2722 CHECK(!klass->IsTemp()) << descriptor; 2723 if (kIsDebugBuild && klass->GetClassLoader() == nullptr && 2724 dex_cache_image_class_lookup_required_) { 2725 // Check a class loaded with the system class loader matches one in the image if the class 2726 // is in the image. 2727 existing = LookupClassFromImage(descriptor); 2728 if (existing != nullptr) { 2729 CHECK_EQ(klass, existing) << descriptor; 2730 } 2731 } 2732 VerifyObject(klass); 2733 2734 // Update the element in the hash set. 2735 *existing_it = GcRoot<mirror::Class>(klass); 2736 if (log_new_class_table_roots_) { 2737 new_class_roots_.push_back(GcRoot<mirror::Class>(klass)); 2738 } 2739 2740 return existing; 2741} 2742 2743bool ClassLinker::RemoveClass(const char* descriptor, mirror::ClassLoader* class_loader) { 2744 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 2745 auto pair = std::make_pair(descriptor, class_loader); 2746 auto it = class_table_.Find(pair); 2747 if (it != class_table_.end()) { 2748 class_table_.Erase(it); 2749 return true; 2750 } 2751 it = pre_zygote_class_table_.Find(pair); 2752 if (it != pre_zygote_class_table_.end()) { 2753 pre_zygote_class_table_.Erase(it); 2754 return true; 2755 } 2756 return false; 2757} 2758 2759mirror::Class* ClassLinker::LookupClass(Thread* self, const char* descriptor, size_t hash, 2760 mirror::ClassLoader* class_loader) { 2761 { 2762 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 2763 mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash); 2764 if (result != nullptr) { 2765 return result; 2766 } 2767 } 2768 if (class_loader != nullptr || !dex_cache_image_class_lookup_required_) { 2769 return nullptr; 2770 } else { 2771 // Lookup failed but need to search dex_caches_. 2772 mirror::Class* result = LookupClassFromImage(descriptor); 2773 if (result != nullptr) { 2774 InsertClass(descriptor, result, hash); 2775 } else { 2776 // Searching the image dex files/caches failed, we don't want to get into this situation 2777 // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image 2778 // classes into the class table. 2779 constexpr uint32_t kMaxFailedDexCacheLookups = 1000; 2780 if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) { 2781 MoveImageClassesToClassTable(); 2782 } 2783 } 2784 return result; 2785 } 2786} 2787 2788mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor, 2789 mirror::ClassLoader* class_loader, 2790 size_t hash) { 2791 auto descriptor_pair = std::make_pair(descriptor, class_loader); 2792 auto it = pre_zygote_class_table_.FindWithHash(descriptor_pair, hash); 2793 if (it == pre_zygote_class_table_.end()) { 2794 it = class_table_.FindWithHash(descriptor_pair, hash); 2795 if (it == class_table_.end()) { 2796 return nullptr; 2797 } 2798 } 2799 return it->Read(); 2800} 2801 2802static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches() 2803 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 2804 gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace(); 2805 CHECK(image != nullptr); 2806 mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches); 2807 return root->AsObjectArray<mirror::DexCache>(); 2808} 2809 2810void ClassLinker::MoveImageClassesToClassTable() { 2811 Thread* self = Thread::Current(); 2812 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_); 2813 if (!dex_cache_image_class_lookup_required_) { 2814 return; // All dex cache classes are already in the class table. 2815 } 2816 ScopedAssertNoThreadSuspension ants(self, "Moving image classes to class table"); 2817 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches(); 2818 std::string temp; 2819 for (int32_t i = 0; i < dex_caches->GetLength(); i++) { 2820 mirror::DexCache* dex_cache = dex_caches->Get(i); 2821 mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes(); 2822 for (int32_t j = 0; j < types->GetLength(); j++) { 2823 mirror::Class* klass = types->Get(j); 2824 if (klass != nullptr) { 2825 DCHECK(klass->GetClassLoader() == nullptr); 2826 const char* descriptor = klass->GetDescriptor(&temp); 2827 size_t hash = ComputeModifiedUtf8Hash(descriptor); 2828 mirror::Class* existing = LookupClassFromTableLocked(descriptor, nullptr, hash); 2829 if (existing != nullptr) { 2830 CHECK_EQ(existing, klass) << PrettyClassAndClassLoader(existing) << " != " 2831 << PrettyClassAndClassLoader(klass); 2832 } else { 2833 class_table_.Insert(GcRoot<mirror::Class>(klass)); 2834 if (log_new_class_table_roots_) { 2835 new_class_roots_.push_back(GcRoot<mirror::Class>(klass)); 2836 } 2837 } 2838 } 2839 } 2840 } 2841 dex_cache_image_class_lookup_required_ = false; 2842} 2843 2844void ClassLinker::MoveClassTableToPreZygote() { 2845 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 2846 DCHECK(pre_zygote_class_table_.Empty()); 2847 pre_zygote_class_table_ = std::move(class_table_); 2848 class_table_.Clear(); 2849} 2850 2851mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) { 2852 ScopedAssertNoThreadSuspension ants(Thread::Current(), "Image class lookup"); 2853 mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches(); 2854 for (int32_t i = 0; i < dex_caches->GetLength(); ++i) { 2855 mirror::DexCache* dex_cache = dex_caches->Get(i); 2856 const DexFile* dex_file = dex_cache->GetDexFile(); 2857 // Try binary searching the string/type index. 2858 const DexFile::StringId* string_id = dex_file->FindStringId(descriptor); 2859 if (string_id != nullptr) { 2860 const DexFile::TypeId* type_id = 2861 dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id)); 2862 if (type_id != nullptr) { 2863 uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id); 2864 mirror::Class* klass = dex_cache->GetResolvedType(type_idx); 2865 if (klass != nullptr) { 2866 return klass; 2867 } 2868 } 2869 } 2870 } 2871 return nullptr; 2872} 2873 2874void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) { 2875 result.clear(); 2876 if (dex_cache_image_class_lookup_required_) { 2877 MoveImageClassesToClassTable(); 2878 } 2879 WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 2880 while (true) { 2881 auto it = class_table_.Find(descriptor); 2882 if (it == class_table_.end()) { 2883 break; 2884 } 2885 result.push_back(it->Read()); 2886 class_table_.Erase(it); 2887 } 2888 for (mirror::Class* k : result) { 2889 class_table_.Insert(GcRoot<mirror::Class>(k)); 2890 } 2891 size_t pre_zygote_start = result.size(); 2892 // Now handle the pre zygote table. 2893 // Note: This dirties the pre-zygote table but shouldn't be an issue since LookupClasses is only 2894 // called from the debugger. 2895 while (true) { 2896 auto it = pre_zygote_class_table_.Find(descriptor); 2897 if (it == pre_zygote_class_table_.end()) { 2898 break; 2899 } 2900 result.push_back(it->Read()); 2901 pre_zygote_class_table_.Erase(it); 2902 } 2903 for (size_t i = pre_zygote_start; i < result.size(); ++i) { 2904 pre_zygote_class_table_.Insert(GcRoot<mirror::Class>(result[i])); 2905 } 2906} 2907 2908void ClassLinker::VerifyClass(Thread* self, Handle<mirror::Class> klass) { 2909 // TODO: assert that the monitor on the Class is held 2910 ObjectLock<mirror::Class> lock(self, klass); 2911 2912 // Don't attempt to re-verify if already sufficiently verified. 2913 if (klass->IsVerified()) { 2914 EnsurePreverifiedMethods(klass); 2915 return; 2916 } 2917 if (klass->IsCompileTimeVerified() && Runtime::Current()->IsAotCompiler()) { 2918 return; 2919 } 2920 2921 // The class might already be erroneous, for example at compile time if we attempted to verify 2922 // this class as a parent to another. 2923 if (klass->IsErroneous()) { 2924 ThrowEarlierClassFailure(klass.Get()); 2925 return; 2926 } 2927 2928 if (klass->GetStatus() == mirror::Class::kStatusResolved) { 2929 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifying, self); 2930 } else { 2931 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime) 2932 << PrettyClass(klass.Get()); 2933 CHECK(!Runtime::Current()->IsAotCompiler()); 2934 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifyingAtRuntime, self); 2935 } 2936 2937 // Skip verification if disabled. 2938 if (!Runtime::Current()->IsVerificationEnabled()) { 2939 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self); 2940 EnsurePreverifiedMethods(klass); 2941 return; 2942 } 2943 2944 // Verify super class. 2945 StackHandleScope<2> hs(self); 2946 Handle<mirror::Class> super(hs.NewHandle(klass->GetSuperClass())); 2947 if (super.Get() != nullptr) { 2948 // Acquire lock to prevent races on verifying the super class. 2949 ObjectLock<mirror::Class> super_lock(self, super); 2950 2951 if (!super->IsVerified() && !super->IsErroneous()) { 2952 VerifyClass(self, super); 2953 } 2954 if (!super->IsCompileTimeVerified()) { 2955 std::string error_msg( 2956 StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s", 2957 PrettyDescriptor(klass.Get()).c_str(), 2958 PrettyDescriptor(super.Get()).c_str())); 2959 LOG(WARNING) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8(); 2960 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException())); 2961 if (cause.Get() != nullptr) { 2962 self->ClearException(); 2963 } 2964 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str()); 2965 if (cause.Get() != nullptr) { 2966 self->GetException()->SetCause(cause.Get()); 2967 } 2968 ClassReference ref(klass->GetDexCache()->GetDexFile(), klass->GetDexClassDefIndex()); 2969 if (Runtime::Current()->IsAotCompiler()) { 2970 Runtime::Current()->GetCompilerCallbacks()->ClassRejected(ref); 2971 } 2972 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 2973 return; 2974 } 2975 } 2976 2977 // Try to use verification information from the oat file, otherwise do runtime verification. 2978 const DexFile& dex_file = *klass->GetDexCache()->GetDexFile(); 2979 mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady); 2980 bool preverified = VerifyClassUsingOatFile(dex_file, klass.Get(), oat_file_class_status); 2981 if (oat_file_class_status == mirror::Class::kStatusError) { 2982 VLOG(class_linker) << "Skipping runtime verification of erroneous class " 2983 << PrettyDescriptor(klass.Get()) << " in " 2984 << klass->GetDexCache()->GetLocation()->ToModifiedUtf8(); 2985 ThrowVerifyError(klass.Get(), "Rejecting class %s because it failed compile-time verification", 2986 PrettyDescriptor(klass.Get()).c_str()); 2987 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 2988 return; 2989 } 2990 verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure; 2991 std::string error_msg; 2992 if (!preverified) { 2993 verifier_failure = verifier::MethodVerifier::VerifyClass(self, klass.Get(), 2994 Runtime::Current()->IsAotCompiler(), 2995 &error_msg); 2996 } 2997 if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) { 2998 if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) { 2999 VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass.Get()) 3000 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8() 3001 << " because: " << error_msg; 3002 } 3003 self->AssertNoPendingException(); 3004 // Make sure all classes referenced by catch blocks are resolved. 3005 ResolveClassExceptionHandlerTypes(dex_file, klass); 3006 if (verifier_failure == verifier::MethodVerifier::kNoFailure) { 3007 // Even though there were no verifier failures we need to respect whether the super-class 3008 // was verified or requiring runtime reverification. 3009 if (super.Get() == nullptr || super->IsVerified()) { 3010 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self); 3011 } else { 3012 CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 3013 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self); 3014 // Pretend a soft failure occured so that we don't consider the class verified below. 3015 verifier_failure = verifier::MethodVerifier::kSoftFailure; 3016 } 3017 } else { 3018 CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure); 3019 // Soft failures at compile time should be retried at runtime. Soft 3020 // failures at runtime will be handled by slow paths in the generated 3021 // code. Set status accordingly. 3022 if (Runtime::Current()->IsAotCompiler()) { 3023 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self); 3024 } else { 3025 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self); 3026 // As this is a fake verified status, make sure the methods are _not_ marked preverified 3027 // later. 3028 klass->SetPreverified(); 3029 } 3030 } 3031 } else { 3032 LOG(WARNING) << "Verification failed on class " << PrettyDescriptor(klass.Get()) 3033 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8() 3034 << " because: " << error_msg; 3035 self->AssertNoPendingException(); 3036 ThrowVerifyError(klass.Get(), "%s", error_msg.c_str()); 3037 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3038 } 3039 if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) { 3040 // Class is verified so we don't need to do any access check on its methods. 3041 // Let the interpreter know it by setting the kAccPreverified flag onto each 3042 // method. 3043 // Note: we're going here during compilation and at runtime. When we set the 3044 // kAccPreverified flag when compiling image classes, the flag is recorded 3045 // in the image and is set when loading the image. 3046 EnsurePreverifiedMethods(klass); 3047 } 3048} 3049 3050void ClassLinker::EnsurePreverifiedMethods(Handle<mirror::Class> klass) { 3051 if (!klass->IsPreverified()) { 3052 klass->SetPreverifiedFlagOnAllMethods(); 3053 klass->SetPreverified(); 3054 } 3055} 3056 3057bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass, 3058 mirror::Class::Status& oat_file_class_status) { 3059 // If we're compiling, we can only verify the class using the oat file if 3060 // we are not compiling the image or if the class we're verifying is not part of 3061 // the app. In other words, we will only check for preverification of bootclasspath 3062 // classes. 3063 if (Runtime::Current()->IsAotCompiler()) { 3064 // Are we compiling the bootclasspath? 3065 if (Runtime::Current()->GetCompilerCallbacks()->IsBootImage()) { 3066 return false; 3067 } 3068 // We are compiling an app (not the image). 3069 3070 // Is this an app class? (I.e. not a bootclasspath class) 3071 if (klass->GetClassLoader() != nullptr) { 3072 return false; 3073 } 3074 } 3075 3076 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 3077 // In case we run without an image there won't be a backing oat file. 3078 if (oat_dex_file == nullptr) { 3079 return false; 3080 } 3081 3082 // We may be running with a preopted oat file but without image. In this case, 3083 // we don't skip verification of preverified classes to ensure we initialize 3084 // dex caches with all types resolved during verification. 3085 // We need to trust image classes, as these might be coming out of a pre-opted, quickened boot 3086 // image (that we just failed loading), and the verifier can't be run on quickened opcodes when 3087 // the runtime isn't started. On the other hand, app classes can be re-verified even if they are 3088 // already pre-opted, as then the runtime is started. 3089 if (!Runtime::Current()->IsAotCompiler() && 3090 !Runtime::Current()->GetHeap()->HasImageSpace() && 3091 klass->GetClassLoader() != nullptr) { 3092 return false; 3093 } 3094 3095 uint16_t class_def_index = klass->GetDexClassDefIndex(); 3096 oat_file_class_status = oat_dex_file->GetOatClass(class_def_index).GetStatus(); 3097 if (oat_file_class_status == mirror::Class::kStatusVerified || 3098 oat_file_class_status == mirror::Class::kStatusInitialized) { 3099 return true; 3100 } 3101 if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) { 3102 // Compile time verification failed with a soft error. Compile time verification can fail 3103 // because we have incomplete type information. Consider the following: 3104 // class ... { 3105 // Foo x; 3106 // .... () { 3107 // if (...) { 3108 // v1 gets assigned a type of resolved class Foo 3109 // } else { 3110 // v1 gets assigned a type of unresolved class Bar 3111 // } 3112 // iput x = v1 3113 // } } 3114 // when we merge v1 following the if-the-else it results in Conflict 3115 // (see verifier::RegType::Merge) as we can't know the type of Bar and we could possibly be 3116 // allowing an unsafe assignment to the field x in the iput (javac may have compiled this as 3117 // it knew Bar was a sub-class of Foo, but for us this may have been moved into a separate apk 3118 // at compile time). 3119 return false; 3120 } 3121 if (oat_file_class_status == mirror::Class::kStatusError) { 3122 // Compile time verification failed with a hard error. This is caused by invalid instructions 3123 // in the class. These errors are unrecoverable. 3124 return false; 3125 } 3126 if (oat_file_class_status == mirror::Class::kStatusNotReady) { 3127 // Status is uninitialized if we couldn't determine the status at compile time, for example, 3128 // not loading the class. 3129 // TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy 3130 // isn't a problem and this case shouldn't occur 3131 return false; 3132 } 3133 std::string temp; 3134 LOG(FATAL) << "Unexpected class status: " << oat_file_class_status 3135 << " " << dex_file.GetLocation() << " " << PrettyClass(klass) << " " 3136 << klass->GetDescriptor(&temp); 3137 UNREACHABLE(); 3138} 3139 3140void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, 3141 Handle<mirror::Class> klass) { 3142 for (size_t i = 0; i < klass->NumDirectMethods(); i++) { 3143 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i)); 3144 } 3145 for (size_t i = 0; i < klass->NumVirtualMethods(); i++) { 3146 ResolveMethodExceptionHandlerTypes(dex_file, klass->GetVirtualMethod(i)); 3147 } 3148} 3149 3150void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, 3151 mirror::ArtMethod* method) { 3152 // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod. 3153 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset()); 3154 if (code_item == nullptr) { 3155 return; // native or abstract method 3156 } 3157 if (code_item->tries_size_ == 0) { 3158 return; // nothing to process 3159 } 3160 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0); 3161 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr); 3162 ClassLinker* linker = Runtime::Current()->GetClassLinker(); 3163 for (uint32_t idx = 0; idx < handlers_size; idx++) { 3164 CatchHandlerIterator iterator(handlers_ptr); 3165 for (; iterator.HasNext(); iterator.Next()) { 3166 // Ensure exception types are resolved so that they don't need resolution to be delivered, 3167 // unresolved exception types will be ignored by exception delivery 3168 if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) { 3169 mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method); 3170 if (exception_type == nullptr) { 3171 DCHECK(Thread::Current()->IsExceptionPending()); 3172 Thread::Current()->ClearException(); 3173 } 3174 } 3175 } 3176 handlers_ptr = iterator.EndDataPointer(); 3177 } 3178} 3179 3180static void CheckProxyConstructor(mirror::ArtMethod* constructor); 3181static void CheckProxyMethod(Handle<mirror::ArtMethod> method, 3182 Handle<mirror::ArtMethod> prototype); 3183 3184mirror::Class* ClassLinker::CreateProxyClass(ScopedObjectAccessAlreadyRunnable& soa, jstring name, 3185 jobjectArray interfaces, jobject loader, 3186 jobjectArray methods, jobjectArray throws) { 3187 Thread* self = soa.Self(); 3188 StackHandleScope<9> hs(self); 3189 MutableHandle<mirror::Class> klass(hs.NewHandle( 3190 AllocClass(self, GetClassRoot(kJavaLangClass), sizeof(mirror::Class)))); 3191 if (klass.Get() == nullptr) { 3192 CHECK(self->IsExceptionPending()); // OOME. 3193 return nullptr; 3194 } 3195 DCHECK(klass->GetClass() != nullptr); 3196 klass->SetObjectSize(sizeof(mirror::Proxy)); 3197 // Set the class access flags incl. preverified, so we do not try to set the flag on the methods. 3198 klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal | kAccPreverified); 3199 klass->SetClassLoader(soa.Decode<mirror::ClassLoader*>(loader)); 3200 DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot); 3201 klass->SetName(soa.Decode<mirror::String*>(name)); 3202 mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy); 3203 klass->SetDexCache(proxy_class->GetDexCache()); 3204 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, self); 3205 3206 // Instance fields are inherited, but we add a couple of static fields... 3207 const size_t num_fields = 2; 3208 ArtField* sfields = AllocArtFieldArray(self, num_fields); 3209 klass->SetSFields(sfields); 3210 klass->SetNumStaticFields(num_fields); 3211 3212 // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by 3213 // our proxy, so Class.getInterfaces doesn't return the flattened set. 3214 ArtField* interfaces_sfield = &sfields[0]; 3215 interfaces_sfield->SetDexFieldIndex(0); 3216 interfaces_sfield->SetDeclaringClass(klass.Get()); 3217 interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal); 3218 3219 // 2. Create a static field 'throws' that holds exceptions thrown by our methods. 3220 ArtField* throws_sfield = &sfields[1]; 3221 throws_sfield->SetDexFieldIndex(1); 3222 throws_sfield->SetDeclaringClass(klass.Get()); 3223 throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal); 3224 3225 // Proxies have 1 direct method, the constructor 3226 { 3227 mirror::ObjectArray<mirror::ArtMethod>* directs = AllocArtMethodArray(self, 1); 3228 if (UNLIKELY(directs == nullptr)) { 3229 CHECK(self->IsExceptionPending()); // OOME. 3230 return nullptr; 3231 } 3232 klass->SetDirectMethods(directs); 3233 mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class); 3234 if (UNLIKELY(constructor == nullptr)) { 3235 CHECK(self->IsExceptionPending()); // OOME. 3236 return nullptr; 3237 } 3238 klass->SetDirectMethod(0, constructor); 3239 } 3240 3241 // Create virtual method using specified prototypes. 3242 auto h_methods = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Method>*>(methods)); 3243 DCHECK_EQ(h_methods->GetClass(), mirror::Method::ArrayClass()) 3244 << PrettyClass(h_methods->GetClass()); 3245 const size_t num_virtual_methods = h_methods->GetLength(); 3246 { 3247 mirror::ObjectArray<mirror::ArtMethod>* virtuals = AllocArtMethodArray(self, 3248 num_virtual_methods); 3249 if (UNLIKELY(virtuals == nullptr)) { 3250 CHECK(self->IsExceptionPending()); // OOME. 3251 return nullptr; 3252 } 3253 klass->SetVirtualMethods(virtuals); 3254 } 3255 for (size_t i = 0; i < num_virtual_methods; ++i) { 3256 StackHandleScope<1> hs2(self); 3257 Handle<mirror::ArtMethod> prototype(hs2.NewHandle(h_methods->Get(i)->GetArtMethod())); 3258 mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype); 3259 if (UNLIKELY(clone == nullptr)) { 3260 CHECK(self->IsExceptionPending()); // OOME. 3261 return nullptr; 3262 } 3263 klass->SetVirtualMethod(i, clone); 3264 } 3265 3266 klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy 3267 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, self); // Now effectively in the loaded state. 3268 self->AssertNoPendingException(); 3269 3270 std::string descriptor(GetDescriptorForProxy(klass.Get())); 3271 mirror::Class* new_class = nullptr; 3272 { 3273 // Must hold lock on object when resolved. 3274 ObjectLock<mirror::Class> resolution_lock(self, klass); 3275 // Link the fields and virtual methods, creating vtable and iftables 3276 Handle<mirror::ObjectArray<mirror::Class> > h_interfaces( 3277 hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces))); 3278 if (!LinkClass(self, descriptor.c_str(), klass, h_interfaces, &new_class)) { 3279 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3280 return nullptr; 3281 } 3282 } 3283 3284 CHECK(klass->IsRetired()); 3285 CHECK_NE(klass.Get(), new_class); 3286 klass.Assign(new_class); 3287 3288 CHECK_EQ(interfaces_sfield->GetDeclaringClass(), new_class); 3289 interfaces_sfield->SetObject<false>(klass.Get(), 3290 soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces)); 3291 CHECK_EQ(throws_sfield->GetDeclaringClass(), new_class); 3292 throws_sfield->SetObject<false>(klass.Get(), 3293 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(throws)); 3294 3295 { 3296 // Lock on klass is released. Lock new class object. 3297 ObjectLock<mirror::Class> initialization_lock(self, klass); 3298 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self); 3299 } 3300 3301 // sanity checks 3302 if (kIsDebugBuild) { 3303 CHECK(klass->GetIFields() == nullptr); 3304 CheckProxyConstructor(klass->GetDirectMethod(0)); 3305 for (size_t i = 0; i < num_virtual_methods; ++i) { 3306 StackHandleScope<2> hs2(self); 3307 Handle<mirror::ArtMethod> prototype(hs2.NewHandle(h_methods->Get(i)->GetArtMethod())); 3308 Handle<mirror::ArtMethod> virtual_method(hs2.NewHandle(klass->GetVirtualMethod(i))); 3309 CheckProxyMethod(virtual_method, prototype); 3310 } 3311 3312 mirror::String* decoded_name = soa.Decode<mirror::String*>(name); 3313 std::string interfaces_field_name(StringPrintf("java.lang.Class[] %s.interfaces", 3314 decoded_name->ToModifiedUtf8().c_str())); 3315 CHECK_EQ(PrettyField(klass->GetStaticField(0)), interfaces_field_name); 3316 3317 std::string throws_field_name(StringPrintf("java.lang.Class[][] %s.throws", 3318 decoded_name->ToModifiedUtf8().c_str())); 3319 CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name); 3320 3321 CHECK_EQ(klass.Get()->GetInterfaces(), 3322 soa.Decode<mirror::ObjectArray<mirror::Class>*>(interfaces)); 3323 CHECK_EQ(klass.Get()->GetThrows(), 3324 soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class>>*>(throws)); 3325 } 3326 mirror::Class* existing = InsertClass(descriptor.c_str(), klass.Get(), 3327 ComputeModifiedUtf8Hash(descriptor.c_str())); 3328 CHECK(existing == nullptr); 3329 return klass.Get(); 3330} 3331 3332std::string ClassLinker::GetDescriptorForProxy(mirror::Class* proxy_class) { 3333 DCHECK(proxy_class->IsProxyClass()); 3334 mirror::String* name = proxy_class->GetName(); 3335 DCHECK(name != nullptr); 3336 return DotToDescriptor(name->ToModifiedUtf8().c_str()); 3337} 3338 3339mirror::ArtMethod* ClassLinker::FindMethodForProxy(mirror::Class* proxy_class, 3340 mirror::ArtMethod* proxy_method) { 3341 DCHECK(proxy_class->IsProxyClass()); 3342 DCHECK(proxy_method->IsProxyMethod()); 3343 { 3344 ReaderMutexLock mu(Thread::Current(), dex_lock_); 3345 // Locate the dex cache of the original interface/Object 3346 for (const GcRoot<mirror::DexCache>& root : dex_caches_) { 3347 auto* dex_cache = root.Read(); 3348 if (proxy_method->HasSameDexCacheResolvedTypes(dex_cache->GetResolvedTypes())) { 3349 mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod( 3350 proxy_method->GetDexMethodIndex()); 3351 CHECK(resolved_method != nullptr); 3352 return resolved_method; 3353 } 3354 } 3355 } 3356 LOG(FATAL) << "Didn't find dex cache for " << PrettyClass(proxy_class) << " " 3357 << PrettyMethod(proxy_method); 3358 UNREACHABLE(); 3359} 3360 3361 3362mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self, 3363 Handle<mirror::Class> klass, 3364 mirror::Class* proxy_class) { 3365 // Create constructor for Proxy that must initialize h 3366 mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods = 3367 proxy_class->GetDirectMethods(); 3368 CHECK_EQ(proxy_direct_methods->GetLength(), 16); 3369 mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2); 3370 // Ensure constructor is in dex cache so that we can use the dex cache to look up the overridden 3371 // constructor method. 3372 proxy_class->GetDexCache()->SetResolvedMethod(proxy_constructor->GetDexMethodIndex(), 3373 proxy_constructor); 3374 // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its 3375 // code_ too) 3376 mirror::ArtMethod* constructor = down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self)); 3377 if (constructor == nullptr) { 3378 CHECK(self->IsExceptionPending()); // OOME. 3379 return nullptr; 3380 } 3381 // Make this constructor public and fix the class to be our Proxy version 3382 constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic); 3383 constructor->SetDeclaringClass(klass.Get()); 3384 return constructor; 3385} 3386 3387static void CheckProxyConstructor(mirror::ArtMethod* constructor) 3388 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 3389 CHECK(constructor->IsConstructor()); 3390 CHECK_STREQ(constructor->GetName(), "<init>"); 3391 CHECK_STREQ(constructor->GetSignature().ToString().c_str(), 3392 "(Ljava/lang/reflect/InvocationHandler;)V"); 3393 DCHECK(constructor->IsPublic()); 3394} 3395 3396mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self, 3397 Handle<mirror::Class> klass, 3398 Handle<mirror::ArtMethod> prototype) { 3399 // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden 3400 // prototype method 3401 auto* dex_cache = prototype->GetDeclaringClass()->GetDexCache(); 3402 // Avoid dirtying the dex cache unless we need to. 3403 if (dex_cache->GetResolvedMethod(prototype->GetDexMethodIndex()) != prototype.Get()) { 3404 dex_cache->SetResolvedMethod(prototype->GetDexMethodIndex(), prototype.Get()); 3405 } 3406 // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize 3407 // as necessary 3408 mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self)); 3409 if (UNLIKELY(method == nullptr)) { 3410 CHECK(self->IsExceptionPending()); // OOME. 3411 return nullptr; 3412 } 3413 3414 // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to 3415 // the intersection of throw exceptions as defined in Proxy 3416 method->SetDeclaringClass(klass.Get()); 3417 method->SetAccessFlags((method->GetAccessFlags() & ~kAccAbstract) | kAccFinal); 3418 3419 // At runtime the method looks like a reference and argument saving method, clone the code 3420 // related parameters from this method. 3421 method->SetEntryPointFromQuickCompiledCode(GetQuickProxyInvokeHandler()); 3422 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge); 3423 3424 return method; 3425} 3426 3427static void CheckProxyMethod(Handle<mirror::ArtMethod> method, 3428 Handle<mirror::ArtMethod> prototype) 3429 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 3430 // Basic sanity 3431 CHECK(!prototype->IsFinal()); 3432 CHECK(method->IsFinal()); 3433 CHECK(!method->IsAbstract()); 3434 3435 // The proxy method doesn't have its own dex cache or dex file and so it steals those of its 3436 // interface prototype. The exception to this are Constructors and the Class of the Proxy itself. 3437 CHECK(prototype->HasSameDexCacheResolvedMethods(method.Get())); 3438 CHECK(prototype->HasSameDexCacheResolvedTypes(method.Get())); 3439 CHECK_EQ(prototype->GetDeclaringClass()->GetDexCache(), method->GetDexCache()); 3440 CHECK_EQ(prototype->GetDexMethodIndex(), method->GetDexMethodIndex()); 3441 3442 CHECK_STREQ(method->GetName(), prototype->GetName()); 3443 CHECK_STREQ(method->GetShorty(), prototype->GetShorty()); 3444 // More complex sanity - via dex cache 3445 CHECK_EQ(method->GetInterfaceMethodIfProxy()->GetReturnType(), prototype->GetReturnType()); 3446} 3447 3448static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics, 3449 bool can_init_parents) 3450 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 3451 if (can_init_statics && can_init_parents) { 3452 return true; 3453 } 3454 if (!can_init_statics) { 3455 // Check if there's a class initializer. 3456 mirror::ArtMethod* clinit = klass->FindClassInitializer(); 3457 if (clinit != nullptr) { 3458 return false; 3459 } 3460 // Check if there are encoded static values needing initialization. 3461 if (klass->NumStaticFields() != 0) { 3462 const DexFile::ClassDef* dex_class_def = klass->GetClassDef(); 3463 DCHECK(dex_class_def != nullptr); 3464 if (dex_class_def->static_values_off_ != 0) { 3465 return false; 3466 } 3467 } 3468 } 3469 if (!klass->IsInterface() && klass->HasSuperClass()) { 3470 mirror::Class* super_class = klass->GetSuperClass(); 3471 if (!can_init_parents && !super_class->IsInitialized()) { 3472 return false; 3473 } else { 3474 if (!CanWeInitializeClass(super_class, can_init_statics, can_init_parents)) { 3475 return false; 3476 } 3477 } 3478 } 3479 return true; 3480} 3481 3482bool ClassLinker::InitializeClass(Thread* self, Handle<mirror::Class> klass, 3483 bool can_init_statics, bool can_init_parents) { 3484 // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol 3485 3486 // Are we already initialized and therefore done? 3487 // Note: we differ from the JLS here as we don't do this under the lock, this is benign as 3488 // an initialized class will never change its state. 3489 if (klass->IsInitialized()) { 3490 return true; 3491 } 3492 3493 // Fast fail if initialization requires a full runtime. Not part of the JLS. 3494 if (!CanWeInitializeClass(klass.Get(), can_init_statics, can_init_parents)) { 3495 return false; 3496 } 3497 3498 self->AllowThreadSuspension(); 3499 uint64_t t0; 3500 { 3501 ObjectLock<mirror::Class> lock(self, klass); 3502 3503 // Re-check under the lock in case another thread initialized ahead of us. 3504 if (klass->IsInitialized()) { 3505 return true; 3506 } 3507 3508 // Was the class already found to be erroneous? Done under the lock to match the JLS. 3509 if (klass->IsErroneous()) { 3510 ThrowEarlierClassFailure(klass.Get()); 3511 VlogClassInitializationFailure(klass); 3512 return false; 3513 } 3514 3515 CHECK(klass->IsResolved()) << PrettyClass(klass.Get()) << ": state=" << klass->GetStatus(); 3516 3517 if (!klass->IsVerified()) { 3518 VerifyClass(self, klass); 3519 if (!klass->IsVerified()) { 3520 // We failed to verify, expect either the klass to be erroneous or verification failed at 3521 // compile time. 3522 if (klass->IsErroneous()) { 3523 CHECK(self->IsExceptionPending()); 3524 VlogClassInitializationFailure(klass); 3525 } else { 3526 CHECK(Runtime::Current()->IsAotCompiler()); 3527 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 3528 } 3529 return false; 3530 } else { 3531 self->AssertNoPendingException(); 3532 } 3533 } 3534 3535 // If the class is kStatusInitializing, either this thread is 3536 // initializing higher up the stack or another thread has beat us 3537 // to initializing and we need to wait. Either way, this 3538 // invocation of InitializeClass will not be responsible for 3539 // running <clinit> and will return. 3540 if (klass->GetStatus() == mirror::Class::kStatusInitializing) { 3541 // Could have got an exception during verification. 3542 if (self->IsExceptionPending()) { 3543 VlogClassInitializationFailure(klass); 3544 return false; 3545 } 3546 // We caught somebody else in the act; was it us? 3547 if (klass->GetClinitThreadId() == self->GetTid()) { 3548 // Yes. That's fine. Return so we can continue initializing. 3549 return true; 3550 } 3551 // No. That's fine. Wait for another thread to finish initializing. 3552 return WaitForInitializeClass(klass, self, lock); 3553 } 3554 3555 if (!ValidateSuperClassDescriptors(klass)) { 3556 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3557 return false; 3558 } 3559 self->AllowThreadSuspension(); 3560 3561 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass.Get()); 3562 3563 // From here out other threads may observe that we're initializing and so changes of state 3564 // require the a notification. 3565 klass->SetClinitThreadId(self->GetTid()); 3566 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitializing, self); 3567 3568 t0 = NanoTime(); 3569 } 3570 3571 // Initialize super classes, must be done while initializing for the JLS. 3572 if (!klass->IsInterface() && klass->HasSuperClass()) { 3573 mirror::Class* super_class = klass->GetSuperClass(); 3574 if (!super_class->IsInitialized()) { 3575 CHECK(!super_class->IsInterface()); 3576 CHECK(can_init_parents); 3577 StackHandleScope<1> hs(self); 3578 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class)); 3579 bool super_initialized = InitializeClass(self, handle_scope_super, can_init_statics, true); 3580 if (!super_initialized) { 3581 // The super class was verified ahead of entering initializing, we should only be here if 3582 // the super class became erroneous due to initialization. 3583 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending()) 3584 << "Super class initialization failed for " 3585 << PrettyDescriptor(handle_scope_super.Get()) 3586 << " that has unexpected status " << handle_scope_super->GetStatus() 3587 << "\nPending exception:\n" 3588 << (self->GetException() != nullptr ? self->GetException()->Dump() : ""); 3589 ObjectLock<mirror::Class> lock(self, klass); 3590 // Initialization failed because the super-class is erroneous. 3591 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3592 return false; 3593 } 3594 } 3595 } 3596 3597 const size_t num_static_fields = klass->NumStaticFields(); 3598 if (num_static_fields > 0) { 3599 const DexFile::ClassDef* dex_class_def = klass->GetClassDef(); 3600 CHECK(dex_class_def != nullptr); 3601 const DexFile& dex_file = klass->GetDexFile(); 3602 StackHandleScope<3> hs(self); 3603 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader())); 3604 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache())); 3605 3606 // Eagerly fill in static fields so that the we don't have to do as many expensive 3607 // Class::FindStaticField in ResolveField. 3608 for (size_t i = 0; i < num_static_fields; ++i) { 3609 ArtField* field = klass->GetStaticField(i); 3610 const uint32_t field_idx = field->GetDexFieldIndex(); 3611 ArtField* resolved_field = dex_cache->GetResolvedField(field_idx, image_pointer_size_); 3612 if (resolved_field == nullptr) { 3613 dex_cache->SetResolvedField(field_idx, field, image_pointer_size_); 3614 } else { 3615 DCHECK_EQ(field, resolved_field); 3616 } 3617 } 3618 3619 EncodedStaticFieldValueIterator value_it(dex_file, &dex_cache, &class_loader, 3620 this, *dex_class_def); 3621 const uint8_t* class_data = dex_file.GetClassData(*dex_class_def); 3622 ClassDataItemIterator field_it(dex_file, class_data); 3623 if (value_it.HasNext()) { 3624 DCHECK(field_it.HasNextStaticField()); 3625 CHECK(can_init_statics); 3626 for ( ; value_it.HasNext(); value_it.Next(), field_it.Next()) { 3627 ArtField* field = ResolveField( 3628 dex_file, field_it.GetMemberIndex(), dex_cache, class_loader, true); 3629 if (Runtime::Current()->IsActiveTransaction()) { 3630 value_it.ReadValueToField<true>(field); 3631 } else { 3632 value_it.ReadValueToField<false>(field); 3633 } 3634 DCHECK(!value_it.HasNext() || field_it.HasNextStaticField()); 3635 } 3636 } 3637 } 3638 3639 mirror::ArtMethod* clinit = klass->FindClassInitializer(); 3640 if (clinit != nullptr) { 3641 CHECK(can_init_statics); 3642 JValue result; 3643 clinit->Invoke(self, nullptr, 0, &result, "V"); 3644 } 3645 3646 self->AllowThreadSuspension(); 3647 uint64_t t1 = NanoTime(); 3648 3649 bool success = true; 3650 { 3651 ObjectLock<mirror::Class> lock(self, klass); 3652 3653 if (self->IsExceptionPending()) { 3654 WrapExceptionInInitializer(klass); 3655 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3656 success = false; 3657 } else if (Runtime::Current()->IsTransactionAborted()) { 3658 // The exception thrown when the transaction aborted has been caught and cleared 3659 // so we need to throw it again now. 3660 VLOG(compiler) << "Return from class initializer of " << PrettyDescriptor(klass.Get()) 3661 << " without exception while transaction was aborted: re-throw it now."; 3662 Runtime::Current()->ThrowTransactionAbortError(self); 3663 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3664 success = false; 3665 } else { 3666 RuntimeStats* global_stats = Runtime::Current()->GetStats(); 3667 RuntimeStats* thread_stats = self->GetStats(); 3668 ++global_stats->class_init_count; 3669 ++thread_stats->class_init_count; 3670 global_stats->class_init_time_ns += (t1 - t0); 3671 thread_stats->class_init_time_ns += (t1 - t0); 3672 // Set the class as initialized except if failed to initialize static fields. 3673 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self); 3674 if (VLOG_IS_ON(class_linker)) { 3675 std::string temp; 3676 LOG(INFO) << "Initialized class " << klass->GetDescriptor(&temp) << " from " << 3677 klass->GetLocation(); 3678 } 3679 // Opportunistically set static method trampolines to their destination. 3680 FixupStaticTrampolines(klass.Get()); 3681 } 3682 } 3683 return success; 3684} 3685 3686bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass, Thread* self, 3687 ObjectLock<mirror::Class>& lock) 3688 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 3689 while (true) { 3690 self->AssertNoPendingException(); 3691 CHECK(!klass->IsInitialized()); 3692 lock.WaitIgnoringInterrupts(); 3693 3694 // When we wake up, repeat the test for init-in-progress. If 3695 // there's an exception pending (only possible if 3696 // we were not using WaitIgnoringInterrupts), bail out. 3697 if (self->IsExceptionPending()) { 3698 WrapExceptionInInitializer(klass); 3699 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3700 return false; 3701 } 3702 // Spurious wakeup? Go back to waiting. 3703 if (klass->GetStatus() == mirror::Class::kStatusInitializing) { 3704 continue; 3705 } 3706 if (klass->GetStatus() == mirror::Class::kStatusVerified && 3707 Runtime::Current()->IsAotCompiler()) { 3708 // Compile time initialization failed. 3709 return false; 3710 } 3711 if (klass->IsErroneous()) { 3712 // The caller wants an exception, but it was thrown in a 3713 // different thread. Synthesize one here. 3714 ThrowNoClassDefFoundError("<clinit> failed for class %s; see exception in other thread", 3715 PrettyDescriptor(klass.Get()).c_str()); 3716 VlogClassInitializationFailure(klass); 3717 return false; 3718 } 3719 if (klass->IsInitialized()) { 3720 return true; 3721 } 3722 LOG(FATAL) << "Unexpected class status. " << PrettyClass(klass.Get()) << " is " 3723 << klass->GetStatus(); 3724 } 3725 UNREACHABLE(); 3726} 3727 3728static bool HasSameSignatureWithDifferentClassLoaders(Thread* self, 3729 Handle<mirror::ArtMethod> method1, 3730 Handle<mirror::ArtMethod> method2, 3731 std::string* error_msg) 3732 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 3733 { 3734 StackHandleScope<1> hs(self); 3735 Handle<mirror::Class> return_type(hs.NewHandle(method1->GetReturnType())); 3736 mirror::Class* other_return_type = method2->GetReturnType(); 3737 // NOTE: return_type.Get() must be sequenced after method2->GetReturnType(). 3738 if (UNLIKELY(other_return_type != return_type.Get())) { 3739 *error_msg = StringPrintf("Return types mismatch: %s(%p) vs %s(%p)", 3740 PrettyClassAndClassLoader(return_type.Get()).c_str(), 3741 return_type.Get(), 3742 PrettyClassAndClassLoader(other_return_type).c_str(), 3743 other_return_type); 3744 return false; 3745 } 3746 } 3747 const DexFile::TypeList* types1 = method1->GetParameterTypeList(); 3748 const DexFile::TypeList* types2 = method2->GetParameterTypeList(); 3749 if (types1 == nullptr) { 3750 if (types2 != nullptr && types2->Size() != 0) { 3751 *error_msg = StringPrintf("Type list mismatch with %s", 3752 PrettyMethod(method2.Get(), true).c_str()); 3753 return false; 3754 } 3755 return true; 3756 } else if (UNLIKELY(types2 == nullptr)) { 3757 if (types1->Size() != 0) { 3758 *error_msg = StringPrintf("Type list mismatch with %s", 3759 PrettyMethod(method2.Get(), true).c_str()); 3760 return false; 3761 } 3762 return true; 3763 } 3764 uint32_t num_types = types1->Size(); 3765 if (UNLIKELY(num_types != types2->Size())) { 3766 *error_msg = StringPrintf("Type list mismatch with %s", 3767 PrettyMethod(method2.Get(), true).c_str()); 3768 return false; 3769 } 3770 for (uint32_t i = 0; i < num_types; ++i) { 3771 StackHandleScope<1> hs(self); 3772 Handle<mirror::Class> param_type(hs.NewHandle( 3773 method1->GetClassFromTypeIndex(types1->GetTypeItem(i).type_idx_, true))); 3774 mirror::Class* other_param_type = 3775 method2->GetClassFromTypeIndex(types2->GetTypeItem(i).type_idx_, true); 3776 // NOTE: param_type.Get() must be sequenced after method2->GetClassFromTypeIndex(...). 3777 if (UNLIKELY(param_type.Get() != other_param_type)) { 3778 *error_msg = StringPrintf("Parameter %u type mismatch: %s(%p) vs %s(%p)", 3779 i, 3780 PrettyClassAndClassLoader(param_type.Get()).c_str(), 3781 param_type.Get(), 3782 PrettyClassAndClassLoader(other_param_type).c_str(), 3783 other_param_type); 3784 return false; 3785 } 3786 } 3787 return true; 3788} 3789 3790 3791bool ClassLinker::ValidateSuperClassDescriptors(Handle<mirror::Class> klass) { 3792 if (klass->IsInterface()) { 3793 return true; 3794 } 3795 // Begin with the methods local to the superclass. 3796 Thread* self = Thread::Current(); 3797 StackHandleScope<2> hs(self); 3798 MutableHandle<mirror::ArtMethod> h_m(hs.NewHandle<mirror::ArtMethod>(nullptr)); 3799 MutableHandle<mirror::ArtMethod> super_h_m(hs.NewHandle<mirror::ArtMethod>(nullptr)); 3800 if (klass->HasSuperClass() && 3801 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) { 3802 for (int i = klass->GetSuperClass()->GetVTableLength() - 1; i >= 0; --i) { 3803 h_m.Assign(klass->GetVTableEntry(i)); 3804 super_h_m.Assign(klass->GetSuperClass()->GetVTableEntry(i)); 3805 if (h_m.Get() != super_h_m.Get()) { 3806 std::string error_msg; 3807 if (!HasSameSignatureWithDifferentClassLoaders(self, h_m, super_h_m, &error_msg)) { 3808 ThrowLinkageError(klass.Get(), 3809 "Class %s method %s resolves differently in superclass %s: %s", 3810 PrettyDescriptor(klass.Get()).c_str(), 3811 PrettyMethod(h_m.Get()).c_str(), 3812 PrettyDescriptor(klass->GetSuperClass()).c_str(), 3813 error_msg.c_str()); 3814 return false; 3815 } 3816 } 3817 } 3818 } 3819 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) { 3820 if (klass->GetClassLoader() != klass->GetIfTable()->GetInterface(i)->GetClassLoader()) { 3821 uint32_t num_methods = klass->GetIfTable()->GetInterface(i)->NumVirtualMethods(); 3822 for (uint32_t j = 0; j < num_methods; ++j) { 3823 h_m.Assign(klass->GetIfTable()->GetMethodArray(i)->GetWithoutChecks(j)); 3824 super_h_m.Assign(klass->GetIfTable()->GetInterface(i)->GetVirtualMethod(j)); 3825 if (h_m.Get() != super_h_m.Get()) { 3826 std::string error_msg; 3827 if (!HasSameSignatureWithDifferentClassLoaders(self, h_m, super_h_m, &error_msg)) { 3828 ThrowLinkageError(klass.Get(), 3829 "Class %s method %s resolves differently in interface %s: %s", 3830 PrettyDescriptor(klass.Get()).c_str(), 3831 PrettyMethod(h_m.Get()).c_str(), 3832 PrettyDescriptor(klass->GetIfTable()->GetInterface(i)).c_str(), 3833 error_msg.c_str()); 3834 return false; 3835 } 3836 } 3837 } 3838 } 3839 } 3840 return true; 3841} 3842 3843bool ClassLinker::EnsureInitialized(Thread* self, Handle<mirror::Class> c, bool can_init_fields, 3844 bool can_init_parents) { 3845 DCHECK(c.Get() != nullptr); 3846 if (c->IsInitialized()) { 3847 EnsurePreverifiedMethods(c); 3848 return true; 3849 } 3850 const bool success = InitializeClass(self, c, can_init_fields, can_init_parents); 3851 if (!success) { 3852 if (can_init_fields && can_init_parents) { 3853 CHECK(self->IsExceptionPending()) << PrettyClass(c.Get()); 3854 } 3855 } else { 3856 self->AssertNoPendingException(); 3857 } 3858 return success; 3859} 3860 3861void ClassLinker::FixupTemporaryDeclaringClass(mirror::Class* temp_class, mirror::Class* new_class) { 3862 ArtField* fields = new_class->GetIFields(); 3863 for (size_t i = 0, count = new_class->NumInstanceFields(); i < count; i++) { 3864 if (fields[i].GetDeclaringClass() == temp_class) { 3865 fields[i].SetDeclaringClass(new_class); 3866 } 3867 } 3868 3869 fields = new_class->GetSFields(); 3870 for (size_t i = 0, count = new_class->NumStaticFields(); i < count; i++) { 3871 if (fields[i].GetDeclaringClass() == temp_class) { 3872 fields[i].SetDeclaringClass(new_class); 3873 } 3874 } 3875 3876 mirror::ObjectArray<mirror::ArtMethod>* methods = new_class->GetDirectMethods(); 3877 if (methods != nullptr) { 3878 for (int index = 0; index < methods->GetLength(); index ++) { 3879 if (methods->Get(index)->GetDeclaringClass() == temp_class) { 3880 methods->Get(index)->SetDeclaringClass(new_class); 3881 } 3882 } 3883 } 3884 3885 methods = new_class->GetVirtualMethods(); 3886 if (methods != nullptr) { 3887 for (int index = 0; index < methods->GetLength(); index ++) { 3888 if (methods->Get(index)->GetDeclaringClass() == temp_class) { 3889 methods->Get(index)->SetDeclaringClass(new_class); 3890 } 3891 } 3892 } 3893} 3894 3895bool ClassLinker::LinkClass(Thread* self, const char* descriptor, Handle<mirror::Class> klass, 3896 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 3897 mirror::Class** new_class) { 3898 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus()); 3899 3900 if (!LinkSuperClass(klass)) { 3901 return false; 3902 } 3903 StackHandleScope<mirror::Class::kImtSize> imt_handle_scope( 3904 self, Runtime::Current()->GetImtUnimplementedMethod()); 3905 if (!LinkMethods(self, klass, interfaces, &imt_handle_scope)) { 3906 return false; 3907 } 3908 if (!LinkInstanceFields(self, klass)) { 3909 return false; 3910 } 3911 size_t class_size; 3912 if (!LinkStaticFields(self, klass, &class_size)) { 3913 return false; 3914 } 3915 CreateReferenceInstanceOffsets(klass); 3916 CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus()); 3917 3918 if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) { 3919 // We don't need to retire this class as it has no embedded tables or it was created the 3920 // correct size during class linker initialization. 3921 CHECK_EQ(klass->GetClassSize(), class_size) << PrettyDescriptor(klass.Get()); 3922 3923 if (klass->ShouldHaveEmbeddedImtAndVTable()) { 3924 klass->PopulateEmbeddedImtAndVTable(&imt_handle_scope); 3925 } 3926 3927 // This will notify waiters on klass that saw the not yet resolved 3928 // class in the class_table_ during EnsureResolved. 3929 mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self); 3930 *new_class = klass.Get(); 3931 } else { 3932 CHECK(!klass->IsResolved()); 3933 // Retire the temporary class and create the correctly sized resolved class. 3934 *new_class = klass->CopyOf(self, class_size, &imt_handle_scope); 3935 if (UNLIKELY(*new_class == nullptr)) { 3936 CHECK(self->IsExceptionPending()); // Expect an OOME. 3937 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self); 3938 return false; 3939 } 3940 3941 CHECK_EQ((*new_class)->GetClassSize(), class_size); 3942 StackHandleScope<1> hs(self); 3943 auto new_class_h = hs.NewHandleWrapper<mirror::Class>(new_class); 3944 ObjectLock<mirror::Class> lock(self, new_class_h); 3945 3946 FixupTemporaryDeclaringClass(klass.Get(), new_class_h.Get()); 3947 3948 mirror::Class* existing = UpdateClass(descriptor, new_class_h.Get(), 3949 ComputeModifiedUtf8Hash(descriptor)); 3950 CHECK(existing == nullptr || existing == klass.Get()); 3951 3952 // This will notify waiters on temp class that saw the not yet resolved class in the 3953 // class_table_ during EnsureResolved. 3954 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetired, self); 3955 3956 CHECK_EQ(new_class_h->GetStatus(), mirror::Class::kStatusResolving); 3957 // This will notify waiters on new_class that saw the not yet resolved 3958 // class in the class_table_ during EnsureResolved. 3959 mirror::Class::SetStatus(new_class_h, mirror::Class::kStatusResolved, self); 3960 } 3961 return true; 3962} 3963 3964static void CountMethodsAndFields(ClassDataItemIterator& dex_data, 3965 size_t* virtual_methods, 3966 size_t* direct_methods, 3967 size_t* static_fields, 3968 size_t* instance_fields) { 3969 *virtual_methods = *direct_methods = *static_fields = *instance_fields = 0; 3970 3971 while (dex_data.HasNextStaticField()) { 3972 dex_data.Next(); 3973 (*static_fields)++; 3974 } 3975 while (dex_data.HasNextInstanceField()) { 3976 dex_data.Next(); 3977 (*instance_fields)++; 3978 } 3979 while (dex_data.HasNextDirectMethod()) { 3980 (*direct_methods)++; 3981 dex_data.Next(); 3982 } 3983 while (dex_data.HasNextVirtualMethod()) { 3984 (*virtual_methods)++; 3985 dex_data.Next(); 3986 } 3987 DCHECK(!dex_data.HasNext()); 3988} 3989 3990static void DumpClass(std::ostream& os, 3991 const DexFile& dex_file, const DexFile::ClassDef& dex_class_def, 3992 const char* suffix) { 3993 ClassDataItemIterator dex_data(dex_file, dex_file.GetClassData(dex_class_def)); 3994 os << dex_file.GetClassDescriptor(dex_class_def) << suffix << ":\n"; 3995 os << " Static fields:\n"; 3996 while (dex_data.HasNextStaticField()) { 3997 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex()); 3998 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n"; 3999 dex_data.Next(); 4000 } 4001 os << " Instance fields:\n"; 4002 while (dex_data.HasNextInstanceField()) { 4003 const DexFile::FieldId& id = dex_file.GetFieldId(dex_data.GetMemberIndex()); 4004 os << " " << dex_file.GetFieldTypeDescriptor(id) << " " << dex_file.GetFieldName(id) << "\n"; 4005 dex_data.Next(); 4006 } 4007 os << " Direct methods:\n"; 4008 while (dex_data.HasNextDirectMethod()) { 4009 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex()); 4010 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n"; 4011 dex_data.Next(); 4012 } 4013 os << " Virtual methods:\n"; 4014 while (dex_data.HasNextVirtualMethod()) { 4015 const DexFile::MethodId& id = dex_file.GetMethodId(dex_data.GetMemberIndex()); 4016 os << " " << dex_file.GetMethodName(id) << dex_file.GetMethodSignature(id).ToString() << "\n"; 4017 dex_data.Next(); 4018 } 4019} 4020 4021static std::string DumpClasses(const DexFile& dex_file1, const DexFile::ClassDef& dex_class_def1, 4022 const DexFile& dex_file2, const DexFile::ClassDef& dex_class_def2) { 4023 std::ostringstream os; 4024 DumpClass(os, dex_file1, dex_class_def1, " (Compile time)"); 4025 DumpClass(os, dex_file2, dex_class_def2, " (Runtime)"); 4026 return os.str(); 4027} 4028 4029 4030// Very simple structural check on whether the classes match. Only compares the number of 4031// methods and fields. 4032static bool SimpleStructuralCheck(const DexFile& dex_file1, const DexFile::ClassDef& dex_class_def1, 4033 const DexFile& dex_file2, const DexFile::ClassDef& dex_class_def2, 4034 std::string* error_msg) { 4035 ClassDataItemIterator dex_data1(dex_file1, dex_file1.GetClassData(dex_class_def1)); 4036 ClassDataItemIterator dex_data2(dex_file2, dex_file2.GetClassData(dex_class_def2)); 4037 4038 // Counters for current dex file. 4039 size_t dex_virtual_methods1, dex_direct_methods1, dex_static_fields1, dex_instance_fields1; 4040 CountMethodsAndFields(dex_data1, &dex_virtual_methods1, &dex_direct_methods1, &dex_static_fields1, 4041 &dex_instance_fields1); 4042 // Counters for compile-time dex file. 4043 size_t dex_virtual_methods2, dex_direct_methods2, dex_static_fields2, dex_instance_fields2; 4044 CountMethodsAndFields(dex_data2, &dex_virtual_methods2, &dex_direct_methods2, &dex_static_fields2, 4045 &dex_instance_fields2); 4046 4047 if (dex_virtual_methods1 != dex_virtual_methods2) { 4048 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 4049 *error_msg = StringPrintf("Virtual method count off: %zu vs %zu\n%s", dex_virtual_methods1, 4050 dex_virtual_methods2, class_dump.c_str()); 4051 return false; 4052 } 4053 if (dex_direct_methods1 != dex_direct_methods2) { 4054 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 4055 *error_msg = StringPrintf("Direct method count off: %zu vs %zu\n%s", dex_direct_methods1, 4056 dex_direct_methods2, class_dump.c_str()); 4057 return false; 4058 } 4059 if (dex_static_fields1 != dex_static_fields2) { 4060 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 4061 *error_msg = StringPrintf("Static field count off: %zu vs %zu\n%s", dex_static_fields1, 4062 dex_static_fields2, class_dump.c_str()); 4063 return false; 4064 } 4065 if (dex_instance_fields1 != dex_instance_fields2) { 4066 std::string class_dump = DumpClasses(dex_file1, dex_class_def1, dex_file2, dex_class_def2); 4067 *error_msg = StringPrintf("Instance field count off: %zu vs %zu\n%s", dex_instance_fields1, 4068 dex_instance_fields2, class_dump.c_str()); 4069 return false; 4070 } 4071 4072 return true; 4073} 4074 4075// Checks whether a the super-class changed from what we had at compile-time. This would 4076// invalidate quickening. 4077static bool CheckSuperClassChange(Handle<mirror::Class> klass, 4078 const DexFile& dex_file, 4079 const DexFile::ClassDef& class_def, 4080 mirror::Class* super_class) 4081 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 4082 // Check for unexpected changes in the superclass. 4083 // Quick check 1) is the super_class class-loader the boot class loader? This always has 4084 // precedence. 4085 if (super_class->GetClassLoader() != nullptr && 4086 // Quick check 2) different dex cache? Breaks can only occur for different dex files, 4087 // which is implied by different dex cache. 4088 klass->GetDexCache() != super_class->GetDexCache()) { 4089 // Now comes the expensive part: things can be broken if (a) the klass' dex file has a 4090 // definition for the super-class, and (b) the files are in separate oat files. The oat files 4091 // are referenced from the dex file, so do (b) first. Only relevant if we have oat files. 4092 const OatDexFile* class_oat_dex_file = dex_file.GetOatDexFile(); 4093 const OatFile* class_oat_file = nullptr; 4094 if (class_oat_dex_file != nullptr) { 4095 class_oat_file = class_oat_dex_file->GetOatFile(); 4096 } 4097 4098 if (class_oat_file != nullptr) { 4099 const OatDexFile* loaded_super_oat_dex_file = super_class->GetDexFile().GetOatDexFile(); 4100 const OatFile* loaded_super_oat_file = nullptr; 4101 if (loaded_super_oat_dex_file != nullptr) { 4102 loaded_super_oat_file = loaded_super_oat_dex_file->GetOatFile(); 4103 } 4104 4105 if (loaded_super_oat_file != nullptr && class_oat_file != loaded_super_oat_file) { 4106 // Now check (a). 4107 const DexFile::ClassDef* super_class_def = dex_file.FindClassDef(class_def.superclass_idx_); 4108 if (super_class_def != nullptr) { 4109 // Uh-oh, we found something. Do our check. 4110 std::string error_msg; 4111 if (!SimpleStructuralCheck(dex_file, *super_class_def, 4112 super_class->GetDexFile(), *super_class->GetClassDef(), 4113 &error_msg)) { 4114 // Print a warning to the log. This exception might be caught, e.g., as common in test 4115 // drivers. When the class is later tried to be used, we re-throw a new instance, as we 4116 // only save the type of the exception. 4117 LOG(WARNING) << "Incompatible structural change detected: " << 4118 StringPrintf( 4119 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s", 4120 PrettyType(super_class_def->class_idx_, dex_file).c_str(), 4121 class_oat_file->GetLocation().c_str(), 4122 loaded_super_oat_file->GetLocation().c_str(), 4123 error_msg.c_str()); 4124 ThrowIncompatibleClassChangeError(klass.Get(), 4125 "Structural change of %s is hazardous (%s at compile time, %s at runtime): %s", 4126 PrettyType(super_class_def->class_idx_, dex_file).c_str(), 4127 class_oat_file->GetLocation().c_str(), 4128 loaded_super_oat_file->GetLocation().c_str(), 4129 error_msg.c_str()); 4130 return false; 4131 } 4132 } 4133 } 4134 } 4135 } 4136 return true; 4137} 4138 4139bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) { 4140 CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus()); 4141 const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex()); 4142 uint16_t super_class_idx = class_def.superclass_idx_; 4143 if (super_class_idx != DexFile::kDexNoIndex16) { 4144 mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.Get()); 4145 if (super_class == nullptr) { 4146 DCHECK(Thread::Current()->IsExceptionPending()); 4147 return false; 4148 } 4149 // Verify 4150 if (!klass->CanAccess(super_class)) { 4151 ThrowIllegalAccessError(klass.Get(), "Class %s extended by class %s is inaccessible", 4152 PrettyDescriptor(super_class).c_str(), 4153 PrettyDescriptor(klass.Get()).c_str()); 4154 return false; 4155 } 4156 CHECK(super_class->IsResolved()); 4157 klass->SetSuperClass(super_class); 4158 4159 if (!CheckSuperClassChange(klass, dex_file, class_def, super_class)) { 4160 DCHECK(Thread::Current()->IsExceptionPending()); 4161 return false; 4162 } 4163 } 4164 const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def); 4165 if (interfaces != nullptr) { 4166 for (size_t i = 0; i < interfaces->Size(); i++) { 4167 uint16_t idx = interfaces->GetTypeItem(i).type_idx_; 4168 mirror::Class* interface = ResolveType(dex_file, idx, klass.Get()); 4169 if (interface == nullptr) { 4170 DCHECK(Thread::Current()->IsExceptionPending()); 4171 return false; 4172 } 4173 // Verify 4174 if (!klass->CanAccess(interface)) { 4175 // TODO: the RI seemed to ignore this in my testing. 4176 ThrowIllegalAccessError(klass.Get(), "Interface %s implemented by class %s is inaccessible", 4177 PrettyDescriptor(interface).c_str(), 4178 PrettyDescriptor(klass.Get()).c_str()); 4179 return false; 4180 } 4181 } 4182 } 4183 // Mark the class as loaded. 4184 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, nullptr); 4185 return true; 4186} 4187 4188bool ClassLinker::LinkSuperClass(Handle<mirror::Class> klass) { 4189 CHECK(!klass->IsPrimitive()); 4190 mirror::Class* super = klass->GetSuperClass(); 4191 if (klass.Get() == GetClassRoot(kJavaLangObject)) { 4192 if (super != nullptr) { 4193 ThrowClassFormatError(klass.Get(), "java.lang.Object must not have a superclass"); 4194 return false; 4195 } 4196 return true; 4197 } 4198 if (super == nullptr) { 4199 ThrowLinkageError(klass.Get(), "No superclass defined for class %s", 4200 PrettyDescriptor(klass.Get()).c_str()); 4201 return false; 4202 } 4203 // Verify 4204 if (super->IsFinal() || super->IsInterface()) { 4205 ThrowIncompatibleClassChangeError(klass.Get(), "Superclass %s of %s is %s", 4206 PrettyDescriptor(super).c_str(), 4207 PrettyDescriptor(klass.Get()).c_str(), 4208 super->IsFinal() ? "declared final" : "an interface"); 4209 return false; 4210 } 4211 if (!klass->CanAccess(super)) { 4212 ThrowIllegalAccessError(klass.Get(), "Superclass %s is inaccessible to class %s", 4213 PrettyDescriptor(super).c_str(), 4214 PrettyDescriptor(klass.Get()).c_str()); 4215 return false; 4216 } 4217 4218 // Inherit kAccClassIsFinalizable from the superclass in case this 4219 // class doesn't override finalize. 4220 if (super->IsFinalizable()) { 4221 klass->SetFinalizable(); 4222 } 4223 4224 // Inherit reference flags (if any) from the superclass. 4225 int reference_flags = (super->GetAccessFlags() & kAccReferenceFlagsMask); 4226 if (reference_flags != 0) { 4227 klass->SetAccessFlags(klass->GetAccessFlags() | reference_flags); 4228 } 4229 // Disallow custom direct subclasses of java.lang.ref.Reference. 4230 if (init_done_ && super == GetClassRoot(kJavaLangRefReference)) { 4231 ThrowLinkageError(klass.Get(), 4232 "Class %s attempts to subclass java.lang.ref.Reference, which is not allowed", 4233 PrettyDescriptor(klass.Get()).c_str()); 4234 return false; 4235 } 4236 4237 if (kIsDebugBuild) { 4238 // Ensure super classes are fully resolved prior to resolving fields.. 4239 while (super != nullptr) { 4240 CHECK(super->IsResolved()); 4241 super = super->GetSuperClass(); 4242 } 4243 } 4244 return true; 4245} 4246 4247// Populate the class vtable and itable. Compute return type indices. 4248bool ClassLinker::LinkMethods(Thread* self, Handle<mirror::Class> klass, 4249 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 4250 StackHandleScope<mirror::Class::kImtSize>* out_imt) { 4251 self->AllowThreadSuspension(); 4252 if (klass->IsInterface()) { 4253 // No vtable. 4254 size_t count = klass->NumVirtualMethods(); 4255 if (!IsUint<16>(count)) { 4256 ThrowClassFormatError(klass.Get(), "Too many methods on interface: %zd", count); 4257 return false; 4258 } 4259 for (size_t i = 0; i < count; ++i) { 4260 klass->GetVirtualMethodDuringLinking(i)->SetMethodIndex(i); 4261 } 4262 } else if (!LinkVirtualMethods(self, klass)) { // Link virtual methods first. 4263 return false; 4264 } 4265 return LinkInterfaceMethods(self, klass, interfaces, out_imt); // Link interface method last. 4266} 4267 4268// Comparator for name and signature of a method, used in finding overriding methods. Implementation 4269// avoids the use of handles, if it didn't then rather than compare dex files we could compare dex 4270// caches in the implementation below. 4271class MethodNameAndSignatureComparator FINAL : public ValueObject { 4272 public: 4273 explicit MethodNameAndSignatureComparator(mirror::ArtMethod* method) 4274 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) : 4275 dex_file_(method->GetDexFile()), mid_(&dex_file_->GetMethodId(method->GetDexMethodIndex())), 4276 name_(nullptr), name_len_(0) { 4277 DCHECK(!method->IsProxyMethod()) << PrettyMethod(method); 4278 } 4279 4280 const char* GetName() { 4281 if (name_ == nullptr) { 4282 name_ = dex_file_->StringDataAndUtf16LengthByIdx(mid_->name_idx_, &name_len_); 4283 } 4284 return name_; 4285 } 4286 4287 bool HasSameNameAndSignature(mirror::ArtMethod* other) 4288 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 4289 DCHECK(!other->IsProxyMethod()) << PrettyMethod(other); 4290 const DexFile* other_dex_file = other->GetDexFile(); 4291 const DexFile::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex()); 4292 if (dex_file_ == other_dex_file) { 4293 return mid_->name_idx_ == other_mid.name_idx_ && mid_->proto_idx_ == other_mid.proto_idx_; 4294 } 4295 GetName(); // Only used to make sure its calculated. 4296 uint32_t other_name_len; 4297 const char* other_name = other_dex_file->StringDataAndUtf16LengthByIdx(other_mid.name_idx_, 4298 &other_name_len); 4299 if (name_len_ != other_name_len || strcmp(name_, other_name) != 0) { 4300 return false; 4301 } 4302 return dex_file_->GetMethodSignature(*mid_) == other_dex_file->GetMethodSignature(other_mid); 4303 } 4304 4305 private: 4306 // Dex file for the method to compare against. 4307 const DexFile* const dex_file_; 4308 // MethodId for the method to compare against. 4309 const DexFile::MethodId* const mid_; 4310 // Lazily computed name from the dex file's strings. 4311 const char* name_; 4312 // Lazily computed name length. 4313 uint32_t name_len_; 4314}; 4315 4316class LinkVirtualHashTable { 4317 public: 4318 LinkVirtualHashTable(Handle<mirror::Class> klass, size_t hash_size, uint32_t* hash_table) 4319 : klass_(klass), hash_size_(hash_size), hash_table_(hash_table) { 4320 std::fill(hash_table_, hash_table_ + hash_size_, invalid_index_); 4321 } 4322 void Add(uint32_t virtual_method_index) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 4323 mirror::ArtMethod* local_method = klass_->GetVirtualMethodDuringLinking(virtual_method_index); 4324 const char* name = local_method->GetName(); 4325 uint32_t hash = ComputeModifiedUtf8Hash(name); 4326 uint32_t index = hash % hash_size_; 4327 // Linear probe until we have an empty slot. 4328 while (hash_table_[index] != invalid_index_) { 4329 if (++index == hash_size_) { 4330 index = 0; 4331 } 4332 } 4333 hash_table_[index] = virtual_method_index; 4334 } 4335 uint32_t FindAndRemove(MethodNameAndSignatureComparator* comparator) 4336 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 4337 const char* name = comparator->GetName(); 4338 uint32_t hash = ComputeModifiedUtf8Hash(name); 4339 size_t index = hash % hash_size_; 4340 while (true) { 4341 const uint32_t value = hash_table_[index]; 4342 // Since linear probe makes continuous blocks, hitting an invalid index means we are done 4343 // the block and can safely assume not found. 4344 if (value == invalid_index_) { 4345 break; 4346 } 4347 if (value != removed_index_) { // This signifies not already overriden. 4348 mirror::ArtMethod* virtual_method = 4349 klass_->GetVirtualMethodDuringLinking(value); 4350 if (comparator->HasSameNameAndSignature(virtual_method->GetInterfaceMethodIfProxy())) { 4351 hash_table_[index] = removed_index_; 4352 return value; 4353 } 4354 } 4355 if (++index == hash_size_) { 4356 index = 0; 4357 } 4358 } 4359 return GetNotFoundIndex(); 4360 } 4361 static uint32_t GetNotFoundIndex() { 4362 return invalid_index_; 4363 } 4364 4365 private: 4366 static const uint32_t invalid_index_; 4367 static const uint32_t removed_index_; 4368 4369 Handle<mirror::Class> klass_; 4370 const size_t hash_size_; 4371 uint32_t* const hash_table_; 4372}; 4373 4374const uint32_t LinkVirtualHashTable::invalid_index_ = std::numeric_limits<uint32_t>::max(); 4375const uint32_t LinkVirtualHashTable::removed_index_ = std::numeric_limits<uint32_t>::max() - 1; 4376 4377bool ClassLinker::LinkVirtualMethods(Thread* self, Handle<mirror::Class> klass) { 4378 const size_t num_virtual_methods = klass->NumVirtualMethods(); 4379 if (klass->HasSuperClass()) { 4380 const size_t super_vtable_length = klass->GetSuperClass()->GetVTableLength(); 4381 const size_t max_count = num_virtual_methods + super_vtable_length; 4382 StackHandleScope<2> hs(self); 4383 Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass())); 4384 MutableHandle<mirror::ObjectArray<mirror::ArtMethod>> vtable; 4385 if (super_class->ShouldHaveEmbeddedImtAndVTable()) { 4386 vtable = hs.NewHandle(AllocArtMethodArray(self, max_count)); 4387 if (UNLIKELY(vtable.Get() == nullptr)) { 4388 CHECK(self->IsExceptionPending()); // OOME. 4389 return false; 4390 } 4391 for (size_t i = 0; i < super_vtable_length; i++) { 4392 vtable->SetWithoutChecks<false>(i, super_class->GetEmbeddedVTableEntry(i)); 4393 } 4394 if (num_virtual_methods == 0) { 4395 klass->SetVTable(vtable.Get()); 4396 return true; 4397 } 4398 } else { 4399 mirror::ObjectArray<mirror::ArtMethod>* super_vtable = super_class->GetVTable(); 4400 CHECK(super_vtable != nullptr) << PrettyClass(super_class.Get()); 4401 if (num_virtual_methods == 0) { 4402 klass->SetVTable(super_vtable); 4403 return true; 4404 } 4405 vtable = hs.NewHandle(super_vtable->CopyOf(self, max_count)); 4406 if (UNLIKELY(vtable.Get() == nullptr)) { 4407 CHECK(self->IsExceptionPending()); // OOME. 4408 return false; 4409 } 4410 } 4411 // How the algorithm works: 4412 // 1. Populate hash table by adding num_virtual_methods from klass. The values in the hash 4413 // table are: invalid_index for unused slots, index super_vtable_length + i for a virtual 4414 // method which has not been matched to a vtable method, and j if the virtual method at the 4415 // index overrode the super virtual method at index j. 4416 // 2. Loop through super virtual methods, if they overwrite, update hash table to j 4417 // (j < super_vtable_length) to avoid redundant checks. (TODO maybe use this info for reducing 4418 // the need for the initial vtable which we later shrink back down). 4419 // 3. Add non overridden methods to the end of the vtable. 4420 static constexpr size_t kMaxStackHash = 250; 4421 const size_t hash_table_size = num_virtual_methods * 3; 4422 uint32_t* hash_table_ptr; 4423 std::unique_ptr<uint32_t[]> hash_heap_storage; 4424 if (hash_table_size <= kMaxStackHash) { 4425 hash_table_ptr = reinterpret_cast<uint32_t*>( 4426 alloca(hash_table_size * sizeof(*hash_table_ptr))); 4427 } else { 4428 hash_heap_storage.reset(new uint32_t[hash_table_size]); 4429 hash_table_ptr = hash_heap_storage.get(); 4430 } 4431 LinkVirtualHashTable hash_table(klass, hash_table_size, hash_table_ptr); 4432 // Add virtual methods to the hash table. 4433 for (size_t i = 0; i < num_virtual_methods; ++i) { 4434 hash_table.Add(i); 4435 } 4436 // Loop through each super vtable method and see if they are overriden by a method we added to 4437 // the hash table. 4438 for (size_t j = 0; j < super_vtable_length; ++j) { 4439 // Search the hash table to see if we are overidden by any method. 4440 mirror::ArtMethod* super_method = vtable->GetWithoutChecks(j); 4441 MethodNameAndSignatureComparator super_method_name_comparator( 4442 super_method->GetInterfaceMethodIfProxy()); 4443 uint32_t hash_index = hash_table.FindAndRemove(&super_method_name_comparator); 4444 if (hash_index != hash_table.GetNotFoundIndex()) { 4445 mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(hash_index); 4446 if (klass->CanAccessMember(super_method->GetDeclaringClass(), 4447 super_method->GetAccessFlags())) { 4448 if (super_method->IsFinal()) { 4449 ThrowLinkageError(klass.Get(), "Method %s overrides final method in class %s", 4450 PrettyMethod(virtual_method).c_str(), 4451 super_method->GetDeclaringClassDescriptor()); 4452 return false; 4453 } 4454 vtable->SetWithoutChecks<false>(j, virtual_method); 4455 virtual_method->SetMethodIndex(j); 4456 } else { 4457 LOG(WARNING) << "Before Android 4.1, method " << PrettyMethod(virtual_method) 4458 << " would have incorrectly overridden the package-private method in " 4459 << PrettyDescriptor(super_method->GetDeclaringClassDescriptor()); 4460 } 4461 } 4462 } 4463 // Add the non overridden methods at the end. 4464 size_t actual_count = super_vtable_length; 4465 for (size_t i = 0; i < num_virtual_methods; ++i) { 4466 mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i); 4467 size_t method_idx = local_method->GetMethodIndexDuringLinking(); 4468 if (method_idx < super_vtable_length && 4469 local_method == vtable->GetWithoutChecks(method_idx)) { 4470 continue; 4471 } 4472 vtable->SetWithoutChecks<false>(actual_count, local_method); 4473 local_method->SetMethodIndex(actual_count); 4474 ++actual_count; 4475 } 4476 if (!IsUint<16>(actual_count)) { 4477 ThrowClassFormatError(klass.Get(), "Too many methods defined on class: %zd", actual_count); 4478 return false; 4479 } 4480 // Shrink vtable if possible 4481 CHECK_LE(actual_count, max_count); 4482 if (actual_count < max_count) { 4483 vtable.Assign(vtable->CopyOf(self, actual_count)); 4484 if (UNLIKELY(vtable.Get() == nullptr)) { 4485 CHECK(self->IsExceptionPending()); // OOME. 4486 return false; 4487 } 4488 } 4489 klass->SetVTable(vtable.Get()); 4490 } else { 4491 CHECK_EQ(klass.Get(), GetClassRoot(kJavaLangObject)); 4492 if (!IsUint<16>(num_virtual_methods)) { 4493 ThrowClassFormatError(klass.Get(), "Too many methods: %d", 4494 static_cast<int>(num_virtual_methods)); 4495 return false; 4496 } 4497 mirror::ObjectArray<mirror::ArtMethod>* vtable = AllocArtMethodArray(self, num_virtual_methods); 4498 if (UNLIKELY(vtable == nullptr)) { 4499 CHECK(self->IsExceptionPending()); // OOME. 4500 return false; 4501 } 4502 for (size_t i = 0; i < num_virtual_methods; ++i) { 4503 mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i); 4504 vtable->SetWithoutChecks<false>(i, virtual_method); 4505 virtual_method->SetMethodIndex(i & 0xFFFF); 4506 } 4507 klass->SetVTable(vtable); 4508 } 4509 return true; 4510} 4511 4512bool ClassLinker::LinkInterfaceMethods(Thread* self, Handle<mirror::Class> klass, 4513 Handle<mirror::ObjectArray<mirror::Class>> interfaces, 4514 StackHandleScope<mirror::Class::kImtSize>* out_imt) { 4515 StackHandleScope<3> hs(self); 4516 Runtime* const runtime = Runtime::Current(); 4517 const bool has_superclass = klass->HasSuperClass(); 4518 const size_t super_ifcount = has_superclass ? klass->GetSuperClass()->GetIfTableCount() : 0U; 4519 const bool have_interfaces = interfaces.Get() != nullptr; 4520 const size_t num_interfaces = 4521 have_interfaces ? interfaces->GetLength() : klass->NumDirectInterfaces(); 4522 if (num_interfaces == 0) { 4523 if (super_ifcount == 0) { 4524 // Class implements no interfaces. 4525 DCHECK_EQ(klass->GetIfTableCount(), 0); 4526 DCHECK(klass->GetIfTable() == nullptr); 4527 return true; 4528 } 4529 // Class implements same interfaces as parent, are any of these not marker interfaces? 4530 bool has_non_marker_interface = false; 4531 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable(); 4532 for (size_t i = 0; i < super_ifcount; ++i) { 4533 if (super_iftable->GetMethodArrayCount(i) > 0) { 4534 has_non_marker_interface = true; 4535 break; 4536 } 4537 } 4538 // Class just inherits marker interfaces from parent so recycle parent's iftable. 4539 if (!has_non_marker_interface) { 4540 klass->SetIfTable(super_iftable); 4541 return true; 4542 } 4543 } 4544 size_t ifcount = super_ifcount + num_interfaces; 4545 for (size_t i = 0; i < num_interfaces; i++) { 4546 mirror::Class* interface = have_interfaces ? 4547 interfaces->GetWithoutChecks(i) : mirror::Class::GetDirectInterface(self, klass, i); 4548 DCHECK(interface != nullptr); 4549 if (UNLIKELY(!interface->IsInterface())) { 4550 std::string temp; 4551 ThrowIncompatibleClassChangeError(klass.Get(), "Class %s implements non-interface class %s", 4552 PrettyDescriptor(klass.Get()).c_str(), 4553 PrettyDescriptor(interface->GetDescriptor(&temp)).c_str()); 4554 return false; 4555 } 4556 ifcount += interface->GetIfTableCount(); 4557 } 4558 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount))); 4559 if (UNLIKELY(iftable.Get() == nullptr)) { 4560 CHECK(self->IsExceptionPending()); // OOME. 4561 return false; 4562 } 4563 if (super_ifcount != 0) { 4564 mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable(); 4565 for (size_t i = 0; i < super_ifcount; i++) { 4566 mirror::Class* super_interface = super_iftable->GetInterface(i); 4567 iftable->SetInterface(i, super_interface); 4568 } 4569 } 4570 self->AllowThreadSuspension(); 4571 // Flatten the interface inheritance hierarchy. 4572 size_t idx = super_ifcount; 4573 for (size_t i = 0; i < num_interfaces; i++) { 4574 mirror::Class* interface = have_interfaces ? interfaces->Get(i) : 4575 mirror::Class::GetDirectInterface(self, klass, i); 4576 // Check if interface is already in iftable 4577 bool duplicate = false; 4578 for (size_t j = 0; j < idx; j++) { 4579 mirror::Class* existing_interface = iftable->GetInterface(j); 4580 if (existing_interface == interface) { 4581 duplicate = true; 4582 break; 4583 } 4584 } 4585 if (!duplicate) { 4586 // Add this non-duplicate interface. 4587 iftable->SetInterface(idx++, interface); 4588 // Add this interface's non-duplicate super-interfaces. 4589 for (int32_t j = 0; j < interface->GetIfTableCount(); j++) { 4590 mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j); 4591 bool super_duplicate = false; 4592 for (size_t k = 0; k < idx; k++) { 4593 mirror::Class* existing_interface = iftable->GetInterface(k); 4594 if (existing_interface == super_interface) { 4595 super_duplicate = true; 4596 break; 4597 } 4598 } 4599 if (!super_duplicate) { 4600 iftable->SetInterface(idx++, super_interface); 4601 } 4602 } 4603 } 4604 } 4605 self->AllowThreadSuspension(); 4606 // Shrink iftable in case duplicates were found 4607 if (idx < ifcount) { 4608 DCHECK_NE(num_interfaces, 0U); 4609 iftable.Assign(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax))); 4610 if (UNLIKELY(iftable.Get() == nullptr)) { 4611 CHECK(self->IsExceptionPending()); // OOME. 4612 return false; 4613 } 4614 ifcount = idx; 4615 } else { 4616 DCHECK_EQ(idx, ifcount); 4617 } 4618 klass->SetIfTable(iftable.Get()); 4619 // If we're an interface, we don't need the vtable pointers, so we're done. 4620 if (klass->IsInterface()) { 4621 return true; 4622 } 4623 size_t miranda_list_size = 0; 4624 size_t max_miranda_methods = 0; // The max size of miranda_list. 4625 for (size_t i = 0; i < ifcount; ++i) { 4626 max_miranda_methods += iftable->GetInterface(i)->NumVirtualMethods(); 4627 } 4628 MutableHandle<mirror::ObjectArray<mirror::ArtMethod>> 4629 miranda_list(hs.NewHandle(AllocArtMethodArray(self, max_miranda_methods))); 4630 MutableHandle<mirror::ObjectArray<mirror::ArtMethod>> vtable( 4631 hs.NewHandle(klass->GetVTableDuringLinking())); 4632 // Copy the IMT from the super class if possible. 4633 bool extend_super_iftable = false; 4634 if (has_superclass) { 4635 mirror::Class* super_class = klass->GetSuperClass(); 4636 extend_super_iftable = true; 4637 if (super_class->ShouldHaveEmbeddedImtAndVTable()) { 4638 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) { 4639 out_imt->SetReference(i, super_class->GetEmbeddedImTableEntry(i)); 4640 } 4641 } else { 4642 // No imt in the super class, need to reconstruct from the iftable. 4643 mirror::IfTable* if_table = super_class->GetIfTable(); 4644 mirror::ArtMethod* conflict_method = runtime->GetImtConflictMethod(); 4645 const size_t length = super_class->GetIfTableCount(); 4646 for (size_t i = 0; i < length; ++i) { 4647 mirror::Class* interface = iftable->GetInterface(i); 4648 const size_t num_virtuals = interface->NumVirtualMethods(); 4649 const size_t method_array_count = if_table->GetMethodArrayCount(i); 4650 DCHECK_EQ(num_virtuals, method_array_count); 4651 if (method_array_count == 0) { 4652 continue; 4653 } 4654 mirror::ObjectArray<mirror::ArtMethod>* method_array = if_table->GetMethodArray(i); 4655 for (size_t j = 0; j < num_virtuals; ++j) { 4656 mirror::ArtMethod* method = method_array->GetWithoutChecks(j); 4657 if (method->IsMiranda()) { 4658 continue; 4659 } 4660 mirror::ArtMethod* interface_method = interface->GetVirtualMethod(j); 4661 uint32_t imt_index = interface_method->GetDexMethodIndex() % mirror::Class::kImtSize; 4662 mirror::ArtMethod* imt_ref = out_imt->GetReference(imt_index)->AsArtMethod(); 4663 if (imt_ref == runtime->GetImtUnimplementedMethod()) { 4664 out_imt->SetReference(imt_index, method); 4665 } else if (imt_ref != conflict_method) { 4666 out_imt->SetReference(imt_index, conflict_method); 4667 } 4668 } 4669 } 4670 } 4671 } 4672 for (size_t i = 0; i < ifcount; ++i) { 4673 self->AllowThreadSuspension(); 4674 size_t num_methods = iftable->GetInterface(i)->NumVirtualMethods(); 4675 if (num_methods > 0) { 4676 StackHandleScope<2> hs2(self); 4677 const bool is_super = i < super_ifcount; 4678 const bool super_interface = is_super && extend_super_iftable; 4679 Handle<mirror::ObjectArray<mirror::ArtMethod>> method_array; 4680 Handle<mirror::ObjectArray<mirror::ArtMethod>> input_array; 4681 if (super_interface) { 4682 mirror::IfTable* if_table = klass->GetSuperClass()->GetIfTable(); 4683 DCHECK(if_table != nullptr); 4684 DCHECK(if_table->GetMethodArray(i) != nullptr); 4685 // If we are working on a super interface, try extending the existing method array. 4686 method_array = hs2.NewHandle(if_table->GetMethodArray(i)->Clone(self)-> 4687 AsObjectArray<mirror::ArtMethod>()); 4688 // We are overwriting a super class interface, try to only virtual methods instead of the 4689 // whole vtable. 4690 input_array = hs2.NewHandle(klass->GetVirtualMethods()); 4691 } else { 4692 method_array = hs2.NewHandle(AllocArtMethodArray(self, num_methods)); 4693 // A new interface, we need the whole vtable incase a new interface method is implemented 4694 // in the whole superclass. 4695 input_array = vtable; 4696 } 4697 if (UNLIKELY(method_array.Get() == nullptr)) { 4698 CHECK(self->IsExceptionPending()); // OOME. 4699 return false; 4700 } 4701 iftable->SetMethodArray(i, method_array.Get()); 4702 if (input_array.Get() == nullptr) { 4703 // If the added virtual methods is empty, do nothing. 4704 DCHECK(super_interface); 4705 continue; 4706 } 4707 for (size_t j = 0; j < num_methods; ++j) { 4708 mirror::ArtMethod* interface_method = iftable->GetInterface(i)->GetVirtualMethod(j); 4709 MethodNameAndSignatureComparator interface_name_comparator( 4710 interface_method->GetInterfaceMethodIfProxy()); 4711 int32_t k; 4712 // For each method listed in the interface's method list, find the 4713 // matching method in our class's method list. We want to favor the 4714 // subclass over the superclass, which just requires walking 4715 // back from the end of the vtable. (This only matters if the 4716 // superclass defines a private method and this class redefines 4717 // it -- otherwise it would use the same vtable slot. In .dex files 4718 // those don't end up in the virtual method table, so it shouldn't 4719 // matter which direction we go. We walk it backward anyway.) 4720 for (k = input_array->GetLength() - 1; k >= 0; --k) { 4721 mirror::ArtMethod* vtable_method = input_array->GetWithoutChecks(k); 4722 mirror::ArtMethod* vtable_method_for_name_comparison = 4723 vtable_method->GetInterfaceMethodIfProxy(); 4724 if (interface_name_comparator.HasSameNameAndSignature( 4725 vtable_method_for_name_comparison)) { 4726 if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) { 4727 ThrowIllegalAccessError( 4728 klass.Get(), 4729 "Method '%s' implementing interface method '%s' is not public", 4730 PrettyMethod(vtable_method).c_str(), 4731 PrettyMethod(interface_method).c_str()); 4732 return false; 4733 } 4734 method_array->SetWithoutChecks<false>(j, vtable_method); 4735 // Place method in imt if entry is empty, place conflict otherwise. 4736 uint32_t imt_index = interface_method->GetDexMethodIndex() % mirror::Class::kImtSize; 4737 mirror::ArtMethod* imt_ref = out_imt->GetReference(imt_index)->AsArtMethod(); 4738 mirror::ArtMethod* conflict_method = runtime->GetImtConflictMethod(); 4739 if (imt_ref == runtime->GetImtUnimplementedMethod()) { 4740 out_imt->SetReference(imt_index, vtable_method); 4741 } else if (imt_ref != conflict_method) { 4742 // If we are not a conflict and we have the same signature and name as the imt entry, 4743 // it must be that we overwrote a superclass vtable entry. 4744 MethodNameAndSignatureComparator imt_ref_name_comparator( 4745 imt_ref->GetInterfaceMethodIfProxy()); 4746 if (imt_ref_name_comparator.HasSameNameAndSignature( 4747 vtable_method_for_name_comparison)) { 4748 out_imt->SetReference(imt_index, vtable_method); 4749 } else { 4750 out_imt->SetReference(imt_index, conflict_method); 4751 } 4752 } 4753 break; 4754 } 4755 } 4756 if (k < 0 && !super_interface) { 4757 mirror::ArtMethod* miranda_method = nullptr; 4758 for (size_t l = 0; l < miranda_list_size; ++l) { 4759 mirror::ArtMethod* mir_method = miranda_list->Get(l); 4760 if (interface_name_comparator.HasSameNameAndSignature(mir_method)) { 4761 miranda_method = mir_method; 4762 break; 4763 } 4764 } 4765 if (miranda_method == nullptr) { 4766 // Point the interface table at a phantom slot. 4767 miranda_method = interface_method->Clone(self)->AsArtMethod(); 4768 if (UNLIKELY(miranda_method == nullptr)) { 4769 CHECK(self->IsExceptionPending()); // OOME. 4770 return false; 4771 } 4772 DCHECK_LT(miranda_list_size, max_miranda_methods); 4773 miranda_list->Set<false>(miranda_list_size++, miranda_method); 4774 } 4775 method_array->SetWithoutChecks<false>(j, miranda_method); 4776 } 4777 } 4778 } 4779 } 4780 if (miranda_list_size > 0) { 4781 int old_method_count = klass->NumVirtualMethods(); 4782 int new_method_count = old_method_count + miranda_list_size; 4783 mirror::ObjectArray<mirror::ArtMethod>* virtuals; 4784 if (old_method_count == 0) { 4785 virtuals = AllocArtMethodArray(self, new_method_count); 4786 } else { 4787 virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count); 4788 } 4789 if (UNLIKELY(virtuals == nullptr)) { 4790 CHECK(self->IsExceptionPending()); // OOME. 4791 return false; 4792 } 4793 klass->SetVirtualMethods(virtuals); 4794 4795 int old_vtable_count = vtable->GetLength(); 4796 int new_vtable_count = old_vtable_count + miranda_list_size; 4797 vtable.Assign(vtable->CopyOf(self, new_vtable_count)); 4798 if (UNLIKELY(vtable.Get() == nullptr)) { 4799 CHECK(self->IsExceptionPending()); // OOME. 4800 return false; 4801 } 4802 for (size_t i = 0; i < miranda_list_size; ++i) { 4803 mirror::ArtMethod* method = miranda_list->Get(i); 4804 // Leave the declaring class alone as type indices are relative to it 4805 method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda); 4806 method->SetMethodIndex(0xFFFF & (old_vtable_count + i)); 4807 klass->SetVirtualMethod(old_method_count + i, method); 4808 vtable->SetWithoutChecks<false>(old_vtable_count + i, method); 4809 } 4810 // TODO: do not assign to the vtable field until it is fully constructed. 4811 klass->SetVTable(vtable.Get()); 4812 } 4813 4814 if (kIsDebugBuild) { 4815 mirror::ObjectArray<mirror::ArtMethod>* check_vtable = klass->GetVTableDuringLinking(); 4816 for (int i = 0; i < check_vtable->GetLength(); ++i) { 4817 CHECK(check_vtable->GetWithoutChecks(i) != nullptr); 4818 } 4819 } 4820 4821 self->AllowThreadSuspension(); 4822 return true; 4823} 4824 4825bool ClassLinker::LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) { 4826 CHECK(klass.Get() != nullptr); 4827 return LinkFields(self, klass, false, nullptr); 4828} 4829 4830bool ClassLinker::LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) { 4831 CHECK(klass.Get() != nullptr); 4832 return LinkFields(self, klass, true, class_size); 4833} 4834 4835struct LinkFieldsComparator { 4836 explicit LinkFieldsComparator() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 4837 } 4838 // No thread safety analysis as will be called from STL. Checked lock held in constructor. 4839 bool operator()(ArtField* field1, ArtField* field2) 4840 NO_THREAD_SAFETY_ANALYSIS { 4841 // First come reference fields, then 64-bit, then 32-bit, and then 16-bit, then finally 8-bit. 4842 Primitive::Type type1 = field1->GetTypeAsPrimitiveType(); 4843 Primitive::Type type2 = field2->GetTypeAsPrimitiveType(); 4844 if (type1 != type2) { 4845 if (type1 == Primitive::kPrimNot) { 4846 // Reference always goes first. 4847 return true; 4848 } 4849 if (type2 == Primitive::kPrimNot) { 4850 // Reference always goes first. 4851 return false; 4852 } 4853 size_t size1 = Primitive::ComponentSize(type1); 4854 size_t size2 = Primitive::ComponentSize(type2); 4855 if (size1 != size2) { 4856 // Larger primitive types go first. 4857 return size1 > size2; 4858 } 4859 // Primitive types differ but sizes match. Arbitrarily order by primitive type. 4860 return type1 < type2; 4861 } 4862 // Same basic group? Then sort by dex field index. This is guaranteed to be sorted 4863 // by name and for equal names by type id index. 4864 // NOTE: This works also for proxies. Their static fields are assigned appropriate indexes. 4865 return field1->GetDexFieldIndex() < field2->GetDexFieldIndex(); 4866 } 4867}; 4868 4869bool ClassLinker::LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, 4870 size_t* class_size) { 4871 self->AllowThreadSuspension(); 4872 const size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields(); 4873 ArtField* const fields = is_static ? klass->GetSFields() : klass->GetIFields(); 4874 4875 // Initialize field_offset 4876 MemberOffset field_offset(0); 4877 if (is_static) { 4878 field_offset = klass->GetFirstReferenceStaticFieldOffsetDuringLinking(); 4879 } else { 4880 mirror::Class* super_class = klass->GetSuperClass(); 4881 if (super_class != nullptr) { 4882 CHECK(super_class->IsResolved()) 4883 << PrettyClass(klass.Get()) << " " << PrettyClass(super_class); 4884 field_offset = MemberOffset(super_class->GetObjectSize()); 4885 } 4886 } 4887 4888 CHECK_EQ(num_fields == 0, fields == nullptr) << PrettyClass(klass.Get()); 4889 4890 // we want a relatively stable order so that adding new fields 4891 // minimizes disruption of C++ version such as Class and Method. 4892 std::deque<ArtField*> grouped_and_sorted_fields; 4893 const char* old_no_suspend_cause = self->StartAssertNoThreadSuspension( 4894 "Naked ArtField references in deque"); 4895 for (size_t i = 0; i < num_fields; i++) { 4896 grouped_and_sorted_fields.push_back(&fields[i]); 4897 } 4898 std::sort(grouped_and_sorted_fields.begin(), grouped_and_sorted_fields.end(), 4899 LinkFieldsComparator()); 4900 4901 // References should be at the front. 4902 size_t current_field = 0; 4903 size_t num_reference_fields = 0; 4904 FieldGaps gaps; 4905 4906 for (; current_field < num_fields; current_field++) { 4907 ArtField* field = grouped_and_sorted_fields.front(); 4908 Primitive::Type type = field->GetTypeAsPrimitiveType(); 4909 bool isPrimitive = type != Primitive::kPrimNot; 4910 if (isPrimitive) { 4911 break; // past last reference, move on to the next phase 4912 } 4913 if (UNLIKELY(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>( 4914 field_offset.Uint32Value()))) { 4915 MemberOffset old_offset = field_offset; 4916 field_offset = MemberOffset(RoundUp(field_offset.Uint32Value(), 4)); 4917 AddFieldGap(old_offset.Uint32Value(), field_offset.Uint32Value(), &gaps); 4918 } 4919 DCHECK(IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(field_offset.Uint32Value())); 4920 grouped_and_sorted_fields.pop_front(); 4921 num_reference_fields++; 4922 field->SetOffset(field_offset); 4923 field_offset = MemberOffset(field_offset.Uint32Value() + 4924 sizeof(mirror::HeapReference<mirror::Object>)); 4925 } 4926 // Gaps are stored as a max heap which means that we must shuffle from largest to smallest 4927 // otherwise we could end up with suboptimal gap fills. 4928 ShuffleForward<8>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 4929 ShuffleForward<4>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 4930 ShuffleForward<2>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 4931 ShuffleForward<1>(¤t_field, &field_offset, &grouped_and_sorted_fields, &gaps); 4932 CHECK(grouped_and_sorted_fields.empty()) << "Missed " << grouped_and_sorted_fields.size() << 4933 " fields."; 4934 self->EndAssertNoThreadSuspension(old_no_suspend_cause); 4935 4936 // We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it. 4937 if (!is_static && klass->DescriptorEquals("Ljava/lang/ref/Reference;")) { 4938 // We know there are no non-reference fields in the Reference classes, and we know 4939 // that 'referent' is alphabetically last, so this is easy... 4940 CHECK_EQ(num_reference_fields, num_fields) << PrettyClass(klass.Get()); 4941 CHECK_STREQ(fields[num_fields - 1].GetName(), "referent") << PrettyClass(klass.Get()); 4942 --num_reference_fields; 4943 } 4944 4945 size_t size = field_offset.Uint32Value(); 4946 // Update klass 4947 if (is_static) { 4948 klass->SetNumReferenceStaticFields(num_reference_fields); 4949 *class_size = size; 4950 } else { 4951 klass->SetNumReferenceInstanceFields(num_reference_fields); 4952 if (!klass->IsVariableSize()) { 4953 if (klass->DescriptorEquals("Ljava/lang/reflect/ArtMethod;")) { 4954 size_t pointer_size = GetInstructionSetPointerSize(Runtime::Current()->GetInstructionSet()); 4955 klass->SetObjectSize(mirror::ArtMethod::InstanceSize(pointer_size)); 4956 } else { 4957 std::string temp; 4958 DCHECK_GE(size, sizeof(mirror::Object)) << klass->GetDescriptor(&temp); 4959 size_t previous_size = klass->GetObjectSize(); 4960 if (previous_size != 0) { 4961 // Make sure that we didn't originally have an incorrect size. 4962 CHECK_EQ(previous_size, size) << klass->GetDescriptor(&temp); 4963 } 4964 klass->SetObjectSize(size); 4965 } 4966 } 4967 } 4968 4969 if (kIsDebugBuild) { 4970 // Make sure that the fields array is ordered by name but all reference 4971 // offsets are at the beginning as far as alignment allows. 4972 MemberOffset start_ref_offset = is_static 4973 ? klass->GetFirstReferenceStaticFieldOffsetDuringLinking() 4974 : klass->GetFirstReferenceInstanceFieldOffset(); 4975 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() + 4976 num_reference_fields * 4977 sizeof(mirror::HeapReference<mirror::Object>)); 4978 MemberOffset current_ref_offset = start_ref_offset; 4979 for (size_t i = 0; i < num_fields; i++) { 4980 ArtField* field = &fields[i]; 4981 VLOG(class_linker) << "LinkFields: " << (is_static ? "static" : "instance") 4982 << " class=" << PrettyClass(klass.Get()) << " field=" << PrettyField(field) << " offset=" 4983 << field->GetOffset(); 4984 if (i != 0) { 4985 ArtField* const prev_field = &fields[i - 1]; 4986 // NOTE: The field names can be the same. This is not possible in the Java language 4987 // but it's valid Java/dex bytecode and for example proguard can generate such bytecode. 4988 CHECK_LE(strcmp(prev_field->GetName(), field->GetName()), 0); 4989 } 4990 Primitive::Type type = field->GetTypeAsPrimitiveType(); 4991 bool is_primitive = type != Primitive::kPrimNot; 4992 if (klass->DescriptorEquals("Ljava/lang/ref/Reference;") && 4993 strcmp("referent", field->GetName()) == 0) { 4994 is_primitive = true; // We lied above, so we have to expect a lie here. 4995 } 4996 MemberOffset offset = field->GetOffsetDuringLinking(); 4997 if (is_primitive) { 4998 if (offset.Uint32Value() < end_ref_offset.Uint32Value()) { 4999 // Shuffled before references. 5000 size_t type_size = Primitive::ComponentSize(type); 5001 CHECK_LT(type_size, sizeof(mirror::HeapReference<mirror::Object>)); 5002 CHECK_LT(offset.Uint32Value(), start_ref_offset.Uint32Value()); 5003 CHECK_LE(offset.Uint32Value() + type_size, start_ref_offset.Uint32Value()); 5004 CHECK(!IsAligned<sizeof(mirror::HeapReference<mirror::Object>)>(offset.Uint32Value())); 5005 } 5006 } else { 5007 CHECK_EQ(current_ref_offset.Uint32Value(), offset.Uint32Value()); 5008 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() + 5009 sizeof(mirror::HeapReference<mirror::Object>)); 5010 } 5011 } 5012 CHECK_EQ(current_ref_offset.Uint32Value(), end_ref_offset.Uint32Value()); 5013 } 5014 return true; 5015} 5016 5017// Set the bitmap of reference instance field offsets. 5018void ClassLinker::CreateReferenceInstanceOffsets(Handle<mirror::Class> klass) { 5019 uint32_t reference_offsets = 0; 5020 mirror::Class* super_class = klass->GetSuperClass(); 5021 // Leave the reference offsets as 0 for mirror::Object (the class field is handled specially). 5022 if (super_class != nullptr) { 5023 reference_offsets = super_class->GetReferenceInstanceOffsets(); 5024 // Compute reference offsets unless our superclass overflowed. 5025 if (reference_offsets != mirror::Class::kClassWalkSuper) { 5026 size_t num_reference_fields = klass->NumReferenceInstanceFieldsDuringLinking(); 5027 if (num_reference_fields != 0u) { 5028 // All of the fields that contain object references are guaranteed be grouped in memory 5029 // starting at an appropriately aligned address after super class object data. 5030 uint32_t start_offset = RoundUp(super_class->GetObjectSize(), 5031 sizeof(mirror::HeapReference<mirror::Object>)); 5032 uint32_t start_bit = (start_offset - mirror::kObjectHeaderSize) / 5033 sizeof(mirror::HeapReference<mirror::Object>); 5034 if (start_bit + num_reference_fields > 32) { 5035 reference_offsets = mirror::Class::kClassWalkSuper; 5036 } else { 5037 reference_offsets |= (0xffffffffu << start_bit) & 5038 (0xffffffffu >> (32 - (start_bit + num_reference_fields))); 5039 } 5040 } 5041 } 5042 } 5043 klass->SetReferenceInstanceOffsets(reference_offsets); 5044} 5045 5046mirror::String* ClassLinker::ResolveString(const DexFile& dex_file, uint32_t string_idx, 5047 Handle<mirror::DexCache> dex_cache) { 5048 DCHECK(dex_cache.Get() != nullptr); 5049 mirror::String* resolved = dex_cache->GetResolvedString(string_idx); 5050 if (resolved != nullptr) { 5051 return resolved; 5052 } 5053 uint32_t utf16_length; 5054 const char* utf8_data = dex_file.StringDataAndUtf16LengthByIdx(string_idx, &utf16_length); 5055 mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data); 5056 dex_cache->SetResolvedString(string_idx, string); 5057 return string; 5058} 5059 5060mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx, 5061 mirror::Class* referrer) { 5062 StackHandleScope<2> hs(Thread::Current()); 5063 Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache())); 5064 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(referrer->GetClassLoader())); 5065 return ResolveType(dex_file, type_idx, dex_cache, class_loader); 5066} 5067 5068mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file, uint16_t type_idx, 5069 Handle<mirror::DexCache> dex_cache, 5070 Handle<mirror::ClassLoader> class_loader) { 5071 DCHECK(dex_cache.Get() != nullptr); 5072 mirror::Class* resolved = dex_cache->GetResolvedType(type_idx); 5073 if (resolved == nullptr) { 5074 Thread* self = Thread::Current(); 5075 const char* descriptor = dex_file.StringByTypeIdx(type_idx); 5076 resolved = FindClass(self, descriptor, class_loader); 5077 if (resolved != nullptr) { 5078 // TODO: we used to throw here if resolved's class loader was not the 5079 // boot class loader. This was to permit different classes with the 5080 // same name to be loaded simultaneously by different loaders 5081 dex_cache->SetResolvedType(type_idx, resolved); 5082 } else { 5083 CHECK(self->IsExceptionPending()) 5084 << "Expected pending exception for failed resolution of: " << descriptor; 5085 // Convert a ClassNotFoundException to a NoClassDefFoundError. 5086 StackHandleScope<1> hs(self); 5087 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException())); 5088 if (cause->InstanceOf(GetClassRoot(kJavaLangClassNotFoundException))) { 5089 DCHECK(resolved == nullptr); // No Handle needed to preserve resolved. 5090 self->ClearException(); 5091 ThrowNoClassDefFoundError("Failed resolution of: %s", descriptor); 5092 self->GetException()->SetCause(cause.Get()); 5093 } 5094 } 5095 } 5096 DCHECK((resolved == nullptr) || resolved->IsResolved() || resolved->IsErroneous()) 5097 << PrettyDescriptor(resolved) << " " << resolved->GetStatus(); 5098 return resolved; 5099} 5100 5101mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file, uint32_t method_idx, 5102 Handle<mirror::DexCache> dex_cache, 5103 Handle<mirror::ClassLoader> class_loader, 5104 Handle<mirror::ArtMethod> referrer, 5105 InvokeType type) { 5106 DCHECK(dex_cache.Get() != nullptr); 5107 // Check for hit in the dex cache. 5108 mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx); 5109 if (resolved != nullptr && !resolved->IsRuntimeMethod()) { 5110 return resolved; 5111 } 5112 // Fail, get the declaring class. 5113 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 5114 mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader); 5115 if (klass == nullptr) { 5116 DCHECK(Thread::Current()->IsExceptionPending()); 5117 return nullptr; 5118 } 5119 // Scan using method_idx, this saves string compares but will only hit for matching dex 5120 // caches/files. 5121 switch (type) { 5122 case kDirect: // Fall-through. 5123 case kStatic: 5124 resolved = klass->FindDirectMethod(dex_cache.Get(), method_idx); 5125 break; 5126 case kInterface: 5127 resolved = klass->FindInterfaceMethod(dex_cache.Get(), method_idx); 5128 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface()); 5129 break; 5130 case kSuper: // Fall-through. 5131 case kVirtual: 5132 resolved = klass->FindVirtualMethod(dex_cache.Get(), method_idx); 5133 break; 5134 default: 5135 LOG(FATAL) << "Unreachable - invocation type: " << type; 5136 UNREACHABLE(); 5137 } 5138 if (resolved == nullptr) { 5139 // Search by name, which works across dex files. 5140 const char* name = dex_file.StringDataByIdx(method_id.name_idx_); 5141 const Signature signature = dex_file.GetMethodSignature(method_id); 5142 switch (type) { 5143 case kDirect: // Fall-through. 5144 case kStatic: 5145 resolved = klass->FindDirectMethod(name, signature); 5146 break; 5147 case kInterface: 5148 resolved = klass->FindInterfaceMethod(name, signature); 5149 DCHECK(resolved == nullptr || resolved->GetDeclaringClass()->IsInterface()); 5150 break; 5151 case kSuper: // Fall-through. 5152 case kVirtual: 5153 resolved = klass->FindVirtualMethod(name, signature); 5154 break; 5155 } 5156 } 5157 // If we found a method, check for incompatible class changes. 5158 if (LIKELY(resolved != nullptr && !resolved->CheckIncompatibleClassChange(type))) { 5159 // Be a good citizen and update the dex cache to speed subsequent calls. 5160 dex_cache->SetResolvedMethod(method_idx, resolved); 5161 return resolved; 5162 } else { 5163 // If we had a method, it's an incompatible-class-change error. 5164 if (resolved != nullptr) { 5165 ThrowIncompatibleClassChangeError(type, resolved->GetInvokeType(), resolved, referrer.Get()); 5166 } else { 5167 // We failed to find the method which means either an access error, an incompatible class 5168 // change, or no such method. First try to find the method among direct and virtual methods. 5169 const char* name = dex_file.StringDataByIdx(method_id.name_idx_); 5170 const Signature signature = dex_file.GetMethodSignature(method_id); 5171 switch (type) { 5172 case kDirect: 5173 case kStatic: 5174 resolved = klass->FindVirtualMethod(name, signature); 5175 // Note: kDirect and kStatic are also mutually exclusive, but in that case we would 5176 // have had a resolved method before, which triggers the "true" branch above. 5177 break; 5178 case kInterface: 5179 case kVirtual: 5180 case kSuper: 5181 resolved = klass->FindDirectMethod(name, signature); 5182 break; 5183 } 5184 5185 // If we found something, check that it can be accessed by the referrer. 5186 bool exception_generated = false; 5187 if (resolved != nullptr && referrer.Get() != nullptr) { 5188 mirror::Class* methods_class = resolved->GetDeclaringClass(); 5189 mirror::Class* referring_class = referrer->GetDeclaringClass(); 5190 if (!referring_class->CanAccess(methods_class)) { 5191 ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class, 5192 resolved, type); 5193 exception_generated = true; 5194 } else if (!referring_class->CanAccessMember(methods_class, 5195 resolved->GetAccessFlags())) { 5196 ThrowIllegalAccessErrorMethod(referring_class, resolved); 5197 exception_generated = true; 5198 } 5199 } 5200 if (!exception_generated) { 5201 // Otherwise, throw an IncompatibleClassChangeError if we found something, and check 5202 // interface methods and throw if we find the method there. If we find nothing, throw a 5203 // NoSuchMethodError. 5204 switch (type) { 5205 case kDirect: 5206 case kStatic: 5207 if (resolved != nullptr) { 5208 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer.Get()); 5209 } else { 5210 resolved = klass->FindInterfaceMethod(name, signature); 5211 if (resolved != nullptr) { 5212 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer.Get()); 5213 } else { 5214 ThrowNoSuchMethodError(type, klass, name, signature); 5215 } 5216 } 5217 break; 5218 case kInterface: 5219 if (resolved != nullptr) { 5220 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer.Get()); 5221 } else { 5222 resolved = klass->FindVirtualMethod(name, signature); 5223 if (resolved != nullptr) { 5224 ThrowIncompatibleClassChangeError(type, kVirtual, resolved, referrer.Get()); 5225 } else { 5226 ThrowNoSuchMethodError(type, klass, name, signature); 5227 } 5228 } 5229 break; 5230 case kSuper: 5231 if (resolved != nullptr) { 5232 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer.Get()); 5233 } else { 5234 ThrowNoSuchMethodError(type, klass, name, signature); 5235 } 5236 break; 5237 case kVirtual: 5238 if (resolved != nullptr) { 5239 ThrowIncompatibleClassChangeError(type, kDirect, resolved, referrer.Get()); 5240 } else { 5241 resolved = klass->FindInterfaceMethod(name, signature); 5242 if (resolved != nullptr) { 5243 ThrowIncompatibleClassChangeError(type, kInterface, resolved, referrer.Get()); 5244 } else { 5245 ThrowNoSuchMethodError(type, klass, name, signature); 5246 } 5247 } 5248 break; 5249 } 5250 } 5251 } 5252 Thread::Current()->AssertPendingException(); 5253 return nullptr; 5254 } 5255} 5256 5257ArtField* ClassLinker::ResolveField(const DexFile& dex_file, uint32_t field_idx, 5258 Handle<mirror::DexCache> dex_cache, 5259 Handle<mirror::ClassLoader> class_loader, bool is_static) { 5260 DCHECK(dex_cache.Get() != nullptr); 5261 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_); 5262 if (resolved != nullptr) { 5263 return resolved; 5264 } 5265 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 5266 Thread* const self = Thread::Current(); 5267 StackHandleScope<1> hs(self); 5268 Handle<mirror::Class> klass( 5269 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader))); 5270 if (klass.Get() == nullptr) { 5271 DCHECK(Thread::Current()->IsExceptionPending()); 5272 return nullptr; 5273 } 5274 5275 if (is_static) { 5276 resolved = mirror::Class::FindStaticField(self, klass, dex_cache.Get(), field_idx); 5277 } else { 5278 resolved = klass->FindInstanceField(dex_cache.Get(), field_idx); 5279 } 5280 5281 if (resolved == nullptr) { 5282 const char* name = dex_file.GetFieldName(field_id); 5283 const char* type = dex_file.GetFieldTypeDescriptor(field_id); 5284 if (is_static) { 5285 resolved = mirror::Class::FindStaticField(self, klass, name, type); 5286 } else { 5287 resolved = klass->FindInstanceField(name, type); 5288 } 5289 if (resolved == nullptr) { 5290 ThrowNoSuchFieldError(is_static ? "static " : "instance ", klass.Get(), type, name); 5291 return nullptr; 5292 } 5293 } 5294 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_); 5295 return resolved; 5296} 5297 5298ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file, uint32_t field_idx, 5299 Handle<mirror::DexCache> dex_cache, 5300 Handle<mirror::ClassLoader> class_loader) { 5301 DCHECK(dex_cache.Get() != nullptr); 5302 ArtField* resolved = dex_cache->GetResolvedField(field_idx, image_pointer_size_); 5303 if (resolved != nullptr) { 5304 return resolved; 5305 } 5306 const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx); 5307 Thread* self = Thread::Current(); 5308 StackHandleScope<1> hs(self); 5309 Handle<mirror::Class> klass( 5310 hs.NewHandle(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader))); 5311 if (klass.Get() == nullptr) { 5312 DCHECK(Thread::Current()->IsExceptionPending()); 5313 return nullptr; 5314 } 5315 5316 StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_)); 5317 StringPiece type(dex_file.StringDataByIdx( 5318 dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_)); 5319 resolved = mirror::Class::FindField(self, klass, name, type); 5320 if (resolved != nullptr) { 5321 dex_cache->SetResolvedField(field_idx, resolved, image_pointer_size_); 5322 } else { 5323 ThrowNoSuchFieldError("", klass.Get(), type, name); 5324 } 5325 return resolved; 5326} 5327 5328const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer, 5329 uint32_t* length) { 5330 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 5331 mirror::DexCache* dex_cache = declaring_class->GetDexCache(); 5332 const DexFile& dex_file = *dex_cache->GetDexFile(); 5333 const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx); 5334 return dex_file.GetMethodShorty(method_id, length); 5335} 5336 5337void ClassLinker::DumpAllClasses(int flags) { 5338 if (dex_cache_image_class_lookup_required_) { 5339 MoveImageClassesToClassTable(); 5340 } 5341 // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker 5342 // lock held, because it might need to resolve a field's type, which would try to take the lock. 5343 std::vector<mirror::Class*> all_classes; 5344 { 5345 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 5346 for (GcRoot<mirror::Class>& it : class_table_) { 5347 all_classes.push_back(it.Read()); 5348 } 5349 } 5350 5351 for (size_t i = 0; i < all_classes.size(); ++i) { 5352 all_classes[i]->DumpClass(std::cerr, flags); 5353 } 5354} 5355 5356static OatFile::OatMethod CreateOatMethod(const void* code) { 5357 CHECK(code != nullptr); 5358 const uint8_t* base = reinterpret_cast<const uint8_t*>(code); // Base of data points at code. 5359 base -= sizeof(void*); // Move backward so that code_offset != 0. 5360 const uint32_t code_offset = sizeof(void*); 5361 return OatFile::OatMethod(base, code_offset); 5362} 5363 5364bool ClassLinker::IsQuickResolutionStub(const void* entry_point) const { 5365 return (entry_point == GetQuickResolutionStub()) || 5366 (quick_resolution_trampoline_ == entry_point); 5367} 5368 5369bool ClassLinker::IsQuickToInterpreterBridge(const void* entry_point) const { 5370 return (entry_point == GetQuickToInterpreterBridge()) || 5371 (quick_to_interpreter_bridge_trampoline_ == entry_point); 5372} 5373 5374bool ClassLinker::IsQuickGenericJniStub(const void* entry_point) const { 5375 return (entry_point == GetQuickGenericJniStub()) || 5376 (quick_generic_jni_trampoline_ == entry_point); 5377} 5378 5379const void* ClassLinker::GetRuntimeQuickGenericJniStub() const { 5380 return GetQuickGenericJniStub(); 5381} 5382 5383void ClassLinker::SetEntryPointsToCompiledCode(mirror::ArtMethod* method, 5384 const void* method_code) const { 5385 OatFile::OatMethod oat_method = CreateOatMethod(method_code); 5386 oat_method.LinkMethod(method); 5387 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge); 5388} 5389 5390void ClassLinker::SetEntryPointsToInterpreter(mirror::ArtMethod* method) const { 5391 if (!method->IsNative()) { 5392 method->SetEntryPointFromInterpreter(artInterpreterToInterpreterBridge); 5393 method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge()); 5394 } else { 5395 const void* quick_method_code = GetQuickGenericJniStub(); 5396 OatFile::OatMethod oat_method = CreateOatMethod(quick_method_code); 5397 oat_method.LinkMethod(method); 5398 method->SetEntryPointFromInterpreter(artInterpreterToCompiledCodeBridge); 5399 } 5400} 5401 5402void ClassLinker::DumpForSigQuit(std::ostream& os) { 5403 Thread* self = Thread::Current(); 5404 if (dex_cache_image_class_lookup_required_) { 5405 ScopedObjectAccess soa(self); 5406 MoveImageClassesToClassTable(); 5407 } 5408 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_); 5409 os << "Zygote loaded classes=" << pre_zygote_class_table_.Size() << " post zygote classes=" 5410 << class_table_.Size() << "\n"; 5411} 5412 5413size_t ClassLinker::NumLoadedClasses() { 5414 if (dex_cache_image_class_lookup_required_) { 5415 MoveImageClassesToClassTable(); 5416 } 5417 ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_); 5418 // Only return non zygote classes since these are the ones which apps which care about. 5419 return class_table_.Size(); 5420} 5421 5422pid_t ClassLinker::GetClassesLockOwner() { 5423 return Locks::classlinker_classes_lock_->GetExclusiveOwnerTid(); 5424} 5425 5426pid_t ClassLinker::GetDexLockOwner() { 5427 return dex_lock_.GetExclusiveOwnerTid(); 5428} 5429 5430void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) { 5431 DCHECK(!init_done_); 5432 5433 DCHECK(klass != nullptr); 5434 DCHECK(klass->GetClassLoader() == nullptr); 5435 5436 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read(); 5437 DCHECK(class_roots != nullptr); 5438 DCHECK(class_roots->Get(class_root) == nullptr); 5439 class_roots->Set<false>(class_root, klass); 5440} 5441 5442const char* ClassLinker::GetClassRootDescriptor(ClassRoot class_root) { 5443 static const char* class_roots_descriptors[] = { 5444 "Ljava/lang/Class;", 5445 "Ljava/lang/Object;", 5446 "[Ljava/lang/Class;", 5447 "[Ljava/lang/Object;", 5448 "Ljava/lang/String;", 5449 "Ljava/lang/DexCache;", 5450 "Ljava/lang/ref/Reference;", 5451 "Ljava/lang/reflect/ArtMethod;", 5452 "Ljava/lang/reflect/Constructor;", 5453 "Ljava/lang/reflect/Field;", 5454 "Ljava/lang/reflect/Method;", 5455 "Ljava/lang/reflect/Proxy;", 5456 "[Ljava/lang/String;", 5457 "[Ljava/lang/reflect/ArtMethod;", 5458 "[Ljava/lang/reflect/Constructor;", 5459 "[Ljava/lang/reflect/Field;", 5460 "[Ljava/lang/reflect/Method;", 5461 "Ljava/lang/ClassLoader;", 5462 "Ljava/lang/Throwable;", 5463 "Ljava/lang/ClassNotFoundException;", 5464 "Ljava/lang/StackTraceElement;", 5465 "Z", 5466 "B", 5467 "C", 5468 "D", 5469 "F", 5470 "I", 5471 "J", 5472 "S", 5473 "V", 5474 "[Z", 5475 "[B", 5476 "[C", 5477 "[D", 5478 "[F", 5479 "[I", 5480 "[J", 5481 "[S", 5482 "[Ljava/lang/StackTraceElement;", 5483 }; 5484 static_assert(arraysize(class_roots_descriptors) == size_t(kClassRootsMax), 5485 "Mismatch between class descriptors and class-root enum"); 5486 5487 const char* descriptor = class_roots_descriptors[class_root]; 5488 CHECK(descriptor != nullptr); 5489 return descriptor; 5490} 5491 5492std::size_t ClassLinker::ClassDescriptorHashEquals::operator()(const GcRoot<mirror::Class>& root) 5493 const { 5494 std::string temp; 5495 return ComputeModifiedUtf8Hash(root.Read()->GetDescriptor(&temp)); 5496} 5497 5498bool ClassLinker::ClassDescriptorHashEquals::operator()(const GcRoot<mirror::Class>& a, 5499 const GcRoot<mirror::Class>& b) const { 5500 if (a.Read()->GetClassLoader() != b.Read()->GetClassLoader()) { 5501 return false; 5502 } 5503 std::string temp; 5504 return a.Read()->DescriptorEquals(b.Read()->GetDescriptor(&temp)); 5505} 5506 5507std::size_t ClassLinker::ClassDescriptorHashEquals::operator()( 5508 const std::pair<const char*, mirror::ClassLoader*>& element) const { 5509 return ComputeModifiedUtf8Hash(element.first); 5510} 5511 5512bool ClassLinker::ClassDescriptorHashEquals::operator()( 5513 const GcRoot<mirror::Class>& a, const std::pair<const char*, mirror::ClassLoader*>& b) const { 5514 if (a.Read()->GetClassLoader() != b.second) { 5515 return false; 5516 } 5517 return a.Read()->DescriptorEquals(b.first); 5518} 5519 5520bool ClassLinker::ClassDescriptorHashEquals::operator()(const GcRoot<mirror::Class>& a, 5521 const char* descriptor) const { 5522 return a.Read()->DescriptorEquals(descriptor); 5523} 5524 5525std::size_t ClassLinker::ClassDescriptorHashEquals::operator()(const char* descriptor) const { 5526 return ComputeModifiedUtf8Hash(descriptor); 5527} 5528 5529bool ClassLinker::MayBeCalledWithDirectCodePointer(mirror::ArtMethod* m) { 5530 if (Runtime::Current()->UseJit()) { 5531 // JIT can have direct code pointers from any method to any other method. 5532 return true; 5533 } 5534 // Non-image methods don't use direct code pointer. 5535 if (!m->GetDeclaringClass()->IsBootStrapClassLoaded()) { 5536 return false; 5537 } 5538 if (m->IsPrivate()) { 5539 // The method can only be called inside its own oat file. Therefore it won't be called using 5540 // its direct code if the oat file has been compiled in PIC mode. 5541 const DexFile& dex_file = m->GetDeclaringClass()->GetDexFile(); 5542 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 5543 if (oat_dex_file == nullptr) { 5544 // No oat file: the method has not been compiled. 5545 return false; 5546 } 5547 const OatFile* oat_file = oat_dex_file->GetOatFile(); 5548 return oat_file != nullptr && !oat_file->IsPic(); 5549 } else { 5550 // The method can be called outside its own oat file. Therefore it won't be called using its 5551 // direct code pointer only if all loaded oat files have been compiled in PIC mode. 5552 ReaderMutexLock mu(Thread::Current(), dex_lock_); 5553 for (const OatFile* oat_file : oat_files_) { 5554 if (!oat_file->IsPic()) { 5555 return true; 5556 } 5557 } 5558 return false; 5559 } 5560} 5561 5562jobject ClassLinker::CreatePathClassLoader(Thread* self, std::vector<const DexFile*>& dex_files) { 5563 // SOAAlreadyRunnable is protected, and we need something to add a global reference. 5564 // We could move the jobject to the callers, but all call-sites do this... 5565 ScopedObjectAccessUnchecked soa(self); 5566 5567 // Register the dex files. 5568 for (const DexFile* dex_file : dex_files) { 5569 RegisterDexFile(*dex_file); 5570 } 5571 5572 // For now, create a libcore-level DexFile for each ART DexFile. This "explodes" multidex. 5573 StackHandleScope<10> hs(self); 5574 5575 ArtField* dex_elements_field = 5576 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList_dexElements); 5577 5578 mirror::Class* dex_elements_class = dex_elements_field->GetType<true>(); 5579 DCHECK(dex_elements_class != nullptr); 5580 DCHECK(dex_elements_class->IsArrayClass()); 5581 Handle<mirror::ObjectArray<mirror::Object>> h_dex_elements(hs.NewHandle( 5582 mirror::ObjectArray<mirror::Object>::Alloc(self, dex_elements_class, dex_files.size()))); 5583 Handle<mirror::Class> h_dex_element_class = 5584 hs.NewHandle(dex_elements_class->GetComponentType()); 5585 5586 ArtField* element_file_field = 5587 soa.DecodeField(WellKnownClasses::dalvik_system_DexPathList__Element_dexFile); 5588 DCHECK_EQ(h_dex_element_class.Get(), element_file_field->GetDeclaringClass()); 5589 5590 ArtField* cookie_field = soa.DecodeField(WellKnownClasses::dalvik_system_DexFile_cookie); 5591 DCHECK_EQ(cookie_field->GetDeclaringClass(), element_file_field->GetType<false>()); 5592 5593 // Fill the elements array. 5594 int32_t index = 0; 5595 for (const DexFile* dex_file : dex_files) { 5596 StackHandleScope<3> hs2(self); 5597 5598 Handle<mirror::LongArray> h_long_array = hs2.NewHandle(mirror::LongArray::Alloc(self, 1)); 5599 DCHECK(h_long_array.Get() != nullptr); 5600 h_long_array->Set(0, reinterpret_cast<intptr_t>(dex_file)); 5601 5602 Handle<mirror::Object> h_dex_file = hs2.NewHandle( 5603 cookie_field->GetDeclaringClass()->AllocObject(self)); 5604 DCHECK(h_dex_file.Get() != nullptr); 5605 cookie_field->SetObject<false>(h_dex_file.Get(), h_long_array.Get()); 5606 5607 Handle<mirror::Object> h_element = hs2.NewHandle(h_dex_element_class->AllocObject(self)); 5608 DCHECK(h_element.Get() != nullptr); 5609 element_file_field->SetObject<false>(h_element.Get(), h_dex_file.Get()); 5610 5611 h_dex_elements->Set(index, h_element.Get()); 5612 index++; 5613 } 5614 DCHECK_EQ(index, h_dex_elements->GetLength()); 5615 5616 // Create DexPathList. 5617 Handle<mirror::Object> h_dex_path_list = hs.NewHandle( 5618 dex_elements_field->GetDeclaringClass()->AllocObject(self)); 5619 DCHECK(h_dex_path_list.Get() != nullptr); 5620 // Set elements. 5621 dex_elements_field->SetObject<false>(h_dex_path_list.Get(), h_dex_elements.Get()); 5622 5623 // Create PathClassLoader. 5624 Handle<mirror::Class> h_path_class_class = hs.NewHandle( 5625 soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_system_PathClassLoader)); 5626 Handle<mirror::Object> h_path_class_loader = hs.NewHandle( 5627 h_path_class_class->AllocObject(self)); 5628 DCHECK(h_path_class_loader.Get() != nullptr); 5629 // Set DexPathList. 5630 ArtField* path_list_field = 5631 soa.DecodeField(WellKnownClasses::dalvik_system_PathClassLoader_pathList); 5632 DCHECK(path_list_field != nullptr); 5633 path_list_field->SetObject<false>(h_path_class_loader.Get(), h_dex_path_list.Get()); 5634 5635 // Make a pretend boot-classpath. 5636 // TODO: Should we scan the image? 5637 ArtField* const parent_field = 5638 mirror::Class::FindField(self, hs.NewHandle(h_path_class_loader->GetClass()), "parent", 5639 "Ljava/lang/ClassLoader;"); 5640 DCHECK(parent_field!= nullptr); 5641 mirror::Object* boot_cl = 5642 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader)->AllocObject(self); 5643 parent_field->SetObject<false>(h_path_class_loader.Get(), boot_cl); 5644 5645 // Make it a global ref and return. 5646 ScopedLocalRef<jobject> local_ref( 5647 soa.Env(), soa.Env()->AddLocalReference<jobject>(h_path_class_loader.Get())); 5648 return soa.Env()->NewGlobalRef(local_ref.get()); 5649} 5650 5651} // namespace art 5652