runtime/class_linker.cc

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