blob: c7981804df6fd78a5142c01fd929435da4f281b8 [file] [log] [blame]
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "class.h"
18
Brian Carlstromea46f952013-07-30 01:26:50 -070019#include "art_field-inl.h"
20#include "art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080021#include "class-inl.h"
22#include "class_linker.h"
23#include "class_loader.h"
24#include "dex_cache.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070025#include "dex_file-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070026#include "gc/accounting/card_table-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080027#include "object-inl.h"
28#include "object_array-inl.h"
29#include "object_utils.h"
30#include "runtime.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070031#include "handle_scope-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080032#include "thread.h"
33#include "throwable.h"
34#include "utils.h"
35#include "well_known_classes.h"
36
37namespace art {
38namespace mirror {
39
Brian Carlstrom004644f2014-06-18 08:34:01 -070040Class* Class::java_lang_Class_ = nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080041
42void Class::SetClassClass(Class* java_lang_Class) {
Brian Carlstrom004644f2014-06-18 08:34:01 -070043 CHECK(java_lang_Class_ == nullptr) << java_lang_Class_ << " " << java_lang_Class;
44 CHECK(java_lang_Class != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080045 java_lang_Class_ = java_lang_Class;
46}
47
48void Class::ResetClass() {
Brian Carlstrom004644f2014-06-18 08:34:01 -070049 CHECK(java_lang_Class_ != nullptr);
50 java_lang_Class_ = nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080051}
52
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080053void Class::VisitRoots(RootCallback* callback, void* arg) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -080054 if (java_lang_Class_ != nullptr) {
Mathieu Chartier815873e2014-02-13 18:02:13 -080055 callback(reinterpret_cast<mirror::Object**>(&java_lang_Class_), arg, 0, kRootStickyClass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -080056 }
57}
58
Ian Rogers7dfb28c2013-08-22 08:18:36 -070059void Class::SetStatus(Status new_status, Thread* self) {
60 Status old_status = GetStatus();
Mathieu Chartier590fee92013-09-13 13:46:47 -070061 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
62 bool class_linker_initialized = class_linker != nullptr && class_linker->IsInitialized();
Ian Rogers7dfb28c2013-08-22 08:18:36 -070063 if (LIKELY(class_linker_initialized)) {
64 if (UNLIKELY(new_status <= old_status && new_status != kStatusError)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -070065 LOG(FATAL) << "Unexpected change back of class status for " << PrettyClass(this) << " "
Ian Rogers7dfb28c2013-08-22 08:18:36 -070066 << old_status << " -> " << new_status;
Ian Rogers8f3c9ae2013-08-20 17:26:41 -070067 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -070068 if (new_status >= kStatusResolved || old_status >= kStatusResolved) {
69 // When classes are being resolved the resolution code should hold the lock.
Ian Rogersd9c4fc92013-10-01 19:45:43 -070070 CHECK_EQ(GetLockOwnerThreadId(), self->GetThreadId())
Ian Rogers7dfb28c2013-08-22 08:18:36 -070071 << "Attempt to change status of class while not holding its lock: "
72 << PrettyClass(this) << " " << old_status << " -> " << new_status;
73 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080074 }
Ian Rogers98379392014-02-24 16:53:16 -080075 if (UNLIKELY(new_status == kStatusError)) {
Ian Rogers8f3c9ae2013-08-20 17:26:41 -070076 CHECK_NE(GetStatus(), kStatusError)
77 << "Attempt to set as erroneous an already erroneous class " << PrettyClass(this);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080078
Ian Rogers62d6c772013-02-27 08:32:07 -080079 // Stash current exception.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070080 StackHandleScope<3> hs(self);
81 ThrowLocation old_throw_location;
82 Handle<mirror::Throwable> old_exception(hs.NewHandle(self->GetException(&old_throw_location)));
83 CHECK(old_exception.Get() != nullptr);
84 Handle<mirror::Object> old_throw_this_object(hs.NewHandle(old_throw_location.GetThis()));
85 Handle<mirror::ArtMethod> old_throw_method(hs.NewHandle(old_throw_location.GetMethod()));
86 uint32_t old_throw_dex_pc = old_throw_location.GetDexPc();
Sebastien Hertz9f102032014-05-23 08:59:42 +020087 bool is_exception_reported = self->IsExceptionReportedToInstrumentation();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080088 // clear exception to call FindSystemClass
89 self->ClearException();
90 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogers98379392014-02-24 16:53:16 -080091 Class* eiie_class = class_linker->FindSystemClass(self,
92 "Ljava/lang/ExceptionInInitializerError;");
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080093 CHECK(!self->IsExceptionPending());
94
Ian Rogers62d6c772013-02-27 08:32:07 -080095 // Only verification errors, not initialization problems, should set a verify error.
96 // This is to ensure that ThrowEarlierClassFailure will throw NoClassDefFoundError in that case.
97 Class* exception_class = old_exception->GetClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080098 if (!eiie_class->IsAssignableFrom(exception_class)) {
99 SetVerifyErrorClass(exception_class);
100 }
101
Ian Rogers62d6c772013-02-27 08:32:07 -0800102 // Restore exception.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700103 ThrowLocation gc_safe_throw_location(old_throw_this_object.Get(), old_throw_method.Get(),
Ian Rogers62d6c772013-02-27 08:32:07 -0800104 old_throw_dex_pc);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700105 self->SetException(gc_safe_throw_location, old_exception.Get());
Sebastien Hertz9f102032014-05-23 08:59:42 +0200106 self->SetExceptionReportedToInstrumentation(is_exception_reported);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800107 }
Ian Rogers03dbc042014-06-02 14:24:56 -0700108 COMPILE_ASSERT(sizeof(Status) == sizeof(uint32_t), size_of_status_not_uint32);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100109 if (Runtime::Current()->IsActiveTransaction()) {
Ian Rogers03dbc042014-06-02 14:24:56 -0700110 SetField32Volatile<true>(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100111 } else {
Ian Rogers03dbc042014-06-02 14:24:56 -0700112 SetField32Volatile<false>(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100113 }
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700114 // Classes that are being resolved or initialized need to notify waiters that the class status
115 // changed. See ClassLinker::EnsureResolved and ClassLinker::WaitForInitializeClass.
116 if ((old_status >= kStatusResolved || new_status >= kStatusResolved) &&
117 class_linker_initialized) {
118 NotifyAll(self);
119 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800120}
121
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800122void Class::SetDexCache(DexCache* new_dex_cache) {
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700123 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), new_dex_cache);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800124}
125
Ian Rogersef7d42f2014-01-06 12:55:46 -0800126void Class::SetClassSize(uint32_t new_class_size) {
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700127 if (kIsDebugBuild && (new_class_size < GetClassSize())) {
128 DumpClass(LOG(ERROR), kDumpClassFullDetail);
129 CHECK_GE(new_class_size, GetClassSize()) << " class=" << PrettyTypeOf(this);
130 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100131 // Not called within a transaction.
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700132 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800133}
134
135// Return the class' name. The exact format is bizarre, but it's the specified behavior for
136// Class.getName: keywords for primitive types, regular "[I" form for primitive arrays (so "int"
137// but "[I"), and arrays of reference types written between "L" and ";" but with dots rather than
138// slashes (so "java.lang.String" but "[Ljava.lang.String;"). Madness.
Mathieu Chartierf8322842014-05-16 10:59:25 -0700139String* Class::ComputeName(Handle<Class> h_this) {
140 String* name = h_this->GetName();
Mathieu Chartier692fafd2013-11-29 17:24:40 -0800141 if (name != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800142 return name;
143 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700144 std::string descriptor(h_this->GetDescriptor());
Mathieu Chartier692fafd2013-11-29 17:24:40 -0800145 Thread* self = Thread::Current();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800146 if ((descriptor[0] != 'L') && (descriptor[0] != '[')) {
147 // The descriptor indicates that this is the class for
148 // a primitive type; special-case the return value.
Brian Carlstrom004644f2014-06-18 08:34:01 -0700149 const char* c_name = nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800150 switch (descriptor[0]) {
151 case 'Z': c_name = "boolean"; break;
152 case 'B': c_name = "byte"; break;
153 case 'C': c_name = "char"; break;
154 case 'S': c_name = "short"; break;
155 case 'I': c_name = "int"; break;
156 case 'J': c_name = "long"; break;
157 case 'F': c_name = "float"; break;
158 case 'D': c_name = "double"; break;
159 case 'V': c_name = "void"; break;
160 default:
161 LOG(FATAL) << "Unknown primitive type: " << PrintableChar(descriptor[0]);
162 }
Mathieu Chartier692fafd2013-11-29 17:24:40 -0800163 name = String::AllocFromModifiedUtf8(self, c_name);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800164 } else {
165 // Convert the UTF-8 name to a java.lang.String. The name must use '.' to separate package
166 // components.
167 if (descriptor.size() > 2 && descriptor[0] == 'L' && descriptor[descriptor.size() - 1] == ';') {
168 descriptor.erase(0, 1);
169 descriptor.erase(descriptor.size() - 1);
170 }
171 std::replace(descriptor.begin(), descriptor.end(), '/', '.');
Mathieu Chartier692fafd2013-11-29 17:24:40 -0800172 name = String::AllocFromModifiedUtf8(self, descriptor.c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800173 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700174 h_this->SetName(name);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800175 return name;
176}
177
Ian Rogersef7d42f2014-01-06 12:55:46 -0800178void Class::DumpClass(std::ostream& os, int flags) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800179 if ((flags & kDumpClassFullDetail) == 0) {
180 os << PrettyClass(this);
181 if ((flags & kDumpClassClassLoader) != 0) {
182 os << ' ' << GetClassLoader();
183 }
184 if ((flags & kDumpClassInitialized) != 0) {
185 os << ' ' << GetStatus();
186 }
187 os << "\n";
188 return;
189 }
190
Mathieu Chartierf8322842014-05-16 10:59:25 -0700191 Thread* self = Thread::Current();
192 StackHandleScope<2> hs(self);
193 Handle<mirror::Class> h_this(hs.NewHandle(this));
194 Handle<mirror::Class> h_super(hs.NewHandle(GetSuperClass()));
195
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800196 os << "----- " << (IsInterface() ? "interface" : "class") << " "
Mathieu Chartierf8322842014-05-16 10:59:25 -0700197 << "'" << GetDescriptor() << "' cl=" << GetClassLoader() << " -----\n",
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800198 os << " objectSize=" << SizeOf() << " "
Brian Carlstrom004644f2014-06-18 08:34:01 -0700199 << "(" << (h_super.Get() != nullptr ? h_super->SizeOf() : -1) << " from super)\n",
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800200 os << StringPrintf(" access=0x%04x.%04x\n",
201 GetAccessFlags() >> 16, GetAccessFlags() & kAccJavaFlagsMask);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700202 if (h_super.Get() != nullptr) {
Mathieu Chartierf8322842014-05-16 10:59:25 -0700203 os << " super='" << PrettyClass(h_super.Get()) << "' (cl=" << h_super->GetClassLoader()
204 << ")\n";
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800205 }
206 if (IsArrayClass()) {
207 os << " componentType=" << PrettyClass(GetComponentType()) << "\n";
208 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700209 const size_t num_direct_interfaces = NumDirectInterfaces();
210 if (num_direct_interfaces > 0) {
211 os << " interfaces (" << num_direct_interfaces << "):\n";
212 for (size_t i = 0; i < num_direct_interfaces; ++i) {
213 Class* interface = GetDirectInterface(self, h_this, i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800214 const ClassLoader* cl = interface->GetClassLoader();
215 os << StringPrintf(" %2zd: %s (cl=%p)\n", i, PrettyClass(interface).c_str(), cl);
216 }
217 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700218 // After this point, this may have moved due to GetDirectInterface.
219 os << " vtable (" << h_this->NumVirtualMethods() << " entries, "
Brian Carlstrom004644f2014-06-18 08:34:01 -0700220 << (h_super.Get() != nullptr ? h_super->NumVirtualMethods() : 0) << " in super):\n";
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800221 for (size_t i = 0; i < NumVirtualMethods(); ++i) {
Mathieu Chartierf8322842014-05-16 10:59:25 -0700222 os << StringPrintf(" %2zd: %s\n", i,
223 PrettyMethod(h_this->GetVirtualMethodDuringLinking(i)).c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800224 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700225 os << " direct methods (" << h_this->NumDirectMethods() << " entries):\n";
226 for (size_t i = 0; i < h_this->NumDirectMethods(); ++i) {
227 os << StringPrintf(" %2zd: %s\n", i, PrettyMethod(h_this->GetDirectMethod(i)).c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800228 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700229 if (h_this->NumStaticFields() > 0) {
230 os << " static fields (" << h_this->NumStaticFields() << " entries):\n";
231 if (h_this->IsResolved() || h_this->IsErroneous()) {
232 for (size_t i = 0; i < h_this->NumStaticFields(); ++i) {
233 os << StringPrintf(" %2zd: %s\n", i, PrettyField(h_this->GetStaticField(i)).c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800234 }
235 } else {
236 os << " <not yet available>";
237 }
238 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700239 if (h_this->NumInstanceFields() > 0) {
240 os << " instance fields (" << h_this->NumInstanceFields() << " entries):\n";
241 if (h_this->IsResolved() || h_this->IsErroneous()) {
242 for (size_t i = 0; i < h_this->NumInstanceFields(); ++i) {
243 os << StringPrintf(" %2zd: %s\n", i, PrettyField(h_this->GetInstanceField(i)).c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800244 }
245 } else {
246 os << " <not yet available>";
247 }
248 }
249}
250
251void Class::SetReferenceInstanceOffsets(uint32_t new_reference_offsets) {
252 if (new_reference_offsets != CLASS_WALK_SUPER) {
253 // Sanity check that the number of bits set in the reference offset bitmap
254 // agrees with the number of references
255 size_t count = 0;
Brian Carlstrom004644f2014-06-18 08:34:01 -0700256 for (Class* c = this; c != nullptr; c = c->GetSuperClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800257 count += c->NumReferenceInstanceFieldsDuringLinking();
258 }
Vladimir Marko81949632014-05-02 11:53:22 +0100259 CHECK_EQ((size_t)POPCOUNT(new_reference_offsets), count);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800260 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100261 // Not called within a transaction.
262 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_),
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700263 new_reference_offsets);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800264}
265
266void Class::SetReferenceStaticOffsets(uint32_t new_reference_offsets) {
267 if (new_reference_offsets != CLASS_WALK_SUPER) {
268 // Sanity check that the number of bits set in the reference offset bitmap
269 // agrees with the number of references
Vladimir Marko81949632014-05-02 11:53:22 +0100270 CHECK_EQ((size_t)POPCOUNT(new_reference_offsets),
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800271 NumReferenceStaticFieldsDuringLinking());
272 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100273 // Not called within a transaction.
274 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_),
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700275 new_reference_offsets);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800276}
277
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800278bool Class::IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2) {
279 size_t i = 0;
280 while (descriptor1[i] != '\0' && descriptor1[i] == descriptor2[i]) {
281 ++i;
282 }
283 if (descriptor1.find('/', i) != StringPiece::npos ||
284 descriptor2.find('/', i) != StringPiece::npos) {
285 return false;
286 } else {
287 return true;
288 }
289}
290
Ian Rogersef7d42f2014-01-06 12:55:46 -0800291bool Class::IsInSamePackage(Class* that) {
292 Class* klass1 = this;
293 Class* klass2 = that;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800294 if (klass1 == klass2) {
295 return true;
296 }
297 // Class loaders must match.
298 if (klass1->GetClassLoader() != klass2->GetClassLoader()) {
299 return false;
300 }
301 // Arrays are in the same package when their element classes are.
302 while (klass1->IsArrayClass()) {
303 klass1 = klass1->GetComponentType();
304 }
305 while (klass2->IsArrayClass()) {
306 klass2 = klass2->GetComponentType();
307 }
Anwar Ghuloum9fa3f202013-03-26 14:32:54 -0700308 // trivial check again for array types
309 if (klass1 == klass2) {
310 return true;
311 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800312 // Compare the package part of the descriptor string.
Mathieu Chartierf8322842014-05-16 10:59:25 -0700313 return IsInSamePackage(klass1->GetDescriptor().c_str(), klass2->GetDescriptor().c_str());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800314}
315
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800316bool Class::IsStringClass() const {
317 return this == String::GetJavaLangString();
318}
319
Ian Rogersef7d42f2014-01-06 12:55:46 -0800320bool Class::IsThrowableClass() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800321 return WellKnownClasses::ToClass(WellKnownClasses::java_lang_Throwable)->IsAssignableFrom(this);
322}
323
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800324void Class::SetClassLoader(ClassLoader* new_class_loader) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100325 if (Runtime::Current()->IsActiveTransaction()) {
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700326 SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100327 } else {
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700328 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100329 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800330}
331
Brian Carlstrom004644f2014-06-18 08:34:01 -0700332ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800333 // Check the current class before checking the interfaces.
Brian Carlstromea46f952013-07-30 01:26:50 -0700334 ArtMethod* method = FindDeclaredVirtualMethod(name, signature);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700335 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800336 return method;
337 }
338
339 int32_t iftable_count = GetIfTableCount();
340 IfTable* iftable = GetIfTable();
Brian Carlstrom004644f2014-06-18 08:34:01 -0700341 for (int32_t i = 0; i < iftable_count; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800342 method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(name, signature);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700343 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800344 return method;
345 }
346 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700347 return nullptr;
348}
349
350ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, const Signature& signature) {
351 // Check the current class before checking the interfaces.
352 ArtMethod* method = FindDeclaredVirtualMethod(name, signature);
353 if (method != nullptr) {
354 return method;
355 }
356
357 int32_t iftable_count = GetIfTableCount();
358 IfTable* iftable = GetIfTable();
359 for (int32_t i = 0; i < iftable_count; ++i) {
360 method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(name, signature);
361 if (method != nullptr) {
362 return method;
363 }
364 }
365 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800366}
367
Ian Rogersef7d42f2014-01-06 12:55:46 -0800368ArtMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800369 // Check the current class before checking the interfaces.
Brian Carlstromea46f952013-07-30 01:26:50 -0700370 ArtMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700371 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800372 return method;
373 }
374
375 int32_t iftable_count = GetIfTableCount();
376 IfTable* iftable = GetIfTable();
Brian Carlstrom004644f2014-06-18 08:34:01 -0700377 for (int32_t i = 0; i < iftable_count; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800378 method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700379 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800380 return method;
381 }
382 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700383 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800384}
385
Ian Rogersef7d42f2014-01-06 12:55:46 -0800386ArtMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800387 for (size_t i = 0; i < NumDirectMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700388 ArtMethod* method = GetDirectMethod(i);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700389 if (name == method->GetName() && method->GetSignature() == signature) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700390 return method;
391 }
392 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700393 return nullptr;
Ian Rogersd91d6d62013-09-25 20:26:14 -0700394}
395
Ian Rogersef7d42f2014-01-06 12:55:46 -0800396ArtMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const Signature& signature) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700397 for (size_t i = 0; i < NumDirectMethods(); ++i) {
398 ArtMethod* method = GetDirectMethod(i);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700399 if (name == method->GetName() && signature == method->GetSignature()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800400 return method;
401 }
402 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700403 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800404}
405
Ian Rogersef7d42f2014-01-06 12:55:46 -0800406ArtMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800407 if (GetDexCache() == dex_cache) {
408 for (size_t i = 0; i < NumDirectMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700409 ArtMethod* method = GetDirectMethod(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800410 if (method->GetDexMethodIndex() == dex_method_idx) {
411 return method;
412 }
413 }
414 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700415 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800416}
417
Ian Rogersef7d42f2014-01-06 12:55:46 -0800418ArtMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700419 for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700420 ArtMethod* method = klass->FindDeclaredDirectMethod(name, signature);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700421 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800422 return method;
423 }
424 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700425 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800426}
427
Ian Rogersef7d42f2014-01-06 12:55:46 -0800428ArtMethod* Class::FindDirectMethod(const StringPiece& name, const Signature& signature) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700429 for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700430 ArtMethod* method = klass->FindDeclaredDirectMethod(name, signature);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700431 if (method != nullptr) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700432 return method;
433 }
434 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700435 return nullptr;
Ian Rogersd91d6d62013-09-25 20:26:14 -0700436}
437
Ian Rogersef7d42f2014-01-06 12:55:46 -0800438ArtMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700439 for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700440 ArtMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700441 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800442 return method;
443 }
444 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700445 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800446}
447
Ian Rogersef7d42f2014-01-06 12:55:46 -0800448ArtMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700449 for (size_t i = 0; i < NumVirtualMethods(); ++i) {
450 ArtMethod* method = GetVirtualMethod(i);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700451 if (name == method->GetName() && method->GetSignature() == signature) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700452 return method;
453 }
454 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700455 return nullptr;
Ian Rogersd91d6d62013-09-25 20:26:14 -0700456}
457
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700458ArtMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name, const Signature& signature) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800459 for (size_t i = 0; i < NumVirtualMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700460 ArtMethod* method = GetVirtualMethod(i);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700461 if (name == method->GetName() && signature == method->GetSignature()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800462 return method;
463 }
464 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700465 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800466}
467
Ian Rogersef7d42f2014-01-06 12:55:46 -0800468ArtMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800469 if (GetDexCache() == dex_cache) {
470 for (size_t i = 0; i < NumVirtualMethods(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700471 ArtMethod* method = GetVirtualMethod(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800472 if (method->GetDexMethodIndex() == dex_method_idx) {
473 return method;
474 }
475 }
476 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700477 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800478}
479
Ian Rogersef7d42f2014-01-06 12:55:46 -0800480ArtMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700481 for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700482 ArtMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700483 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800484 return method;
485 }
486 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700487 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800488}
489
Ian Rogersef7d42f2014-01-06 12:55:46 -0800490ArtMethod* Class::FindVirtualMethod(const StringPiece& name, const Signature& signature) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700491 for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700492 ArtMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700493 if (method != nullptr) {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700494 return method;
495 }
496 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700497 return nullptr;
Ian Rogersd91d6d62013-09-25 20:26:14 -0700498}
499
Ian Rogersef7d42f2014-01-06 12:55:46 -0800500ArtMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700501 for (Class* klass = this; klass != nullptr; klass = klass->GetSuperClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700502 ArtMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700503 if (method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800504 return method;
505 }
506 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700507 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800508}
509
Ian Rogersef7d42f2014-01-06 12:55:46 -0800510ArtMethod* Class::FindClassInitializer() {
Ian Rogersd91d6d62013-09-25 20:26:14 -0700511 for (size_t i = 0; i < NumDirectMethods(); ++i) {
512 ArtMethod* method = GetDirectMethod(i);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700513 if (method->IsClassInitializer()) {
514 DCHECK_STREQ(method->GetName(), "<clinit>");
515 DCHECK_STREQ(method->GetSignature().ToString().c_str(), "()V");
Ian Rogersd91d6d62013-09-25 20:26:14 -0700516 return method;
517 }
518 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700519 return nullptr;
Ian Rogersd91d6d62013-09-25 20:26:14 -0700520}
521
Brian Carlstromea46f952013-07-30 01:26:50 -0700522ArtField* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800523 // Is the field in this class?
524 // Interfaces are not relevant because they can't contain instance fields.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800525 for (size_t i = 0; i < NumInstanceFields(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700526 ArtField* f = GetInstanceField(i);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700527 if (name == f->GetName() && type == f->GetTypeDescriptor()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800528 return f;
529 }
530 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700531 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800532}
533
Brian Carlstromea46f952013-07-30 01:26:50 -0700534ArtField* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800535 if (GetDexCache() == dex_cache) {
536 for (size_t i = 0; i < NumInstanceFields(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700537 ArtField* f = GetInstanceField(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800538 if (f->GetDexFieldIndex() == dex_field_idx) {
539 return f;
540 }
541 }
542 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700543 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800544}
545
Brian Carlstromea46f952013-07-30 01:26:50 -0700546ArtField* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800547 // Is the field in this class, or any of its superclasses?
548 // Interfaces are not relevant because they can't contain instance fields.
Brian Carlstrom004644f2014-06-18 08:34:01 -0700549 for (Class* c = this; c != nullptr; c = c->GetSuperClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700550 ArtField* f = c->FindDeclaredInstanceField(name, type);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700551 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800552 return f;
553 }
554 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700555 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800556}
557
Brian Carlstromea46f952013-07-30 01:26:50 -0700558ArtField* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800559 // Is the field in this class, or any of its superclasses?
560 // Interfaces are not relevant because they can't contain instance fields.
Brian Carlstrom004644f2014-06-18 08:34:01 -0700561 for (Class* c = this; c != nullptr; c = c->GetSuperClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700562 ArtField* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700563 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800564 return f;
565 }
566 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700567 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800568}
569
Brian Carlstromea46f952013-07-30 01:26:50 -0700570ArtField* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700571 DCHECK(type != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800572 for (size_t i = 0; i < NumStaticFields(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700573 ArtField* f = GetStaticField(i);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700574 if (name == f->GetName() && type == f->GetTypeDescriptor()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800575 return f;
576 }
577 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700578 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800579}
580
Brian Carlstromea46f952013-07-30 01:26:50 -0700581ArtField* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800582 if (dex_cache == GetDexCache()) {
583 for (size_t i = 0; i < NumStaticFields(); ++i) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700584 ArtField* f = GetStaticField(i);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800585 if (f->GetDexFieldIndex() == dex_field_idx) {
586 return f;
587 }
588 }
589 }
Brian Carlstrom004644f2014-06-18 08:34:01 -0700590 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800591}
592
Mathieu Chartierf8322842014-05-16 10:59:25 -0700593ArtField* Class::FindStaticField(Thread* self, Handle<Class> klass, const StringPiece& name,
594 const StringPiece& type) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800595 // Is the field in this class (or its interfaces), or any of its
596 // superclasses (or their interfaces)?
Mathieu Chartierf8322842014-05-16 10:59:25 -0700597 for (Class* k = klass.Get(); k != nullptr; k = k->GetSuperClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800598 // Is the field in this class?
Brian Carlstromea46f952013-07-30 01:26:50 -0700599 ArtField* f = k->FindDeclaredStaticField(name, type);
Mathieu Chartierf8322842014-05-16 10:59:25 -0700600 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800601 return f;
602 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700603 // Wrap k incase it moves during GetDirectInterface.
604 StackHandleScope<1> hs(self);
605 HandleWrapper<mirror::Class> h_k(hs.NewHandleWrapper(&k));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800606 // Is this field in any of this class' interfaces?
Mathieu Chartierf8322842014-05-16 10:59:25 -0700607 for (uint32_t i = 0; i < h_k->NumDirectInterfaces(); ++i) {
608 StackHandleScope<1> hs(self);
609 Handle<mirror::Class> interface(hs.NewHandle(GetDirectInterface(self, h_k, i)));
610 f = FindStaticField(self, interface, name, type);
611 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800612 return f;
613 }
614 }
615 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700616 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800617}
618
Mathieu Chartierf8322842014-05-16 10:59:25 -0700619ArtField* Class::FindStaticField(Thread* self, Handle<Class> klass, const DexCache* dex_cache,
620 uint32_t dex_field_idx) {
621 for (Class* k = klass.Get(); k != nullptr; k = k->GetSuperClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800622 // Is the field in this class?
Brian Carlstromea46f952013-07-30 01:26:50 -0700623 ArtField* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700624 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800625 return f;
626 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700627 // Wrap k incase it moves during GetDirectInterface.
628 StackHandleScope<1> hs(self);
629 HandleWrapper<mirror::Class> h_k(hs.NewHandleWrapper(&k));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800630 // Is this field in any of this class' interfaces?
Mathieu Chartierf8322842014-05-16 10:59:25 -0700631 for (uint32_t i = 0; i < h_k->NumDirectInterfaces(); ++i) {
632 StackHandleScope<1> hs(self);
633 Handle<mirror::Class> interface(hs.NewHandle(GetDirectInterface(self, h_k, i)));
634 f = FindStaticField(self, interface, dex_cache, dex_field_idx);
635 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800636 return f;
637 }
638 }
639 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700640 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800641}
642
Mathieu Chartierf8322842014-05-16 10:59:25 -0700643ArtField* Class::FindField(Thread* self, Handle<Class> klass, const StringPiece& name,
644 const StringPiece& type) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800645 // Find a field using the JLS field resolution order
Brian Carlstrom004644f2014-06-18 08:34:01 -0700646 for (Class* k = klass.Get(); k != nullptr; k = k->GetSuperClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800647 // Is the field in this class?
Brian Carlstromea46f952013-07-30 01:26:50 -0700648 ArtField* f = k->FindDeclaredInstanceField(name, type);
Mathieu Chartierf8322842014-05-16 10:59:25 -0700649 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800650 return f;
651 }
652 f = k->FindDeclaredStaticField(name, type);
Mathieu Chartierf8322842014-05-16 10:59:25 -0700653 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800654 return f;
655 }
656 // Is this field in any of this class' interfaces?
Mathieu Chartierf8322842014-05-16 10:59:25 -0700657 StackHandleScope<1> hs(self);
658 HandleWrapper<mirror::Class> h_k(hs.NewHandleWrapper(&k));
659 for (uint32_t i = 0; i < h_k->NumDirectInterfaces(); ++i) {
660 StackHandleScope<1> hs(self);
661 Handle<mirror::Class> interface(hs.NewHandle(GetDirectInterface(self, h_k, i)));
662 f = interface->FindStaticField(self, interface, name, type);
663 if (f != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800664 return f;
665 }
666 }
667 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700668 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800669}
670
Brian Carlstromea46f952013-07-30 01:26:50 -0700671static void SetPreverifiedFlagOnMethods(mirror::ObjectArray<mirror::ArtMethod>* methods)
Sebastien Hertz233ea8e2013-06-06 11:57:09 +0200672 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Brian Carlstrom004644f2014-06-18 08:34:01 -0700673 if (methods != nullptr) {
Sebastien Hertz233ea8e2013-06-06 11:57:09 +0200674 for (int32_t index = 0, end = methods->GetLength(); index < end; ++index) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700675 mirror::ArtMethod* method = methods->GetWithoutChecks(index);
Brian Carlstrom004644f2014-06-18 08:34:01 -0700676 DCHECK(method != nullptr);
Ian Rogers1eb512d2013-10-18 15:42:20 -0700677 if (!method->IsNative() && !method->IsAbstract()) {
678 method->SetPreverified();
679 }
Sebastien Hertz233ea8e2013-06-06 11:57:09 +0200680 }
681 }
682}
683
684void Class::SetPreverifiedFlagOnAllMethods() {
685 DCHECK(IsVerified());
686 SetPreverifiedFlagOnMethods(GetDirectMethods());
687 SetPreverifiedFlagOnMethods(GetVirtualMethods());
688}
689
Mathieu Chartierf8322842014-05-16 10:59:25 -0700690std::string Class::GetDescriptor() {
691 if (UNLIKELY(IsArrayClass())) {
692 return GetArrayDescriptor();
693 } else if (UNLIKELY(IsPrimitive())) {
694 return Primitive::Descriptor(GetPrimitiveType());
695 } else if (UNLIKELY(IsProxyClass())) {
696 return Runtime::Current()->GetClassLinker()->GetDescriptorForProxy(this);
697 } else {
698 const DexFile& dex_file = GetDexFile();
699 const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
700 return dex_file.GetTypeDescriptor(type_id);
701 }
702}
703
704std::string Class::GetArrayDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
705 return "[" + GetComponentType()->GetDescriptor();
706}
707
708const DexFile::ClassDef* Class::GetClassDef() {
709 uint16_t class_def_idx = GetDexClassDefIndex();
710 if (class_def_idx == DexFile::kDexNoIndex16) {
711 return nullptr;
712 }
713 return &GetDexFile().GetClassDef(class_def_idx);
714}
715
716uint32_t Class::NumDirectInterfaces() {
717 if (IsPrimitive()) {
718 return 0;
719 } else if (IsArrayClass()) {
720 return 2;
721 } else if (IsProxyClass()) {
722 mirror::SynthesizedProxyClass* proxy_class=
723 reinterpret_cast<mirror::SynthesizedProxyClass*>(this);
724 mirror::ObjectArray<mirror::Class>* interfaces = proxy_class->GetInterfaces();
725 return interfaces != nullptr ? interfaces->GetLength() : 0;
726 } else {
727 const DexFile::TypeList* interfaces = GetInterfaceTypeList();
728 if (interfaces == nullptr) {
729 return 0;
730 } else {
731 return interfaces->Size();
732 }
733 }
734}
735
736uint16_t Class::GetDirectInterfaceTypeIdx(uint32_t idx) {
737 DCHECK(!IsPrimitive());
738 DCHECK(!IsArrayClass());
739 return GetInterfaceTypeList()->GetTypeItem(idx).type_idx_;
740}
741
742mirror::Class* Class::GetDirectInterface(Thread* self, Handle<mirror::Class> klass, uint32_t idx) {
743 DCHECK(klass.Get() != nullptr);
744 DCHECK(!klass->IsPrimitive());
745 if (klass->IsArrayClass()) {
746 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
747 if (idx == 0) {
748 return class_linker->FindSystemClass(self, "Ljava/lang/Cloneable;");
749 } else {
750 DCHECK_EQ(1U, idx);
751 return class_linker->FindSystemClass(self, "Ljava/io/Serializable;");
752 }
753 } else if (klass->IsProxyClass()) {
754 mirror::SynthesizedProxyClass* proxy_class =
755 reinterpret_cast<mirror::SynthesizedProxyClass*>(klass.Get());
756 mirror::ObjectArray<mirror::Class>* interfaces = proxy_class->GetInterfaces();
757 DCHECK(interfaces != nullptr);
758 return interfaces->Get(idx);
759 } else {
760 uint16_t type_idx = klass->GetDirectInterfaceTypeIdx(idx);
761 mirror::Class* interface = klass->GetDexCache()->GetResolvedType(type_idx);
762 if (interface == nullptr) {
763 interface = Runtime::Current()->GetClassLinker()->ResolveType(klass->GetDexFile(), type_idx,
764 klass.Get());
765 CHECK(interface != nullptr || self->IsExceptionPending());
766 }
767 return interface;
768 }
769}
770
771const char* Class::GetSourceFile() {
772 std::string descriptor(GetDescriptor());
773 const DexFile& dex_file = GetDexFile();
774 const DexFile::ClassDef* dex_class_def = GetClassDef();
Sebastien Hertz4206eb52014-06-05 10:15:45 +0200775 if (dex_class_def == nullptr) {
776 // Generated classes have no class def.
777 return nullptr;
778 }
Mathieu Chartierf8322842014-05-16 10:59:25 -0700779 return dex_file.GetSourceFile(*dex_class_def);
780}
781
782std::string Class::GetLocation() {
783 mirror::DexCache* dex_cache = GetDexCache();
784 if (dex_cache != nullptr && !IsProxyClass()) {
785 return dex_cache->GetLocation()->ToModifiedUtf8();
786 }
787 // Arrays and proxies are generated and have no corresponding dex file location.
788 return "generated class";
789}
790
791const DexFile::TypeList* Class::GetInterfaceTypeList() {
792 const DexFile::ClassDef* class_def = GetClassDef();
793 if (class_def == nullptr) {
794 return nullptr;
795 }
796 return GetDexFile().GetInterfacesList(*class_def);
797}
798
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800799} // namespace mirror
800} // namespace art