Lines Matching defs:self
97 Thread* self = Thread::Current();
98 self->ThrowNewExceptionV("Ljava/lang/NoClassDefFoundError;", fmt, args);
103 Thread* self, ClassLinker* class_linker, const char* descriptor) {
104 ArtMethod* method = self->GetCurrentMethod(nullptr);
105 StackHandleScope<1> hs(self);
109 mirror::Class* exception_class = class_linker->FindClass(self, descriptor, class_loader);
113 CHECK(self->IsExceptionPending());
114 self->ClearException();
134 Thread* self = Thread::Current();
138 self->SetException(pre_allocated);
146 if (HasInitWithString(self, this, descriptor)) {
147 self->ThrowNewException(descriptor, PrettyDescriptor(c).c_str());
149 self->ThrowNewException(descriptor, nullptr);
152 self->ThrowNewException("Ljava/lang/NoClassDefFoundError;",
169 Thread* self = Thread::Current();
170 JNIEnv* env = self->GetJniEnv();
181 self->ThrowNewWrappedException("Ljava/lang/ExceptionInInitializerError;", nullptr);
291 Thread* const self = Thread::Current();
303 heap->IncrementDisableMovingGC(self);
304 StackHandleScope<64> hs(self); // 64 is picked arbitrarily.
307 heap->AllocNonMovableObject<true>(self, nullptr, class_class_size, VoidFunctor()))));
316 heap->DecrementDisableMovingGC(self);
322 AllocClass(self, java_lang_Class.Get(), class_array_class_size)));
327 AllocClass(self, java_lang_Class.Get(), mirror::Object::ClassSize(image_pointer_size_))));
331 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusLoaded, self);
335 AllocClass(self, java_lang_Class.Get(),
341 AllocClass(self, java_lang_Class.Get(),
352 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
358 AllocClass(self, java_lang_Class.Get(), mirror::String::ClassSize(image_pointer_size_))));
360 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusResolved, self);
365 AllocClass(self, java_lang_Class.Get(), mirror::Reference::ClassSize(image_pointer_size_))));
368 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusResolved, self);
372 mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.Get(),
384 SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
385 SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
386 SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
387 SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
388 SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
389 SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
390 SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
391 SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
394 array_iftable_ = GcRoot<mirror::IfTable>(AllocIfTable(self, 2));
398 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
405 AllocClass(self, java_lang_Class.Get(), mirror::Array::ClassSize(image_pointer_size_))));
414 AllocClass(self, java_lang_Class.Get(), mirror::DexCache::ClassSize(image_pointer_size_))));
417 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusResolved, self);
421 AllocClass(self, java_lang_Class.Get(),
437 AppendToBootClassPath(self, *dex_file);
458 mirror::Class::SetStatus(java_lang_Object, mirror::Class::kStatusNotReady, self);
459 CHECK_EQ(java_lang_Object.Get(), FindSystemClass(self, "Ljava/lang/Object;"));
461 mirror::Class::SetStatus(java_lang_String, mirror::Class::kStatusNotReady, self);
462 mirror::Class* String_class = FindSystemClass(self, "Ljava/lang/String;");
469 mirror::Class::SetStatus(java_lang_DexCache, mirror::Class::kStatusNotReady, self);
470 CHECK_EQ(java_lang_DexCache.Get(), FindSystemClass(self, "Ljava/lang/DexCache;"));
474 SetClassRoot(kBooleanArrayClass, FindSystemClass(self, "[Z"));
477 SetClassRoot(kByteArrayClass, FindSystemClass(self, "[B"));
480 CHECK_EQ(char_array_class.Get(), FindSystemClass(self, "[C"));
482 SetClassRoot(kShortArrayClass, FindSystemClass(self, "[S"));
485 CHECK_EQ(int_array_class.Get(), FindSystemClass(self, "[I"));
487 CHECK_EQ(long_array_class.Get(), FindSystemClass(self, "[J"));
489 SetClassRoot(kFloatArrayClass, FindSystemClass(self, "[F"));
492 SetClassRoot(kDoubleArrayClass, FindSystemClass(self, "[D"));
495 CHECK_EQ(class_array_class.Get(), FindSystemClass(self, "[Ljava/lang/Class;"));
497 CHECK_EQ(object_array_class.Get(), FindSystemClass(self, "[Ljava/lang/Object;"));
500 auto java_lang_Cloneable = hs.NewHandle(FindSystemClass(self, "Ljava/lang/Cloneable;"));
502 auto java_io_Serializable = hs.NewHandle(FindSystemClass(self, "Ljava/io/Serializable;"));
512 mirror::Class::GetDirectInterface(self, class_array_class, 0));
514 mirror::Class::GetDirectInterface(self, class_array_class, 1));
516 mirror::Class::GetDirectInterface(self, object_array_class, 0));
518 mirror::Class::GetDirectInterface(self, object_array_class, 1));
521 CHECK_EQ(java_lang_Class.Get(), FindSystemClass(self, "Ljava/lang/Class;"));
524 FindSystemClass(self, GetClassRootDescriptor(kJavaLangStringArrayClass)));
529 SetClassRoot(kJavaLangReflectProxy, FindSystemClass(self, "Ljava/lang/reflect/Proxy;"));
532 auto* class_root = FindSystemClass(self, "Ljava/lang/reflect/Field;");
538 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Field;");
544 class_root = FindSystemClass(self, "Ljava/lang/reflect/Constructor;");
548 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Constructor;");
554 class_root = FindSystemClass(self, "Ljava/lang/reflect/Method;");
558 class_root = FindSystemClass(self, "[Ljava/lang/reflect/Method;");
565 mirror::Class::SetStatus(java_lang_ref_Reference, mirror::Class::kStatusNotReady, self);
566 CHECK_EQ(java_lang_ref_Reference.Get(), FindSystemClass(self, "Ljava/lang/ref/Reference;"));
570 class_root = FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
573 class_root = FindSystemClass(self, "Ljava/lang/ref/PhantomReference;");
576 class_root = FindSystemClass(self, "Ljava/lang/ref/SoftReference;");
578 class_root = FindSystemClass(self, "Ljava/lang/ref/WeakReference;");
583 class_root = FindSystemClass(self, "Ljava/lang/ClassLoader;");
589 SetClassRoot(kJavaLangThrowable, FindSystemClass(self, "Ljava/lang/Throwable;"));
592 FindSystemClass(self, "Ljava/lang/ClassNotFoundException;"));
593 SetClassRoot(kJavaLangStackTraceElement, FindSystemClass(self, "Ljava/lang/StackTraceElement;"));
595 FindSystemClass(self, "[Ljava/lang/StackTraceElement;"));
612 self->AssertNoPendingException();
615 FinishInit(self);
620 void ClassLinker::FinishInit(Thread* self) {
629 FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;");
671 Thread* self = Thread::Current();
675 StackHandleScope<1> hs(self);
677 EnsureInitialized(self, h_class, true, true);
678 self->AssertNoPendingException();
1105 Thread* const self = Thread::Current();
1125 StackHandleScope<1> hs(self);
1138 StackHandleScope<1> hs2(self);
1235 FinishInit(self);
1319 Thread* const self = Thread::Current();
1321 ReaderMutexLock mu(self, dex_lock_);
1402 Thread* self = Thread::Current();
1403 StackHandleScope<1> hs(self);
1414 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
1418 mirror::Class* array_of_class = FindArrayClass(self, &class_type);
1420 mirror::ObjectArray<mirror::Class>::Alloc(self, array_of_class, class_table_size));
1461 mirror::PointerArray* ClassLinker::AllocPointerArray(Thread* self, size_t length) {
1463 static_cast<mirror::Array*>(mirror::LongArray::Alloc(self, length)) :
1464 static_cast<mirror::Array*>(mirror::IntArray::Alloc(self, length)));
1467 mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
1468 StackHandleScope<6> hs(self);
1470 GetClassRoot(kJavaLangDexCache)->AllocObject(self))));
1472 self->AssertPendingOOMException();
1477 self->AssertPendingOOMException();
1480 auto strings(hs.NewHandle(AllocStringArray(self, dex_file.NumStringIds())));
1482 self->AssertPendingOOMException();
1485 auto types(hs.NewHandle(AllocClassArray(self, dex_file.NumTypeIds())));
1487 self->AssertPendingOOMException();
1490 auto methods(hs.NewHandle(AllocPointerArray(self, dex_file.NumMethodIds())));
1492 self->AssertPendingOOMException();
1495 auto fields(hs.NewHandle(AllocPointerArray(self, dex_file.NumFieldIds())));
1497 self->AssertPendingOOMException();
1505 mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
1511 heap->AllocObject<true>(self, java_lang_Class, class_size, visitor) :
1512 heap->AllocNonMovableObject<true>(self, java_lang_Class, class_size, visitor);
1514 self->AssertPendingOOMException();
1520 mirror::Class* ClassLinker::AllocClass(Thread* self, uint32_t class_size) {
1521 return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
1525 Thread* self, size_t length) {
1527 self, GetClassRoot(kJavaLangStackTraceElementArrayClass), length);
1530 mirror::Class* ClassLinker::EnsureResolved(Thread* self, const char* descriptor,
1541 StackHandleScope<1> hs(self);
1543 ObjectLock<mirror::Class> lock(self, h_class);
1554 klass = LookupClass(self, descriptor, ComputeModifiedUtf8Hash(descriptor),
1560 StackHandleScope<1> hs(self);
1562 ObjectLock<mirror::Class> lock(self, h_class);
1564 if (!h_class->IsResolved() && h_class->GetClinitThreadId() == self->GetTid()) {
1566 mirror::Class::SetStatus(h_class, mirror::Class::kStatusError, self);
1581 self->AssertNoPendingException();
1608 Thread* self, const char* descriptor,
1617 mirror::Class* klass = LookupClass(self, descriptor, hash, nullptr);
1619 *result = EnsureResolved(self, descriptor, klass);
1621 *result = DefineClass(self, descriptor, hash, NullHandle<mirror::ClassLoader>(),
1625 CHECK(self->IsExceptionPending()) << descriptor;
1626 self->ClearException();
1642 StackHandleScope<4> hs(self);
1644 bool recursive_result = FindClassInPathClassLoader(soa, self, descriptor, hash, h_parent, result);
1697 mirror::Class* klass = DefineClass(self, descriptor, hash, class_loader,
1700 CHECK(self->IsExceptionPending()) << descriptor;
1701 self->ClearException();
1712 self->AssertNoPendingException();
1719 mirror::Class* ClassLinker::FindClass(Thread* self, const char* descriptor,
1722 DCHECK(self != nullptr);
1723 self->AssertNoPendingException();
1731 mirror::Class* klass = LookupClass(self, descriptor, hash, class_loader.Get());
1733 return EnsureResolved(self, descriptor, klass);
1737 return CreateArrayClass(self, descriptor, hash, class_loader);
1742 return DefineClass(self, descriptor, hash, NullHandle<mirror::ClassLoader>(), *pair.first,
1749 self->SetException(pre_allocated);
1753 ScopedObjectAccessUnchecked soa(self);
1755 if (FindClassInPathClassLoader(soa, self, descriptor, hash, class_loader, &cp_klass)) {
1771 self->SetException(pre_allocated);
1780 ScopedThreadStateChange tsc(self, kNative);
1784 DCHECK(self->IsExceptionPending()); // OOME.
1792 if (self->IsExceptionPending()) {
1808 mirror::Class* ClassLinker::DefineClass(Thread* self, const char* descriptor, size_t hash,
1812 StackHandleScope<3> hs(self);
1836 klass.Assign(AllocClass(self, SizeOfClassWithoutEmbeddedTables(dex_file, dex_class_def)));
1839 CHECK(self->IsExceptionPending()); // Expect an OOME.
1853 ObjectLock<mirror::Class> lock(self, klass);
1854 klass->SetClinitThreadId(self->GetTid());
1861 return EnsureResolved(self, descriptor, existing);
1868 LoadClass(self, dex_file, dex_class_def, klass);
1869 if (self->IsExceptionPending()) {
1873 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
1883 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
1894 if (!LinkClass(self, descriptor, klass, interfaces, &h_new_class)) {
1897 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
1901 self->AssertNoPendingException();
1913 DCHECK_EQ(self->GetState(), kRunnable);
2269 void ClassLinker::LoadClass(Thread* self, const DexFile& dex_file,
2281 LoadClassMembers(self, dex_file, class_data, klass, &oat_class);
2285 LoadClassMembers(self, dex_file, class_data, klass, nullptr);
2289 ArtField* ClassLinker::AllocArtFieldArray(Thread* self, size_t length) {
2291 auto* ptr = reinterpret_cast<ArtField*>(la->AllocArray<ArtField>(self, length));
2297 ArtMethod* ClassLinker::AllocArtMethodArray(Thread* self, size_t length) {
2300 Runtime::Current()->GetLinearAlloc()->Alloc(self, method_size * length));
2308 void ClassLinker::LoadClassMembers(Thread* self, const DexFile& dex_file,
2315 ScopedAssertNoThreadSuspension nts(self, __FUNCTION__);
2319 ArtField* sfields = num_sfields != 0 ? AllocArtFieldArray(self, num_sfields) : nullptr;
2329 ArtField* ifields = num_ifields != 0 ? AllocArtFieldArray(self, num_ifields) : nullptr;
2339 klass->SetDirectMethodsPtr(AllocArtMethodArray(self, it.NumDirectMethods()));
2343 klass->SetVirtualMethodsPtr(AllocArtMethodArray(self
2351 LoadMethod(self, dex_file, it, klass, method);
2366 LoadMethod(self, dex_file, it, klass, method);
2373 self->AllowThreadSuspension();
2384 void ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file, const ClassDataItemIterator& it,
2390 ScopedAssertNoThreadSuspension ants(self, "LoadMethod");
2437 void ClassLinker::AppendToBootClassPath(Thread* self, const DexFile& dex_file) {
2438 StackHandleScope<1> hs(self);
2439 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache(self, dex_file)));
2483 Thread* self = Thread::Current();
2485 ReaderMutexLock mu(self, dex_lock_);
2493 StackHandleScope<1> hs(self);
2494 Handle<mirror::DexCache> dex_cache(hs.NewHandle(AllocDexCache(self, dex_file)));
2498 WriterMutexLock mu(self, dex_lock_);
2545 mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
2546 mirror::Class* klass = AllocClass(self, mirror::Class::PrimitiveClassSize(image_pointer_size_));
2548 self->AssertPendingOOMException();
2558 Thread* self = Thread::Current();
2559 StackHandleScope<1> hs(self);
2561 ObjectLock<mirror::Class> lock(self, h_class);
2564 mirror::Class::SetStatus(h_class, mirror::Class::kStatusInitialized, self);
2585 mirror::Class* ClassLinker::CreateArrayClass(Thread* self, const char* descriptor, size_t hash,
2589 StackHandleScope<2> hs(self);
2590 MutableHandle<mirror::Class> component_type(hs.NewHandle(FindClass(self, descriptor + 1,
2593 DCHECK(self->IsExceptionPending());
2596 component_type.Assign(LookupClass(self, descriptor + 1, component_hash, class_loader.Get()));
2598 DCHECK(self->IsExceptionPending());
2601 self->ClearException();
2626 mirror::Class* new_class = LookupClass(self, descriptor, hash, component_type->GetClassLoader());
2658 new_class.Assign(AllocClass(self, mirror::Array::ClassSize(image_pointer_size_)));
2660 self->AssertPendingOOMException();
2665 ObjectLock<mirror::Class> lock(self, new_class); // Must hold lock on object when initializing.
2672 mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self);
2678 mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self);
2846 mirror::Class* ClassLinker::LookupClass(Thread* self, const char* descriptor, size_t hash,
2849 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
2898 Thread* self = Thread::Current();
2899 WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
2903 ScopedAssertNoThreadSuspension ants(self, "Moving image classes to class table");
2995 void ClassLinker::VerifyClass(Thread* self, Handle<mirror::Class> klass) {
2997 ObjectLock<mirror::Class> lock(self, klass);
3016 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifying, self);
3021 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerifyingAtRuntime, self);
3026 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
3032 StackHandleScope<2> hs(self);
3036 ObjectLock<mirror::Class> super_lock(self, super);
3039 VerifyClass(self, super);
3047 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
3049 self->ClearException();
3053 self->GetException()->SetCause(cause.Get());
3059 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3074 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3080 verifier_failure = verifier::MethodVerifier::VerifyClass(self, klass.Get(),
3090 self->AssertNoPendingException();
3097 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
3100 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
3110 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetryVerificationAtRuntime, self);
3112 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, self);
3122 self->AssertNoPendingException();
3124 self);
3270 Thread* self = soa.Self();
3271 StackHandleScope<10> hs(self);
3273 AllocClass(self, GetClassRoot(kJavaLangClass), sizeof(mirror::Class))));
3275 CHECK(self->IsExceptionPending()); // OOME.
3286 mirror::Class::SetStatus(klass, mirror::Class::kStatusIdx, self);
3299 ArtField* sfields = AllocArtFieldArray(self, num_fields);
3317 auto* directs = AllocArtMethodArray(self, 1);
3321 self->AssertPendingOOMException();
3333 auto* virtuals = AllocArtMethodArray(self, num_virtual_methods);
3337 self->AssertPendingOOMException();
3353 mirror::Class::SetStatus(klass, mirror::Class::kStatusLoaded, self);
3354 self->AssertNoPendingException();
3359 ObjectLock<mirror::Class> resolution_lock(self, klass);
3364 if (!LinkClass(self, descriptor.c_str(), klass, h_interfaces, &new_class)) {
3365 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3382 ObjectLock<mirror::Class> initialization_lock(self, klass);
3383 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
3397 StackHandleScope<1> hs2(self);
3547 bool ClassLinker::InitializeClass(Thread* self, Handle<mirror::Class> klass,
3563 self->AllowThreadSuspension();
3566 ObjectLock<mirror::Class> lock(self, klass);
3583 VerifyClass(self, klass);
3588 CHECK(self->IsExceptionPending());
3596 self->AssertNoPendingException();
3607 if (self->IsExceptionPending()) {
3612 if (klass->GetClinitThreadId() == self->GetTid()) {
3617 return WaitForInitializeClass(klass, self, lock);
3621 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3624 self->AllowThreadSuspension();
3630 klass->SetClinitThreadId(self->GetTid());
3631 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitializing, self);
3642 StackHandleScope<1> hs(self);
3644 bool super_initialized = InitializeClass(self, handle_scope_super, can_init_statics, true);
3648 CHECK(handle_scope_super->IsErroneous() && self->IsExceptionPending())
3653 << (self->GetException() != nullptr ? self->GetException()->Dump() : "");
3654 ObjectLock<mirror::Class> lock(self, klass);
3656 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3667 StackHandleScope<3> hs(self);
3708 clinit->Invoke(self, nullptr, 0, &result, "V");
3711 self->AllowThreadSuspension();
3716 ObjectLock<mirror::Class> lock(self, klass);
3718 if (self->IsExceptionPending()) {
3720 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3727 Runtime::Current()->ThrowTransactionAbortError(self);
3728 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3732 RuntimeStats* thread_stats = self->GetStats();
3738 mirror::Class::SetStatus(klass, mirror::Class::kStatusInitialized, self);
3751 bool ClassLinker::WaitForInitializeClass(Handle<mirror::Class> klass, Thread* self,
3755 self->AssertNoPendingException();
3762 if (self->IsExceptionPending()) {
3764 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
3851 static bool HasSameSignatureWithDifferentClassLoaders(Thread* self,
3858 StackHandleScope<1> hs(self);
3906 StackHandleScope<1> hs(self);
3943 Thread* self = Thread::Current();
3944 StackHandleScope<1> hs(self);
3953 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self, klass, super_klass,
3955 self->AssertPendingException();
3970 if (UNLIKELY(!HasSameSignatureWithDifferentClassLoaders(self, klass, super_klass,
3972 self->AssertPendingException();
3982 bool ClassLinker::EnsureInitialized(Thread* self, Handle<mirror::Class> c, bool can_init_fields,
3989 const bool success = InitializeClass(self, c, can_init_fields, can_init_parents);
3992 CHECK(self->IsExceptionPending()) << PrettyClass(c.Get());
3995 self->AssertNoPendingException();
4033 bool ClassLinker::LinkClass(Thread* self, const char* descriptor, Handle<mirror::Class> klass,
4043 if (!LinkMethods(self, klass, interfaces, imt)) {
4046 if (!LinkInstanceFields(self, klass)) {
4050 if (!LinkStaticFields(self, klass, &class_size)) {
4067 mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self);
4072 StackHandleScope<1> hs(self);
4073 auto h_new_class = hs.NewHandle(klass->CopyOf(self, class_size, imt, image_pointer_size_));
4075 self->AssertPendingOOMException();
4076 mirror::Class::SetStatus(klass, mirror::Class::kStatusError, self);
4081 ObjectLock<mirror::Class> lock(self, h_new_class);
4089 mirror::Class::SetStatus(klass, mirror::Class::kStatusRetired, self);
4094 mirror::Class::SetStatus(h_new_class, mirror::Class::kStatusResolved, self);
4385 bool ClassLinker::LinkMethods(Thread* self, Handle<mirror::Class> klass,
4388 self->AllowThreadSuspension();
4399 } else if (!LinkVirtualMethods(self, klass)) { // Link virtual methods first.
4402 return LinkInterfaceMethods(self, klass, interfaces, out_imt); // Link interface method last.
4519 bool ClassLinker::LinkVirtualMethods(Thread* self, Handle<mirror::Class> klass) {
4524 StackHandleScope<2> hs(self);
4528 vtable = hs.NewHandle(AllocPointerArray(self, max_count));
4530 self->AssertPendingOOMException();
4549 super_vtable->CopyOf(self, max_count)));
4551 self->AssertPendingOOMException();
4630 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, actual_count)));
4632 self->AssertPendingOOMException();
4644 auto* vtable = AllocPointerArray(self, num_virtual_methods);
4646 self->AssertPendingOOMException();
4659 bool ClassLinker::LinkInterfaceMethods(Thread* self, Handle<mirror::Class> klass,
4662 StackHandleScope<3> hs(self);
4695 interfaces->GetWithoutChecks(i) : mirror::Class::GetDirectInterface(self, klass, i);
4706 MutableHandle<mirror::IfTable> iftable(hs.NewHandle(AllocIfTable(self, ifcount)));
4708 self->AssertPendingOOMException();
4718 self->AllowThreadSuspension();
4723 mirror::Class::GetDirectInterface(self, klass, i);
4753 self->AllowThreadSuspension();
4758 iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
4760 self->AssertPendingOOMException();
4837 method_array = down_cast<mirror::PointerArray*>(if_table->GetMethodArray(i)->Clone(self));
4839 method_array = AllocPointerArray(self, num_methods);
4842 self->AssertPendingOOMException();
4849 auto* old_cause = self->StartAssertNoThreadSuspension(
4854 StackHandleScope<2> hs2(self);
4904 self->EndAssertNoThreadSuspension(old_cause);
4957 self, old_virtuals, old_method_count * method_size, new_method_count * method_size));
4959 self->AssertPendingOOMException();
4988 self->EndAssertNoThreadSuspension(old_cause);
4993 vtable.Assign(down_cast<mirror::PointerArray*>(vtable->CopyOf(self, new_vtable_count)));
4995 self->AssertPendingOOMException();
5055 self->EndAssertNoThreadSuspension(old_cause);
5066 bool ClassLinker::LinkInstanceFields(Thread* self, Handle<mirror::Class> klass) {
5068 return LinkFields(self, klass, false, nullptr);
5071 bool ClassLinker::LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size) {
5073 return LinkFields(self, klass, true, class_size);
5110 bool ClassLinker::LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static,
5112 self->AllowThreadSuspension();
5134 const char* old_no_suspend_cause = self->StartAssertNoThreadSuspension(
5175 self->EndAssertNoThreadSuspension(old_no_suspend_cause);
5310 Thread* self = Thread::Current();
5312 resolved = FindClass(self, descriptor, class_loader);
5319 CHECK(self->IsExceptionPending())
5322 StackHandleScope<1> hs(self);
5323 Handle<mirror::Throwable> cause(hs.NewHandle(self->GetException()));
5326 self->ClearException();
5328 self->GetException()->SetCause(cause.Get());
5503 Thread* const self = Thread::Current();
5504 StackHandleScope<1> hs(self);
5513 resolved = mirror::Class::FindStaticField(self, klass, dex_cache.Get(), field_idx);
5522 resolved = mirror::Class::FindStaticField(self, klass, name, type);
5544 Thread* self = Thread::Current();
5545 StackHandleScope<1> hs(self);
5556 resolved = mirror::Class::FindField(self, klass, name, type);
5640 Thread* self = Thread::Current();
5642 ScopedObjectAccess soa(self);
5645 ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
5797 jobject ClassLinker::CreatePathClassLoader(Thread* self, std::vector<const DexFile*>& dex_files) {
5800 ScopedObjectAccessUnchecked soa(self);
5808 StackHandleScope<10> hs(self);
5817 mirror::ObjectArray<mirror::Object>::Alloc(self, dex_elements_class, dex_files.size())));
5831 StackHandleScope<3> hs2(self);
5833 Handle<mirror::LongArray> h_long_array = hs2.NewHandle(mirror::LongArray::Alloc(self, 1));
5838 cookie_field->GetDeclaringClass()->AllocObject(self));
5842 Handle<mirror::Object> h_element = hs2.NewHandle(h_dex_element_class->AllocObject(self));
5853 dex_elements_field->GetDeclaringClass()->AllocObject(self));
5862 h_path_class_class->AllocObject(self));
5873 mirror::Class::FindField(self, hs.NewHandle(h_path_class_loader->GetClass()), "parent",
5877 soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_BootClassLoader)->AllocObject(self);
