Home | History | Annotate | Download | only in mirror
      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.h"
     18 
     19 #include "art_field-inl.h"
     20 #include "art_method-inl.h"
     21 #include "class_linker-inl.h"
     22 #include "class_loader.h"
     23 #include "class-inl.h"
     24 #include "dex_cache.h"
     25 #include "dex_file-inl.h"
     26 #include "gc/accounting/card_table-inl.h"
     27 #include "handle_scope-inl.h"
     28 #include "method.h"
     29 #include "object_array-inl.h"
     30 #include "object-inl.h"
     31 #include "runtime.h"
     32 #include "thread.h"
     33 #include "throwable.h"
     34 #include "utils.h"
     35 #include "well_known_classes.h"
     36 
     37 namespace art {
     38 namespace mirror {
     39 
     40 GcRoot<Class> Class::java_lang_Class_;
     41 
     42 void Class::SetClassClass(Class* java_lang_Class) {
     43   CHECK(java_lang_Class_.IsNull())
     44       << java_lang_Class_.Read()
     45       << " " << java_lang_Class;
     46   CHECK(java_lang_Class != nullptr);
     47   java_lang_Class->SetClassFlags(mirror::kClassFlagClass);
     48   java_lang_Class_ = GcRoot<Class>(java_lang_Class);
     49 }
     50 
     51 void Class::ResetClass() {
     52   CHECK(!java_lang_Class_.IsNull());
     53   java_lang_Class_ = GcRoot<Class>(nullptr);
     54 }
     55 
     56 void Class::VisitRoots(RootVisitor* visitor) {
     57   java_lang_Class_.VisitRootIfNonNull(visitor, RootInfo(kRootStickyClass));
     58 }
     59 
     60 inline void Class::SetVerifyError(mirror::Object* error) {
     61   CHECK(error != nullptr) << PrettyClass(this);
     62   if (Runtime::Current()->IsActiveTransaction()) {
     63     SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_), error);
     64   } else {
     65     SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_), error);
     66   }
     67 }
     68 
     69 void Class::SetStatus(Handle<Class> h_this, Status new_status, Thread* self) {
     70   Status old_status = h_this->GetStatus();
     71   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
     72   bool class_linker_initialized = class_linker != nullptr && class_linker->IsInitialized();
     73   if (LIKELY(class_linker_initialized)) {
     74     if (UNLIKELY(new_status <= old_status && new_status != kStatusError &&
     75                  new_status != kStatusRetired)) {
     76       LOG(FATAL) << "Unexpected change back of class status for " << PrettyClass(h_this.Get())
     77                  << " " << old_status << " -> " << new_status;
     78     }
     79     if (new_status >= kStatusResolved || old_status >= kStatusResolved) {
     80       // When classes are being resolved the resolution code should hold the lock.
     81       CHECK_EQ(h_this->GetLockOwnerThreadId(), self->GetThreadId())
     82             << "Attempt to change status of class while not holding its lock: "
     83             << PrettyClass(h_this.Get()) << " " << old_status << " -> " << new_status;
     84     }
     85   }
     86   if (UNLIKELY(new_status == kStatusError)) {
     87     CHECK_NE(h_this->GetStatus(), kStatusError)
     88         << "Attempt to set as erroneous an already erroneous class "
     89         << PrettyClass(h_this.Get());
     90     if (VLOG_IS_ON(class_linker)) {
     91       LOG(ERROR) << "Setting " << PrettyDescriptor(h_this.Get()) << " to erroneous.";
     92       if (self->IsExceptionPending()) {
     93         LOG(ERROR) << "Exception: " << self->GetException()->Dump();
     94       }
     95     }
     96 
     97     // Remember the current exception.
     98     CHECK(self->GetException() != nullptr);
     99     h_this->SetVerifyError(self->GetException());
    100   }
    101   static_assert(sizeof(Status) == sizeof(uint32_t), "Size of status not equal to uint32");
    102   if (Runtime::Current()->IsActiveTransaction()) {
    103     h_this->SetField32Volatile<true>(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status);
    104   } else {
    105     h_this->SetField32Volatile<false>(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status);
    106   }
    107 
    108   if (!class_linker_initialized) {
    109     // When the class linker is being initialized its single threaded and by definition there can be
    110     // no waiters. During initialization classes may appear temporary but won't be retired as their
    111     // size was statically computed.
    112   } else {
    113     // Classes that are being resolved or initialized need to notify waiters that the class status
    114     // changed. See ClassLinker::EnsureResolved and ClassLinker::WaitForInitializeClass.
    115     if (h_this->IsTemp()) {
    116       // Class is a temporary one, ensure that waiters for resolution get notified of retirement
    117       // so that they can grab the new version of the class from the class linker's table.
    118       CHECK_LT(new_status, kStatusResolved) << PrettyDescriptor(h_this.Get());
    119       if (new_status == kStatusRetired || new_status == kStatusError) {
    120         h_this->NotifyAll(self);
    121       }
    122     } else {
    123       CHECK_NE(new_status, kStatusRetired);
    124       if (old_status >= kStatusResolved || new_status >= kStatusResolved) {
    125         h_this->NotifyAll(self);
    126       }
    127     }
    128   }
    129 }
    130 
    131 void Class::SetDexCache(DexCache* new_dex_cache) {
    132   SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), new_dex_cache);
    133   SetDexCacheStrings(new_dex_cache != nullptr ? new_dex_cache->GetStrings() : nullptr);
    134 }
    135 
    136 void Class::SetClassSize(uint32_t new_class_size) {
    137   if (kIsDebugBuild && new_class_size < GetClassSize()) {
    138     DumpClass(LOG(INTERNAL_FATAL), kDumpClassFullDetail);
    139     LOG(INTERNAL_FATAL) << new_class_size << " vs " << GetClassSize();
    140     LOG(FATAL) << " class=" << PrettyTypeOf(this);
    141   }
    142   // Not called within a transaction.
    143   SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size);
    144 }
    145 
    146 // Return the class' name. The exact format is bizarre, but it's the specified behavior for
    147 // Class.getName: keywords for primitive types, regular "[I" form for primitive arrays (so "int"
    148 // but "[I"), and arrays of reference types written between "L" and ";" but with dots rather than
    149 // slashes (so "java.lang.String" but "[Ljava.lang.String;"). Madness.
    150 String* Class::ComputeName(Handle<Class> h_this) {
    151   String* name = h_this->GetName();
    152   if (name != nullptr) {
    153     return name;
    154   }
    155   std::string temp;
    156   const char* descriptor = h_this->GetDescriptor(&temp);
    157   Thread* self = Thread::Current();
    158   if ((descriptor[0] != 'L') && (descriptor[0] != '[')) {
    159     // The descriptor indicates that this is the class for
    160     // a primitive type; special-case the return value.
    161     const char* c_name = nullptr;
    162     switch (descriptor[0]) {
    163     case 'Z': c_name = "boolean"; break;
    164     case 'B': c_name = "byte";    break;
    165     case 'C': c_name = "char";    break;
    166     case 'S': c_name = "short";   break;
    167     case 'I': c_name = "int";     break;
    168     case 'J': c_name = "long";    break;
    169     case 'F': c_name = "float";   break;
    170     case 'D': c_name = "double";  break;
    171     case 'V': c_name = "void";    break;
    172     default:
    173       LOG(FATAL) << "Unknown primitive type: " << PrintableChar(descriptor[0]);
    174     }
    175     name = String::AllocFromModifiedUtf8(self, c_name);
    176   } else {
    177     // Convert the UTF-8 name to a java.lang.String. The name must use '.' to separate package
    178     // components.
    179     name = String::AllocFromModifiedUtf8(self, DescriptorToDot(descriptor).c_str());
    180   }
    181   h_this->SetName(name);
    182   return name;
    183 }
    184 
    185 void Class::DumpClass(std::ostream& os, int flags) {
    186   if ((flags & kDumpClassFullDetail) == 0) {
    187     os << PrettyClass(this);
    188     if ((flags & kDumpClassClassLoader) != 0) {
    189       os << ' ' << GetClassLoader();
    190     }
    191     if ((flags & kDumpClassInitialized) != 0) {
    192       os << ' ' << GetStatus();
    193     }
    194     os << "\n";
    195     return;
    196   }
    197 
    198   Thread* const self = Thread::Current();
    199   StackHandleScope<2> hs(self);
    200   Handle<mirror::Class> h_this(hs.NewHandle(this));
    201   Handle<mirror::Class> h_super(hs.NewHandle(GetSuperClass()));
    202   auto image_pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
    203 
    204   std::string temp;
    205   os << "----- " << (IsInterface() ? "interface" : "class") << " "
    206      << "'" << GetDescriptor(&temp) << "' cl=" << GetClassLoader() << " -----\n",
    207   os << "  objectSize=" << SizeOf() << " "
    208      << "(" << (h_super.Get() != nullptr ? h_super->SizeOf() : -1) << " from super)\n",
    209   os << StringPrintf("  access=0x%04x.%04x\n",
    210       GetAccessFlags() >> 16, GetAccessFlags() & kAccJavaFlagsMask);
    211   if (h_super.Get() != nullptr) {
    212     os << "  super='" << PrettyClass(h_super.Get()) << "' (cl=" << h_super->GetClassLoader()
    213        << ")\n";
    214   }
    215   if (IsArrayClass()) {
    216     os << "  componentType=" << PrettyClass(GetComponentType()) << "\n";
    217   }
    218   const size_t num_direct_interfaces = NumDirectInterfaces();
    219   if (num_direct_interfaces > 0) {
    220     os << "  interfaces (" << num_direct_interfaces << "):\n";
    221     for (size_t i = 0; i < num_direct_interfaces; ++i) {
    222       Class* interface = GetDirectInterface(self, h_this, i);
    223       if (interface == nullptr) {
    224         os << StringPrintf("    %2zd: nullptr!\n", i);
    225       } else {
    226         const ClassLoader* cl = interface->GetClassLoader();
    227         os << StringPrintf("    %2zd: %s (cl=%p)\n", i, PrettyClass(interface).c_str(), cl);
    228       }
    229     }
    230   }
    231   if (!IsLoaded()) {
    232     os << "  class not yet loaded";
    233   } else {
    234     // After this point, this may have moved due to GetDirectInterface.
    235     os << "  vtable (" << h_this->NumVirtualMethods() << " entries, "
    236         << (h_super.Get() != nullptr ? h_super->NumVirtualMethods() : 0) << " in super):\n";
    237     for (size_t i = 0; i < NumVirtualMethods(); ++i) {
    238       os << StringPrintf("    %2zd: %s\n", i, PrettyMethod(
    239           h_this->GetVirtualMethodDuringLinking(i, image_pointer_size)).c_str());
    240     }
    241     os << "  direct methods (" << h_this->NumDirectMethods() << " entries):\n";
    242     for (size_t i = 0; i < h_this->NumDirectMethods(); ++i) {
    243       os << StringPrintf("    %2zd: %s\n", i, PrettyMethod(
    244           h_this->GetDirectMethod(i, image_pointer_size)).c_str());
    245     }
    246     if (h_this->NumStaticFields() > 0) {
    247       os << "  static fields (" << h_this->NumStaticFields() << " entries):\n";
    248       if (h_this->IsResolved() || h_this->IsErroneous()) {
    249         for (size_t i = 0; i < h_this->NumStaticFields(); ++i) {
    250           os << StringPrintf("    %2zd: %s\n", i, PrettyField(h_this->GetStaticField(i)).c_str());
    251         }
    252       } else {
    253         os << "    <not yet available>";
    254       }
    255     }
    256     if (h_this->NumInstanceFields() > 0) {
    257       os << "  instance fields (" << h_this->NumInstanceFields() << " entries):\n";
    258       if (h_this->IsResolved() || h_this->IsErroneous()) {
    259         for (size_t i = 0; i < h_this->NumInstanceFields(); ++i) {
    260           os << StringPrintf("    %2zd: %s\n", i, PrettyField(h_this->GetInstanceField(i)).c_str());
    261         }
    262       } else {
    263         os << "    <not yet available>";
    264       }
    265     }
    266   }
    267 }
    268 
    269 void Class::SetReferenceInstanceOffsets(uint32_t new_reference_offsets) {
    270   if (kIsDebugBuild && new_reference_offsets != kClassWalkSuper) {
    271     // Sanity check that the number of bits set in the reference offset bitmap
    272     // agrees with the number of references
    273     uint32_t count = 0;
    274     for (Class* c = this; c != nullptr; c = c->GetSuperClass()) {
    275       count += c->NumReferenceInstanceFieldsDuringLinking();
    276     }
    277     // +1 for the Class in Object.
    278     CHECK_EQ(static_cast<uint32_t>(POPCOUNT(new_reference_offsets)) + 1, count);
    279   }
    280   // Not called within a transaction.
    281   SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_),
    282                     new_reference_offsets);
    283 }
    284 
    285 bool Class::IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2) {
    286   size_t i = 0;
    287   size_t min_length = std::min(descriptor1.size(), descriptor2.size());
    288   while (i < min_length && descriptor1[i] == descriptor2[i]) {
    289     ++i;
    290   }
    291   if (descriptor1.find('/', i) != StringPiece::npos ||
    292       descriptor2.find('/', i) != StringPiece::npos) {
    293     return false;
    294   } else {
    295     return true;
    296   }
    297 }
    298 
    299 bool Class::IsInSamePackage(Class* that) {
    300   Class* klass1 = this;
    301   Class* klass2 = that;
    302   if (klass1 == klass2) {
    303     return true;
    304   }
    305   // Class loaders must match.
    306   if (klass1->GetClassLoader() != klass2->GetClassLoader()) {
    307     return false;
    308   }
    309   // Arrays are in the same package when their element classes are.
    310   while (klass1->IsArrayClass()) {
    311     klass1 = klass1->GetComponentType();
    312   }
    313   while (klass2->IsArrayClass()) {
    314     klass2 = klass2->GetComponentType();
    315   }
    316   // trivial check again for array types
    317   if (klass1 == klass2) {
    318     return true;
    319   }
    320   // Compare the package part of the descriptor string.
    321   std::string temp1, temp2;
    322   return IsInSamePackage(klass1->GetDescriptor(&temp1), klass2->GetDescriptor(&temp2));
    323 }
    324 
    325 bool Class::IsThrowableClass() {
    326   return WellKnownClasses::ToClass(WellKnownClasses::java_lang_Throwable)->IsAssignableFrom(this);
    327 }
    328 
    329 void Class::SetClassLoader(ClassLoader* new_class_loader) {
    330   if (Runtime::Current()->IsActiveTransaction()) {
    331     SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader);
    332   } else {
    333     SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader);
    334   }
    335 }
    336 
    337 ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature,
    338                                       size_t pointer_size) {
    339   // Check the current class before checking the interfaces.
    340   ArtMethod* method = FindDeclaredVirtualMethod(name, signature, pointer_size);
    341   if (method != nullptr) {
    342     return method;
    343   }
    344 
    345   int32_t iftable_count = GetIfTableCount();
    346   IfTable* iftable = GetIfTable();
    347   for (int32_t i = 0; i < iftable_count; ++i) {
    348     method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(name, signature, pointer_size);
    349     if (method != nullptr) {
    350       return method;
    351     }
    352   }
    353   return nullptr;
    354 }
    355 
    356 ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, const Signature& signature,
    357                                       size_t pointer_size) {
    358   // Check the current class before checking the interfaces.
    359   ArtMethod* method = FindDeclaredVirtualMethod(name, signature, pointer_size);
    360   if (method != nullptr) {
    361     return method;
    362   }
    363 
    364   int32_t iftable_count = GetIfTableCount();
    365   IfTable* iftable = GetIfTable();
    366   for (int32_t i = 0; i < iftable_count; ++i) {
    367     method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(name, signature, pointer_size);
    368     if (method != nullptr) {
    369       return method;
    370     }
    371   }
    372   return nullptr;
    373 }
    374 
    375 ArtMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx,
    376                                       size_t pointer_size) {
    377   // Check the current class before checking the interfaces.
    378   ArtMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx, pointer_size);
    379   if (method != nullptr) {
    380     return method;
    381   }
    382 
    383   int32_t iftable_count = GetIfTableCount();
    384   IfTable* iftable = GetIfTable();
    385   for (int32_t i = 0; i < iftable_count; ++i) {
    386     method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(
    387         dex_cache, dex_method_idx, pointer_size);
    388     if (method != nullptr) {
    389       return method;
    390     }
    391   }
    392   return nullptr;
    393 }
    394 
    395 ArtMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature,
    396                                            size_t pointer_size) {
    397   for (auto& method : GetDirectMethods(pointer_size)) {
    398     if (name == method.GetName() && method.GetSignature() == signature) {
    399       return &method;
    400     }
    401   }
    402   return nullptr;
    403 }
    404 
    405 ArtMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const Signature& signature,
    406                                            size_t pointer_size) {
    407   for (auto& method : GetDirectMethods(pointer_size)) {
    408     if (name == method.GetName() && signature == method.GetSignature()) {
    409       return &method;
    410     }
    411   }
    412   return nullptr;
    413 }
    414 
    415 ArtMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx,
    416                                            size_t pointer_size) {
    417   if (GetDexCache() == dex_cache) {
    418     for (auto& method : GetDirectMethods(pointer_size)) {
    419       if (method.GetDexMethodIndex() == dex_method_idx) {
    420         return &method;
    421       }
    422     }
    423   }
    424   return nullptr;
    425 }
    426 
    427 ArtMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature,
    428                                    size_t pointer_size) {
    429   for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
    430     ArtMethod* method = klass->FindDeclaredDirectMethod(name, signature, pointer_size);
    431     if (method != nullptr) {
    432       return method;
    433     }
    434   }
    435   return nullptr;
    436 }
    437 
    438 ArtMethod* Class::FindDirectMethod(const StringPiece& name, const Signature& signature,
    439                                    size_t pointer_size) {
    440   for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
    441     ArtMethod* method = klass->FindDeclaredDirectMethod(name, signature, pointer_size);
    442     if (method != nullptr) {
    443       return method;
    444     }
    445   }
    446   return nullptr;
    447 }
    448 
    449 ArtMethod* Class::FindDirectMethod(
    450     const DexCache* dex_cache, uint32_t dex_method_idx, size_t pointer_size) {
    451   for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
    452     ArtMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx, pointer_size);
    453     if (method != nullptr) {
    454       return method;
    455     }
    456   }
    457   return nullptr;
    458 }
    459 
    460 ArtMethod* Class::FindDeclaredDirectMethodByName(const StringPiece& name, size_t pointer_size) {
    461   for (auto& method : GetDirectMethods(pointer_size)) {
    462     ArtMethod* const np_method = method.GetInterfaceMethodIfProxy(pointer_size);
    463     if (name == np_method->GetName()) {
    464       return &method;
    465     }
    466   }
    467   return nullptr;
    468 }
    469 
    470 // TODO These should maybe be changed to be named FindOwnedVirtualMethod or something similar
    471 // because they do not only find 'declared' methods and will return copied methods. This behavior is
    472 // desired and correct but the naming can lead to confusion because in the java language declared
    473 // excludes interface methods which might be found by this.
    474 ArtMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature,
    475                                             size_t pointer_size) {
    476   for (auto& method : GetVirtualMethods(pointer_size)) {
    477     ArtMethod* const np_method = method.GetInterfaceMethodIfProxy(pointer_size);
    478     if (name == np_method->GetName() && np_method->GetSignature() == signature) {
    479       return &method;
    480     }
    481   }
    482   return nullptr;
    483 }
    484 
    485 ArtMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name, const Signature& signature,
    486                                             size_t pointer_size) {
    487   for (auto& method : GetVirtualMethods(pointer_size)) {
    488     ArtMethod* const np_method = method.GetInterfaceMethodIfProxy(pointer_size);
    489     if (name == np_method->GetName() && signature == np_method->GetSignature()) {
    490       return &method;
    491     }
    492   }
    493   return nullptr;
    494 }
    495 
    496 ArtMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx,
    497                                             size_t pointer_size) {
    498   if (GetDexCache() == dex_cache) {
    499     for (auto& method : GetDeclaredVirtualMethods(pointer_size)) {
    500       if (method.GetDexMethodIndex() == dex_method_idx) {
    501         return &method;
    502       }
    503     }
    504   }
    505   return nullptr;
    506 }
    507 
    508 ArtMethod* Class::FindDeclaredVirtualMethodByName(const StringPiece& name, size_t pointer_size) {
    509   for (auto& method : GetVirtualMethods(pointer_size)) {
    510     ArtMethod* const np_method = method.GetInterfaceMethodIfProxy(pointer_size);
    511     if (name == np_method->GetName()) {
    512       return &method;
    513     }
    514   }
    515   return nullptr;
    516 }
    517 
    518 ArtMethod* Class::FindVirtualMethod(
    519     const StringPiece& name, const StringPiece& signature, size_t pointer_size) {
    520   for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
    521     ArtMethod* method = klass->FindDeclaredVirtualMethod(name, signature, pointer_size);
    522     if (method != nullptr) {
    523       return method;
    524     }
    525   }
    526   return nullptr;
    527 }
    528 
    529 ArtMethod* Class::FindVirtualMethod(
    530     const StringPiece& name, const Signature& signature, size_t pointer_size) {
    531   for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
    532     ArtMethod* method = klass->FindDeclaredVirtualMethod(name, signature, pointer_size);
    533     if (method != nullptr) {
    534       return method;
    535     }
    536   }
    537   return nullptr;
    538 }
    539 
    540 ArtMethod* Class::FindVirtualMethod(
    541     const DexCache* dex_cache, uint32_t dex_method_idx, size_t pointer_size) {
    542   for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
    543     ArtMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx, pointer_size);
    544     if (method != nullptr) {
    545       return method;
    546     }
    547   }
    548   return nullptr;
    549 }
    550 
    551 ArtMethod* Class::FindVirtualMethodForInterfaceSuper(ArtMethod* method, size_t pointer_size) {
    552   DCHECK(method->GetDeclaringClass()->IsInterface());
    553   DCHECK(IsInterface()) << "Should only be called on a interface class";
    554   // Check if we have one defined on this interface first. This includes searching copied ones to
    555   // get any conflict methods. Conflict methods are copied into each subtype from the supertype. We
    556   // don't do any indirect method checks here.
    557   for (ArtMethod& iface_method : GetVirtualMethods(pointer_size)) {
    558     if (method->HasSameNameAndSignature(&iface_method)) {
    559       return &iface_method;
    560     }
    561   }
    562 
    563   std::vector<ArtMethod*> abstract_methods;
    564   // Search through the IFTable for a working version. We don't need to check for conflicts
    565   // because if there was one it would appear in this classes virtual_methods_ above.
    566 
    567   Thread* self = Thread::Current();
    568   StackHandleScope<2> hs(self);
    569   MutableHandle<mirror::IfTable> iftable(hs.NewHandle(GetIfTable()));
    570   MutableHandle<mirror::Class> iface(hs.NewHandle<mirror::Class>(nullptr));
    571   size_t iftable_count = GetIfTableCount();
    572   // Find the method. We don't need to check for conflicts because they would have been in the
    573   // copied virtuals of this interface.  Order matters, traverse in reverse topological order; most
    574   // subtypiest interfaces get visited first.
    575   for (size_t k = iftable_count; k != 0;) {
    576     k--;
    577     DCHECK_LT(k, iftable->Count());
    578     iface.Assign(iftable->GetInterface(k));
    579     // Iterate through every declared method on this interface. Each direct method's name/signature
    580     // is unique so the order of the inner loop doesn't matter.
    581     for (auto& method_iter : iface->GetDeclaredVirtualMethods(pointer_size)) {
    582       ArtMethod* current_method = &method_iter;
    583       if (current_method->HasSameNameAndSignature(method)) {
    584         if (current_method->IsDefault()) {
    585           // Handle JLS soft errors, a default method from another superinterface tree can
    586           // "override" an abstract method(s) from another superinterface tree(s).  To do this,
    587           // ignore any [default] method which are dominated by the abstract methods we've seen so
    588           // far. Check if overridden by any in abstract_methods. We do not need to check for
    589           // default_conflicts because we would hit those before we get to this loop.
    590           bool overridden = false;
    591           for (ArtMethod* possible_override : abstract_methods) {
    592             DCHECK(possible_override->HasSameNameAndSignature(current_method));
    593             if (iface->IsAssignableFrom(possible_override->GetDeclaringClass())) {
    594               overridden = true;
    595               break;
    596             }
    597           }
    598           if (!overridden) {
    599             return current_method;
    600           }
    601         } else {
    602           // Is not default.
    603           // This might override another default method. Just stash it for now.
    604           abstract_methods.push_back(current_method);
    605         }
    606       }
    607     }
    608   }
    609   // If we reach here we either never found any declaration of the method (in which case
    610   // 'abstract_methods' is empty or we found no non-overriden default methods in which case
    611   // 'abstract_methods' contains a number of abstract implementations of the methods. We choose one
    612   // of these arbitrarily.
    613   return abstract_methods.empty() ? nullptr : abstract_methods[0];
    614 }
    615 
    616 ArtMethod* Class::FindClassInitializer(size_t pointer_size) {
    617   for (ArtMethod& method : GetDirectMethods(pointer_size)) {
    618     if (method.IsClassInitializer()) {
    619       DCHECK_STREQ(method.GetName(), "<clinit>");
    620       DCHECK_STREQ(method.GetSignature().ToString().c_str(), "()V");
    621       return &method;
    622     }
    623   }
    624   return nullptr;
    625 }
    626 
    627 // Custom binary search to avoid double comparisons from std::binary_search.
    628 static ArtField* FindFieldByNameAndType(LengthPrefixedArray<ArtField>* fields,
    629                                         const StringPiece& name,
    630                                         const StringPiece& type)
    631     SHARED_REQUIRES(Locks::mutator_lock_) {
    632   if (fields == nullptr) {
    633     return nullptr;
    634   }
    635   size_t low = 0;
    636   size_t high = fields->size();
    637   ArtField* ret = nullptr;
    638   while (low < high) {
    639     size_t mid = (low + high) / 2;
    640     ArtField& field = fields->At(mid);
    641     // Fields are sorted by class, then name, then type descriptor. This is verified in dex file
    642     // verifier. There can be multiple fields with the same in the same class name due to proguard.
    643     int result = StringPiece(field.GetName()).Compare(name);
    644     if (result == 0) {
    645       result = StringPiece(field.GetTypeDescriptor()).Compare(type);
    646     }
    647     if (result < 0) {
    648       low = mid + 1;
    649     } else if (result > 0) {
    650       high = mid;
    651     } else {
    652       ret = &field;
    653       break;
    654     }
    655   }
    656   if (kIsDebugBuild) {
    657     ArtField* found = nullptr;
    658     for (ArtField& field : MakeIterationRangeFromLengthPrefixedArray(fields)) {
    659       if (name == field.GetName() && type == field.GetTypeDescriptor()) {
    660         found = &field;
    661         break;
    662       }
    663     }
    664     CHECK_EQ(found, ret) << "Found " << PrettyField(found) << " vs  " << PrettyField(ret);
    665   }
    666   return ret;
    667 }
    668 
    669 ArtField* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
    670   // Binary search by name. Interfaces are not relevant because they can't contain instance fields.
    671   return FindFieldByNameAndType(GetIFieldsPtr(), name, type);
    672 }
    673 
    674 ArtField* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
    675   if (GetDexCache() == dex_cache) {
    676     for (ArtField& field : GetIFields()) {
    677       if (field.GetDexFieldIndex() == dex_field_idx) {
    678         return &field;
    679       }
    680     }
    681   }
    682   return nullptr;
    683 }
    684 
    685 ArtField* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) {
    686   // Is the field in this class, or any of its superclasses?
    687   // Interfaces are not relevant because they can't contain instance fields.
    688   for (Class* c = this; c != nullptr; c = c->GetSuperClass()) {
    689     ArtField* f = c->FindDeclaredInstanceField(name, type);
    690     if (f != nullptr) {
    691       return f;
    692     }
    693   }
    694   return nullptr;
    695 }
    696 
    697 ArtField* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
    698   // Is the field in this class, or any of its superclasses?
    699   // Interfaces are not relevant because they can't contain instance fields.
    700   for (Class* c = this; c != nullptr; c = c->GetSuperClass()) {
    701     ArtField* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx);
    702     if (f != nullptr) {
    703       return f;
    704     }
    705   }
    706   return nullptr;
    707 }
    708 
    709 ArtField* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
    710   DCHECK(type != nullptr);
    711   return FindFieldByNameAndType(GetSFieldsPtr(), name, type);
    712 }
    713 
    714 ArtField* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
    715   if (dex_cache == GetDexCache()) {
    716     for (ArtField& field : GetSFields()) {
    717       if (field.GetDexFieldIndex() == dex_field_idx) {
    718         return &field;
    719       }
    720     }
    721   }
    722   return nullptr;
    723 }
    724 
    725 ArtField* Class::FindStaticField(Thread* self, Handle<Class> klass, const StringPiece& name,
    726                                  const StringPiece& type) {
    727   // Is the field in this class (or its interfaces), or any of its
    728   // superclasses (or their interfaces)?
    729   for (Class* k = klass.Get(); k != nullptr; k = k->GetSuperClass()) {
    730     // Is the field in this class?
    731     ArtField* f = k->FindDeclaredStaticField(name, type);
    732     if (f != nullptr) {
    733       return f;
    734     }
    735     // Wrap k incase it moves during GetDirectInterface.
    736     StackHandleScope<1> hs(self);
    737     HandleWrapper<mirror::Class> h_k(hs.NewHandleWrapper(&k));
    738     // Is this field in any of this class' interfaces?
    739     for (uint32_t i = 0; i < h_k->NumDirectInterfaces(); ++i) {
    740       StackHandleScope<1> hs2(self);
    741       Handle<mirror::Class> interface(hs2.NewHandle(GetDirectInterface(self, h_k, i)));
    742       f = FindStaticField(self, interface, name, type);
    743       if (f != nullptr) {
    744         return f;
    745       }
    746     }
    747   }
    748   return nullptr;
    749 }
    750 
    751 ArtField* Class::FindStaticField(Thread* self, Handle<Class> klass, const DexCache* dex_cache,
    752                                  uint32_t dex_field_idx) {
    753   for (Class* k = klass.Get(); k != nullptr; k = k->GetSuperClass()) {
    754     // Is the field in this class?
    755     ArtField* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx);
    756     if (f != nullptr) {
    757       return f;
    758     }
    759     // Wrap k incase it moves during GetDirectInterface.
    760     StackHandleScope<1> hs(self);
    761     HandleWrapper<mirror::Class> h_k(hs.NewHandleWrapper(&k));
    762     // Is this field in any of this class' interfaces?
    763     for (uint32_t i = 0; i < h_k->NumDirectInterfaces(); ++i) {
    764       StackHandleScope<1> hs2(self);
    765       Handle<mirror::Class> interface(hs2.NewHandle(GetDirectInterface(self, h_k, i)));
    766       f = FindStaticField(self, interface, dex_cache, dex_field_idx);
    767       if (f != nullptr) {
    768         return f;
    769       }
    770     }
    771   }
    772   return nullptr;
    773 }
    774 
    775 ArtField* Class::FindField(Thread* self, Handle<Class> klass, const StringPiece& name,
    776                            const StringPiece& type) {
    777   // Find a field using the JLS field resolution order
    778   for (Class* k = klass.Get(); k != nullptr; k = k->GetSuperClass()) {
    779     // Is the field in this class?
    780     ArtField* f = k->FindDeclaredInstanceField(name, type);
    781     if (f != nullptr) {
    782       return f;
    783     }
    784     f = k->FindDeclaredStaticField(name, type);
    785     if (f != nullptr) {
    786       return f;
    787     }
    788     // Is this field in any of this class' interfaces?
    789     StackHandleScope<1> hs(self);
    790     HandleWrapper<mirror::Class> h_k(hs.NewHandleWrapper(&k));
    791     for (uint32_t i = 0; i < h_k->NumDirectInterfaces(); ++i) {
    792       StackHandleScope<1> hs2(self);
    793       Handle<mirror::Class> interface(hs2.NewHandle(GetDirectInterface(self, h_k, i)));
    794       f = interface->FindStaticField(self, interface, name, type);
    795       if (f != nullptr) {
    796         return f;
    797       }
    798     }
    799   }
    800   return nullptr;
    801 }
    802 
    803 void Class::SetSkipAccessChecksFlagOnAllMethods(size_t pointer_size) {
    804   DCHECK(IsVerified());
    805   for (auto& m : GetMethods(pointer_size)) {
    806     if (!m.IsNative() && m.IsInvokable()) {
    807       m.SetSkipAccessChecks();
    808     }
    809   }
    810 }
    811 
    812 const char* Class::GetDescriptor(std::string* storage) {
    813   if (IsPrimitive()) {
    814     return Primitive::Descriptor(GetPrimitiveType());
    815   } else if (IsArrayClass()) {
    816     return GetArrayDescriptor(storage);
    817   } else if (IsProxyClass()) {
    818     *storage = Runtime::Current()->GetClassLinker()->GetDescriptorForProxy(this);
    819     return storage->c_str();
    820   } else {
    821     const DexFile& dex_file = GetDexFile();
    822     const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
    823     return dex_file.GetTypeDescriptor(type_id);
    824   }
    825 }
    826 
    827 const char* Class::GetArrayDescriptor(std::string* storage) {
    828   std::string temp;
    829   const char* elem_desc = GetComponentType()->GetDescriptor(&temp);
    830   *storage = "[";
    831   *storage += elem_desc;
    832   return storage->c_str();
    833 }
    834 
    835 const DexFile::ClassDef* Class::GetClassDef() {
    836   uint16_t class_def_idx = GetDexClassDefIndex();
    837   if (class_def_idx == DexFile::kDexNoIndex16) {
    838     return nullptr;
    839   }
    840   return &GetDexFile().GetClassDef(class_def_idx);
    841 }
    842 
    843 uint16_t Class::GetDirectInterfaceTypeIdx(uint32_t idx) {
    844   DCHECK(!IsPrimitive());
    845   DCHECK(!IsArrayClass());
    846   return GetInterfaceTypeList()->GetTypeItem(idx).type_idx_;
    847 }
    848 
    849 mirror::Class* Class::GetDirectInterface(Thread* self, Handle<mirror::Class> klass,
    850                                          uint32_t idx) {
    851   DCHECK(klass.Get() != nullptr);
    852   DCHECK(!klass->IsPrimitive());
    853   if (klass->IsArrayClass()) {
    854     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
    855     if (idx == 0) {
    856       return class_linker->FindSystemClass(self, "Ljava/lang/Cloneable;");
    857     } else {
    858       DCHECK_EQ(1U, idx);
    859       return class_linker->FindSystemClass(self, "Ljava/io/Serializable;");
    860     }
    861   } else if (klass->IsProxyClass()) {
    862     mirror::ObjectArray<mirror::Class>* interfaces = klass.Get()->GetInterfaces();
    863     DCHECK(interfaces != nullptr);
    864     return interfaces->Get(idx);
    865   } else {
    866     uint16_t type_idx = klass->GetDirectInterfaceTypeIdx(idx);
    867     mirror::Class* interface = klass->GetDexCache()->GetResolvedType(type_idx);
    868     if (interface == nullptr) {
    869       interface = Runtime::Current()->GetClassLinker()->ResolveType(klass->GetDexFile(), type_idx,
    870                                                                     klass.Get());
    871       CHECK(interface != nullptr || self->IsExceptionPending());
    872     }
    873     return interface;
    874   }
    875 }
    876 
    877 mirror::Class* Class::GetCommonSuperClass(Handle<Class> klass) {
    878   DCHECK(klass.Get() != nullptr);
    879   DCHECK(!klass->IsInterface());
    880   DCHECK(!IsInterface());
    881   mirror::Class* common_super_class = this;
    882   while (!common_super_class->IsAssignableFrom(klass.Get())) {
    883     mirror::Class* old_common = common_super_class;
    884     common_super_class = old_common->GetSuperClass();
    885     DCHECK(common_super_class != nullptr) << PrettyClass(old_common);
    886   }
    887   return common_super_class;
    888 }
    889 
    890 const char* Class::GetSourceFile() {
    891   const DexFile& dex_file = GetDexFile();
    892   const DexFile::ClassDef* dex_class_def = GetClassDef();
    893   if (dex_class_def == nullptr) {
    894     // Generated classes have no class def.
    895     return nullptr;
    896   }
    897   return dex_file.GetSourceFile(*dex_class_def);
    898 }
    899 
    900 std::string Class::GetLocation() {
    901   mirror::DexCache* dex_cache = GetDexCache();
    902   if (dex_cache != nullptr && !IsProxyClass()) {
    903     return dex_cache->GetLocation()->ToModifiedUtf8();
    904   }
    905   // Arrays and proxies are generated and have no corresponding dex file location.
    906   return "generated class";
    907 }
    908 
    909 const DexFile::TypeList* Class::GetInterfaceTypeList() {
    910   const DexFile::ClassDef* class_def = GetClassDef();
    911   if (class_def == nullptr) {
    912     return nullptr;
    913   }
    914   return GetDexFile().GetInterfacesList(*class_def);
    915 }
    916 
    917 void Class::PopulateEmbeddedVTable(size_t pointer_size) {
    918   PointerArray* table = GetVTableDuringLinking();
    919   CHECK(table != nullptr) << PrettyClass(this);
    920   const size_t table_length = table->GetLength();
    921   SetEmbeddedVTableLength(table_length);
    922   for (size_t i = 0; i < table_length; i++) {
    923     SetEmbeddedVTableEntry(i, table->GetElementPtrSize<ArtMethod*>(i, pointer_size), pointer_size);
    924   }
    925   // Keep java.lang.Object class's vtable around for since it's easier
    926   // to be reused by array classes during their linking.
    927   if (!IsObjectClass()) {
    928     SetVTable(nullptr);
    929   }
    930 }
    931 
    932 class ReadBarrierOnNativeRootsVisitor {
    933  public:
    934   void operator()(mirror::Object* obj ATTRIBUTE_UNUSED,
    935                   MemberOffset offset ATTRIBUTE_UNUSED,
    936                   bool is_static ATTRIBUTE_UNUSED) const {}
    937 
    938   void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const
    939       SHARED_REQUIRES(Locks::mutator_lock_) {
    940     if (!root->IsNull()) {
    941       VisitRoot(root);
    942     }
    943   }
    944 
    945   void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const
    946       SHARED_REQUIRES(Locks::mutator_lock_) {
    947     mirror::Object* old_ref = root->AsMirrorPtr();
    948     mirror::Object* new_ref = ReadBarrier::BarrierForRoot(root);
    949     if (old_ref != new_ref) {
    950       // Update the field atomically. This may fail if mutator updates before us, but it's ok.
    951       auto* atomic_root =
    952           reinterpret_cast<Atomic<mirror::CompressedReference<mirror::Object>>*>(root);
    953       atomic_root->CompareExchangeStrongSequentiallyConsistent(
    954           mirror::CompressedReference<mirror::Object>::FromMirrorPtr(old_ref),
    955           mirror::CompressedReference<mirror::Object>::FromMirrorPtr(new_ref));
    956     }
    957   }
    958 };
    959 
    960 // The pre-fence visitor for Class::CopyOf().
    961 class CopyClassVisitor {
    962  public:
    963   CopyClassVisitor(Thread* self, Handle<mirror::Class>* orig, size_t new_length,
    964                    size_t copy_bytes, ImTable* imt,
    965                    size_t pointer_size)
    966       : self_(self), orig_(orig), new_length_(new_length),
    967         copy_bytes_(copy_bytes), imt_(imt), pointer_size_(pointer_size) {
    968   }
    969 
    970   void operator()(mirror::Object* obj, size_t usable_size ATTRIBUTE_UNUSED) const
    971       SHARED_REQUIRES(Locks::mutator_lock_) {
    972     StackHandleScope<1> hs(self_);
    973     Handle<mirror::Class> h_new_class_obj(hs.NewHandle(obj->AsClass()));
    974     mirror::Object::CopyObject(self_, h_new_class_obj.Get(), orig_->Get(), copy_bytes_);
    975     mirror::Class::SetStatus(h_new_class_obj, Class::kStatusResolving, self_);
    976     h_new_class_obj->PopulateEmbeddedVTable(pointer_size_);
    977     h_new_class_obj->SetImt(imt_, pointer_size_);
    978     h_new_class_obj->SetClassSize(new_length_);
    979     // Visit all of the references to make sure there is no from space references in the native
    980     // roots.
    981     static_cast<mirror::Object*>(h_new_class_obj.Get())->VisitReferences(
    982         ReadBarrierOnNativeRootsVisitor(), VoidFunctor());
    983   }
    984 
    985  private:
    986   Thread* const self_;
    987   Handle<mirror::Class>* const orig_;
    988   const size_t new_length_;
    989   const size_t copy_bytes_;
    990   ImTable* imt_;
    991   const size_t pointer_size_;
    992   DISALLOW_COPY_AND_ASSIGN(CopyClassVisitor);
    993 };
    994 
    995 Class* Class::CopyOf(Thread* self, int32_t new_length,
    996                      ImTable* imt, size_t pointer_size) {
    997   DCHECK_GE(new_length, static_cast<int32_t>(sizeof(Class)));
    998   // We may get copied by a compacting GC.
    999   StackHandleScope<1> hs(self);
   1000   Handle<mirror::Class> h_this(hs.NewHandle(this));
   1001   gc::Heap* heap = Runtime::Current()->GetHeap();
   1002   // The num_bytes (3rd param) is sizeof(Class) as opposed to SizeOf()
   1003   // to skip copying the tail part that we will overwrite here.
   1004   CopyClassVisitor visitor(self, &h_this, new_length, sizeof(Class), imt, pointer_size);
   1005   mirror::Object* new_class = kMovingClasses ?
   1006       heap->AllocObject<true>(self, java_lang_Class_.Read(), new_length, visitor) :
   1007       heap->AllocNonMovableObject<true>(self, java_lang_Class_.Read(), new_length, visitor);
   1008   if (UNLIKELY(new_class == nullptr)) {
   1009     self->AssertPendingOOMException();
   1010     return nullptr;
   1011   }
   1012   return new_class->AsClass();
   1013 }
   1014 
   1015 bool Class::ProxyDescriptorEquals(const char* match) {
   1016   DCHECK(IsProxyClass());
   1017   return Runtime::Current()->GetClassLinker()->GetDescriptorForProxy(this) == match;
   1018 }
   1019 
   1020 // TODO: Move this to java_lang_Class.cc?
   1021 ArtMethod* Class::GetDeclaredConstructor(
   1022     Thread* self, Handle<mirror::ObjectArray<mirror::Class>> args, size_t pointer_size) {
   1023   for (auto& m : GetDirectMethods(pointer_size)) {
   1024     // Skip <clinit> which is a static constructor, as well as non constructors.
   1025     if (m.IsStatic() || !m.IsConstructor()) {
   1026       continue;
   1027     }
   1028     // May cause thread suspension and exceptions.
   1029     if (m.GetInterfaceMethodIfProxy(sizeof(void*))->EqualParameters(args)) {
   1030       return &m;
   1031     }
   1032     if (UNLIKELY(self->IsExceptionPending())) {
   1033       return nullptr;
   1034     }
   1035   }
   1036   return nullptr;
   1037 }
   1038 
   1039 uint32_t Class::Depth() {
   1040   uint32_t depth = 0;
   1041   for (Class* klass = this; klass->GetSuperClass() != nullptr; klass = klass->GetSuperClass()) {
   1042     depth++;
   1043   }
   1044   return depth;
   1045 }
   1046 
   1047 uint32_t Class::FindTypeIndexInOtherDexFile(const DexFile& dex_file) {
   1048   std::string temp;
   1049   const DexFile::TypeId* type_id = dex_file.FindTypeId(GetDescriptor(&temp));
   1050   return (type_id == nullptr) ? DexFile::kDexNoIndex : dex_file.GetIndexForTypeId(*type_id);
   1051 }
   1052 
   1053 template <bool kTransactionActive>
   1054 mirror::Method* Class::GetDeclaredMethodInternal(Thread* self,
   1055                                                  mirror::Class* klass,
   1056                                                  mirror::String* name,
   1057                                                  mirror::ObjectArray<mirror::Class>* args) {
   1058   // Covariant return types permit the class to define multiple
   1059   // methods with the same name and parameter types. Prefer to
   1060   // return a non-synthetic method in such situations. We may
   1061   // still return a synthetic method to handle situations like
   1062   // escalated visibility. We never return miranda methods that
   1063   // were synthesized by the runtime.
   1064   constexpr uint32_t kSkipModifiers = kAccMiranda | kAccSynthetic;
   1065   StackHandleScope<3> hs(self);
   1066   auto h_method_name = hs.NewHandle(name);
   1067   if (UNLIKELY(h_method_name.Get() == nullptr)) {
   1068     ThrowNullPointerException("name == null");
   1069     return nullptr;
   1070   }
   1071   auto h_args = hs.NewHandle(args);
   1072   Handle<mirror::Class> h_klass = hs.NewHandle(klass);
   1073   ArtMethod* result = nullptr;
   1074   const size_t pointer_size = kTransactionActive
   1075                                   ? Runtime::Current()->GetClassLinker()->GetImagePointerSize()
   1076                                   : sizeof(void*);
   1077   for (auto& m : h_klass->GetDeclaredVirtualMethods(pointer_size)) {
   1078     auto* np_method = m.GetInterfaceMethodIfProxy(pointer_size);
   1079     // May cause thread suspension.
   1080     mirror::String* np_name = np_method->GetNameAsString(self);
   1081     if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) {
   1082       if (UNLIKELY(self->IsExceptionPending())) {
   1083         return nullptr;
   1084       }
   1085       continue;
   1086     }
   1087     auto modifiers = m.GetAccessFlags();
   1088     if ((modifiers & kSkipModifiers) == 0) {
   1089       return mirror::Method::CreateFromArtMethod<kTransactionActive>(self, &m);
   1090     }
   1091     if ((modifiers & kAccMiranda) == 0) {
   1092       result = &m;  // Remember as potential result if it's not a miranda method.
   1093     }
   1094   }
   1095   if (result == nullptr) {
   1096     for (auto& m : h_klass->GetDirectMethods(pointer_size)) {
   1097       auto modifiers = m.GetAccessFlags();
   1098       if ((modifiers & kAccConstructor) != 0) {
   1099         continue;
   1100       }
   1101       auto* np_method = m.GetInterfaceMethodIfProxy(pointer_size);
   1102       // May cause thread suspension.
   1103       mirror::String* np_name = np_method->GetNameAsString(self);
   1104       if (np_name == nullptr) {
   1105         self->AssertPendingException();
   1106         return nullptr;
   1107       }
   1108       if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) {
   1109         if (UNLIKELY(self->IsExceptionPending())) {
   1110           return nullptr;
   1111         }
   1112         continue;
   1113       }
   1114       if ((modifiers & kSkipModifiers) == 0) {
   1115         return mirror::Method::CreateFromArtMethod<kTransactionActive>(self, &m);
   1116       }
   1117       // Direct methods cannot be miranda methods, so this potential result must be synthetic.
   1118       result = &m;
   1119     }
   1120   }
   1121   return result != nullptr
   1122       ? mirror::Method::CreateFromArtMethod<kTransactionActive>(self, result)
   1123       : nullptr;
   1124 }
   1125 
   1126 template
   1127 mirror::Method* Class::GetDeclaredMethodInternal<false>(Thread* self,
   1128                                                         mirror::Class* klass,
   1129                                                         mirror::String* name,
   1130                                                         mirror::ObjectArray<mirror::Class>* args);
   1131 template
   1132 mirror::Method* Class::GetDeclaredMethodInternal<true>(Thread* self,
   1133                                                        mirror::Class* klass,
   1134                                                        mirror::String* name,
   1135                                                        mirror::ObjectArray<mirror::Class>* args);
   1136 
   1137 template <bool kTransactionActive>
   1138 mirror::Constructor* Class::GetDeclaredConstructorInternal(
   1139     Thread* self,
   1140     mirror::Class* klass,
   1141     mirror::ObjectArray<mirror::Class>* args) {
   1142   StackHandleScope<1> hs(self);
   1143   const size_t pointer_size = kTransactionActive
   1144                                   ? Runtime::Current()->GetClassLinker()->GetImagePointerSize()
   1145                                   : sizeof(void*);
   1146   ArtMethod* result = klass->GetDeclaredConstructor(self, hs.NewHandle(args), pointer_size);
   1147   return result != nullptr
   1148       ? mirror::Constructor::CreateFromArtMethod<kTransactionActive>(self, result)
   1149       : nullptr;
   1150 }
   1151 
   1152 // mirror::Constructor::CreateFromArtMethod<kTransactionActive>(self, result)
   1153 
   1154 template mirror::Constructor* Class::GetDeclaredConstructorInternal<false>(
   1155     Thread* self,
   1156     mirror::Class* klass,
   1157     mirror::ObjectArray<mirror::Class>* args);
   1158 template mirror::Constructor* Class::GetDeclaredConstructorInternal<true>(
   1159     Thread* self,
   1160     mirror::Class* klass,
   1161     mirror::ObjectArray<mirror::Class>* args);
   1162 
   1163 int32_t Class::GetInnerClassFlags(Handle<Class> h_this, int32_t default_value) {
   1164   if (h_this->IsProxyClass() || h_this->GetDexCache() == nullptr) {
   1165     return default_value;
   1166   }
   1167   uint32_t flags;
   1168   if (!h_this->GetDexFile().GetInnerClassFlags(h_this, &flags)) {
   1169     return default_value;
   1170   }
   1171   return flags;
   1172 }
   1173 
   1174 }  // namespace mirror
   1175 }  // namespace art
   1176