1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "class_linker.h" 18 19 #include <memory> 20 #include <string> 21 22 #include "android-base/strings.h" 23 24 #include "art_field-inl.h" 25 #include "art_method-inl.h" 26 #include "base/enums.h" 27 #include "class_linker-inl.h" 28 #include "common_runtime_test.h" 29 #include "dex_file.h" 30 #include "dex_file_types.h" 31 #include "experimental_flags.h" 32 #include "entrypoints/entrypoint_utils-inl.h" 33 #include "gc/heap.h" 34 #include "mirror/accessible_object.h" 35 #include "mirror/call_site.h" 36 #include "mirror/class-inl.h" 37 #include "mirror/class_ext.h" 38 #include "mirror/dex_cache.h" 39 #include "mirror/emulated_stack_frame.h" 40 #include "mirror/executable.h" 41 #include "mirror/field.h" 42 #include "mirror/method_type.h" 43 #include "mirror/method_handle_impl.h" 44 #include "mirror/method_handles_lookup.h" 45 #include "mirror/object-inl.h" 46 #include "mirror/object_array-inl.h" 47 #include "mirror/proxy.h" 48 #include "mirror/reference.h" 49 #include "mirror/stack_trace_element.h" 50 #include "mirror/string-inl.h" 51 #include "handle_scope-inl.h" 52 #include "scoped_thread_state_change-inl.h" 53 #include "thread-current-inl.h" 54 55 namespace art { 56 57 class ClassLinkerTest : public CommonRuntimeTest { 58 protected: 59 void AssertNonExistentClass(const std::string& descriptor) 60 REQUIRES_SHARED(Locks::mutator_lock_) { 61 Thread* self = Thread::Current(); 62 EXPECT_TRUE(class_linker_->FindSystemClass(self, descriptor.c_str()) == nullptr); 63 EXPECT_TRUE(self->IsExceptionPending()); 64 mirror::Object* exception = self->GetException(); 65 self->ClearException(); 66 mirror::Class* exception_class = 67 class_linker_->FindSystemClass(self, "Ljava/lang/NoClassDefFoundError;"); 68 EXPECT_TRUE(exception->InstanceOf(exception_class)); 69 } 70 71 void AssertPrimitiveClass(const std::string& descriptor) 72 REQUIRES_SHARED(Locks::mutator_lock_) { 73 Thread* self = Thread::Current(); 74 AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(self, descriptor.c_str())); 75 } 76 77 void AssertPrimitiveClass(const std::string& descriptor, mirror::Class* primitive) 78 REQUIRES_SHARED(Locks::mutator_lock_) { 79 ASSERT_TRUE(primitive != nullptr); 80 ASSERT_TRUE(primitive->GetClass() != nullptr); 81 ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass()); 82 EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != nullptr); 83 std::string temp; 84 ASSERT_STREQ(descriptor.c_str(), primitive->GetDescriptor(&temp)); 85 EXPECT_TRUE(primitive->GetSuperClass() == nullptr); 86 EXPECT_FALSE(primitive->HasSuperClass()); 87 EXPECT_TRUE(primitive->GetClassLoader() == nullptr); 88 EXPECT_EQ(mirror::Class::kStatusInitialized, primitive->GetStatus()); 89 EXPECT_FALSE(primitive->IsErroneous()); 90 EXPECT_TRUE(primitive->IsLoaded()); 91 EXPECT_TRUE(primitive->IsResolved()); 92 EXPECT_FALSE(primitive->IsErroneousResolved()); 93 EXPECT_TRUE(primitive->IsVerified()); 94 EXPECT_TRUE(primitive->IsInitialized()); 95 EXPECT_FALSE(primitive->IsArrayInstance()); 96 EXPECT_FALSE(primitive->IsArrayClass()); 97 EXPECT_TRUE(primitive->GetComponentType() == nullptr); 98 EXPECT_FALSE(primitive->IsInterface()); 99 EXPECT_TRUE(primitive->IsPublic()); 100 EXPECT_TRUE(primitive->IsFinal()); 101 EXPECT_TRUE(primitive->IsPrimitive()); 102 EXPECT_FALSE(primitive->IsSynthetic()); 103 EXPECT_EQ(0U, primitive->NumDirectMethods()); 104 EXPECT_EQ(0U, primitive->NumVirtualMethods()); 105 EXPECT_EQ(0U, primitive->NumInstanceFields()); 106 EXPECT_EQ(0U, primitive->NumStaticFields()); 107 EXPECT_EQ(0U, primitive->NumDirectInterfaces()); 108 EXPECT_FALSE(primitive->HasVTable()); 109 EXPECT_EQ(0, primitive->GetIfTableCount()); 110 EXPECT_TRUE(primitive->GetIfTable() != nullptr); 111 EXPECT_EQ(primitive->GetIfTable()->Count(), 0u); 112 EXPECT_EQ(kAccPublic | kAccFinal | kAccAbstract, primitive->GetAccessFlags()); 113 } 114 115 void AssertObjectClass(mirror::Class* JavaLangObject) 116 REQUIRES_SHARED(Locks::mutator_lock_) { 117 ASSERT_TRUE(JavaLangObject != nullptr); 118 ASSERT_TRUE(JavaLangObject->GetClass() != nullptr); 119 ASSERT_EQ(JavaLangObject->GetClass(), 120 JavaLangObject->GetClass()->GetClass()); 121 EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass()); 122 std::string temp; 123 ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;"); 124 EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr); 125 EXPECT_FALSE(JavaLangObject->HasSuperClass()); 126 EXPECT_TRUE(JavaLangObject->GetClassLoader() == nullptr); 127 EXPECT_EQ(mirror::Class::kStatusInitialized, JavaLangObject->GetStatus()); 128 EXPECT_FALSE(JavaLangObject->IsErroneous()); 129 EXPECT_TRUE(JavaLangObject->IsLoaded()); 130 EXPECT_TRUE(JavaLangObject->IsResolved()); 131 EXPECT_FALSE(JavaLangObject->IsErroneousResolved()); 132 EXPECT_TRUE(JavaLangObject->IsVerified()); 133 EXPECT_TRUE(JavaLangObject->IsInitialized()); 134 EXPECT_FALSE(JavaLangObject->IsArrayInstance()); 135 EXPECT_FALSE(JavaLangObject->IsArrayClass()); 136 EXPECT_TRUE(JavaLangObject->GetComponentType() == nullptr); 137 EXPECT_FALSE(JavaLangObject->IsInterface()); 138 EXPECT_TRUE(JavaLangObject->IsPublic()); 139 EXPECT_FALSE(JavaLangObject->IsFinal()); 140 EXPECT_FALSE(JavaLangObject->IsPrimitive()); 141 EXPECT_FALSE(JavaLangObject->IsSynthetic()); 142 EXPECT_EQ(4U, JavaLangObject->NumDirectMethods()); 143 EXPECT_EQ(11U, JavaLangObject->NumVirtualMethods()); 144 if (!kUseBrooksReadBarrier) { 145 EXPECT_EQ(2U, JavaLangObject->NumInstanceFields()); 146 } else { 147 EXPECT_EQ(4U, JavaLangObject->NumInstanceFields()); 148 } 149 EXPECT_STREQ(JavaLangObject->GetInstanceField(0)->GetName(), 150 "shadow$_klass_"); 151 EXPECT_STREQ(JavaLangObject->GetInstanceField(1)->GetName(), 152 "shadow$_monitor_"); 153 if (kUseBrooksReadBarrier) { 154 EXPECT_STREQ(JavaLangObject->GetInstanceField(2)->GetName(), 155 "shadow$_x_rb_ptr_"); 156 EXPECT_STREQ(JavaLangObject->GetInstanceField(3)->GetName(), 157 "shadow$_x_xpadding_"); 158 } 159 160 EXPECT_EQ(0U, JavaLangObject->NumStaticFields()); 161 EXPECT_EQ(0U, JavaLangObject->NumDirectInterfaces()); 162 163 PointerSize pointer_size = class_linker_->GetImagePointerSize(); 164 ArtMethod* unimplemented = runtime_->GetImtUnimplementedMethod(); 165 ImTable* imt = JavaLangObject->GetImt(pointer_size); 166 ASSERT_NE(nullptr, imt); 167 for (size_t i = 0; i < ImTable::kSize; ++i) { 168 ASSERT_EQ(unimplemented, imt->Get(i, pointer_size)); 169 } 170 } 171 172 void AssertArrayClass(const std::string& array_descriptor, 173 const std::string& component_type, 174 mirror::ClassLoader* class_loader) 175 REQUIRES_SHARED(Locks::mutator_lock_) { 176 Thread* self = Thread::Current(); 177 StackHandleScope<2> hs(self); 178 Handle<mirror::ClassLoader> loader(hs.NewHandle(class_loader)); 179 Handle<mirror::Class> array( 180 hs.NewHandle(class_linker_->FindClass(self, array_descriptor.c_str(), loader))); 181 std::string temp; 182 EXPECT_STREQ(component_type.c_str(), array->GetComponentType()->GetDescriptor(&temp)); 183 EXPECT_EQ(class_loader, array->GetClassLoader()); 184 EXPECT_EQ(kAccFinal | kAccAbstract, (array->GetAccessFlags() & (kAccFinal | kAccAbstract))); 185 AssertArrayClass(array_descriptor, array); 186 } 187 188 void AssertArrayClass(const std::string& array_descriptor, Handle<mirror::Class> array) 189 REQUIRES_SHARED(Locks::mutator_lock_) { 190 ASSERT_TRUE(array != nullptr); 191 ASSERT_TRUE(array->GetClass() != nullptr); 192 ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass()); 193 EXPECT_TRUE(array->GetClass()->GetSuperClass() != nullptr); 194 std::string temp; 195 ASSERT_STREQ(array_descriptor.c_str(), array->GetDescriptor(&temp)); 196 EXPECT_TRUE(array->GetSuperClass() != nullptr); 197 Thread* self = Thread::Current(); 198 EXPECT_EQ(class_linker_->FindSystemClass(self, "Ljava/lang/Object;"), array->GetSuperClass()); 199 EXPECT_TRUE(array->HasSuperClass()); 200 ASSERT_TRUE(array->GetComponentType() != nullptr); 201 ASSERT_GT(strlen(array->GetComponentType()->GetDescriptor(&temp)), 0U); 202 EXPECT_EQ(mirror::Class::kStatusInitialized, array->GetStatus()); 203 EXPECT_FALSE(array->IsErroneous()); 204 EXPECT_TRUE(array->IsLoaded()); 205 EXPECT_TRUE(array->IsResolved()); 206 EXPECT_FALSE(array->IsErroneousResolved()); 207 EXPECT_TRUE(array->IsVerified()); 208 EXPECT_TRUE(array->IsInitialized()); 209 EXPECT_FALSE(array->IsArrayInstance()); 210 EXPECT_TRUE(array->IsArrayClass()); 211 EXPECT_FALSE(array->IsInterface()); 212 EXPECT_EQ(array->GetComponentType()->IsPublic(), array->IsPublic()); 213 EXPECT_TRUE(array->IsFinal()); 214 EXPECT_FALSE(array->IsPrimitive()); 215 EXPECT_FALSE(array->IsSynthetic()); 216 EXPECT_EQ(0U, array->NumDirectMethods()); 217 EXPECT_EQ(0U, array->NumVirtualMethods()); 218 EXPECT_EQ(0U, array->NumInstanceFields()); 219 EXPECT_EQ(0U, array->NumStaticFields()); 220 EXPECT_EQ(2U, array->NumDirectInterfaces()); 221 EXPECT_TRUE(array->ShouldHaveImt()); 222 EXPECT_TRUE(array->ShouldHaveEmbeddedVTable()); 223 EXPECT_EQ(2, array->GetIfTableCount()); 224 ASSERT_TRUE(array->GetIfTable() != nullptr); 225 ObjPtr<mirror::Class> direct_interface0 = 226 mirror::Class::GetDirectInterface(self, array.Get(), 0); 227 EXPECT_TRUE(direct_interface0 != nullptr); 228 EXPECT_STREQ(direct_interface0->GetDescriptor(&temp), "Ljava/lang/Cloneable;"); 229 ObjPtr<mirror::Class> direct_interface1 = 230 mirror::Class::GetDirectInterface(self, array.Get(), 1); 231 EXPECT_STREQ(direct_interface1->GetDescriptor(&temp), "Ljava/io/Serializable;"); 232 ObjPtr<mirror::Class> array_ptr = array->GetComponentType(); 233 EXPECT_OBJ_PTR_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get()); 234 235 PointerSize pointer_size = class_linker_->GetImagePointerSize(); 236 mirror::Class* JavaLangObject = 237 class_linker_->FindSystemClass(self, "Ljava/lang/Object;"); 238 ImTable* JavaLangObject_imt = JavaLangObject->GetImt(pointer_size); 239 // IMT of a array class should be shared with the IMT of the java.lag.Object 240 ASSERT_EQ(JavaLangObject_imt, array->GetImt(pointer_size)); 241 } 242 243 void AssertMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) { 244 EXPECT_TRUE(method != nullptr); 245 EXPECT_TRUE(method->GetDeclaringClass() != nullptr); 246 EXPECT_TRUE(method->GetName() != nullptr); 247 EXPECT_TRUE(method->GetSignature() != Signature::NoSignature()); 248 249 EXPECT_TRUE(method->HasDexCacheResolvedMethods(kRuntimePointerSize)); 250 EXPECT_TRUE(method->HasSameDexCacheResolvedMethods( 251 method->GetDeclaringClass()->GetDexCache()->GetResolvedMethods(), 252 kRuntimePointerSize)); 253 } 254 255 void AssertField(ObjPtr<mirror::Class> klass, ArtField* field) 256 REQUIRES_SHARED(Locks::mutator_lock_) { 257 EXPECT_TRUE(field != nullptr); 258 EXPECT_OBJ_PTR_EQ(klass, field->GetDeclaringClass()); 259 EXPECT_TRUE(field->GetName() != nullptr); 260 EXPECT_TRUE(field->GetType<true>() != nullptr); 261 } 262 263 void AssertClass(const std::string& descriptor, Handle<mirror::Class> klass) 264 REQUIRES_SHARED(Locks::mutator_lock_) { 265 std::string temp; 266 EXPECT_STREQ(descriptor.c_str(), klass->GetDescriptor(&temp)); 267 if (descriptor == "Ljava/lang/Object;") { 268 EXPECT_FALSE(klass->HasSuperClass()); 269 } else { 270 EXPECT_TRUE(klass->HasSuperClass()); 271 EXPECT_TRUE(klass->GetSuperClass() != nullptr); 272 } 273 EXPECT_TRUE(klass->GetClass() != nullptr); 274 EXPECT_EQ(klass->GetClass(), klass->GetClass()->GetClass()); 275 EXPECT_TRUE(klass->GetDexCache() != nullptr); 276 EXPECT_TRUE(klass->IsLoaded()); 277 EXPECT_TRUE(klass->IsResolved()); 278 EXPECT_FALSE(klass->IsErroneousResolved()); 279 EXPECT_FALSE(klass->IsErroneous()); 280 EXPECT_FALSE(klass->IsArrayClass()); 281 EXPECT_TRUE(klass->GetComponentType() == nullptr); 282 EXPECT_TRUE(klass->IsInSamePackage(klass.Get())); 283 std::string temp2; 284 EXPECT_TRUE(mirror::Class::IsInSamePackage(klass->GetDescriptor(&temp), 285 klass->GetDescriptor(&temp2))); 286 if (klass->IsInterface()) { 287 EXPECT_TRUE(klass->IsAbstract()); 288 // Check that all direct methods are static (either <clinit> or a regular static method). 289 for (ArtMethod& m : klass->GetDirectMethods(kRuntimePointerSize)) { 290 EXPECT_TRUE(m.IsStatic()); 291 EXPECT_TRUE(m.IsDirect()); 292 } 293 } else { 294 if (!klass->IsSynthetic()) { 295 EXPECT_NE(0U, klass->NumDirectMethods()); 296 } 297 } 298 EXPECT_EQ(klass->IsInterface(), !klass->HasVTable()); 299 mirror::IfTable* iftable = klass->GetIfTable(); 300 for (int i = 0; i < klass->GetIfTableCount(); i++) { 301 mirror::Class* interface = iftable->GetInterface(i); 302 ASSERT_TRUE(interface != nullptr); 303 if (klass->IsInterface()) { 304 EXPECT_EQ(0U, iftable->GetMethodArrayCount(i)); 305 } else { 306 EXPECT_EQ(interface->NumDeclaredVirtualMethods(), iftable->GetMethodArrayCount(i)); 307 } 308 } 309 if (klass->IsAbstract()) { 310 EXPECT_FALSE(klass->IsFinal()); 311 } else { 312 EXPECT_FALSE(klass->IsAnnotation()); 313 } 314 if (klass->IsFinal()) { 315 EXPECT_FALSE(klass->IsAbstract()); 316 EXPECT_FALSE(klass->IsAnnotation()); 317 } 318 if (klass->IsAnnotation()) { 319 EXPECT_FALSE(klass->IsFinal()); 320 EXPECT_TRUE(klass->IsAbstract()); 321 } 322 323 EXPECT_FALSE(klass->IsPrimitive()); 324 EXPECT_TRUE(klass->CanAccess(klass.Get())); 325 326 for (ArtMethod& method : klass->GetDirectMethods(kRuntimePointerSize)) { 327 AssertMethod(&method); 328 EXPECT_TRUE(method.IsDirect()); 329 EXPECT_EQ(klass.Get(), method.GetDeclaringClass()); 330 } 331 332 for (ArtMethod& method : klass->GetDeclaredVirtualMethods(kRuntimePointerSize)) { 333 AssertMethod(&method); 334 EXPECT_FALSE(method.IsDirect()); 335 EXPECT_EQ(klass.Get(), method.GetDeclaringClass()); 336 } 337 338 for (ArtMethod& method : klass->GetCopiedMethods(kRuntimePointerSize)) { 339 AssertMethod(&method); 340 EXPECT_FALSE(method.IsDirect()); 341 EXPECT_TRUE(method.IsCopied()); 342 EXPECT_TRUE(method.GetDeclaringClass()->IsInterface()) 343 << "declaring class: " << method.GetDeclaringClass()->PrettyClass(); 344 EXPECT_TRUE(method.GetDeclaringClass()->IsAssignableFrom(klass.Get())) 345 << "declaring class: " << method.GetDeclaringClass()->PrettyClass(); 346 } 347 348 for (size_t i = 0; i < klass->NumInstanceFields(); i++) { 349 ArtField* field = klass->GetInstanceField(i); 350 AssertField(klass.Get(), field); 351 EXPECT_FALSE(field->IsStatic()); 352 } 353 354 for (size_t i = 0; i < klass->NumStaticFields(); i++) { 355 ArtField* field = klass->GetStaticField(i); 356 AssertField(klass.Get(), field); 357 EXPECT_TRUE(field->IsStatic()); 358 } 359 360 // Confirm that all instances field offsets are packed together at the start. 361 EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields()); 362 MemberOffset start_ref_offset = klass->GetFirstReferenceInstanceFieldOffset(); 363 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() + 364 klass->NumReferenceInstanceFields() * 365 sizeof(mirror::HeapReference<mirror::Object>)); 366 MemberOffset current_ref_offset = start_ref_offset; 367 for (size_t i = 0; i < klass->NumInstanceFields(); i++) { 368 ArtField* field = klass->GetInstanceField(i); 369 ObjPtr<mirror::Class> field_type = field->GetType<true>(); 370 ASSERT_TRUE(field_type != nullptr); 371 if (!field->IsPrimitiveType()) { 372 ASSERT_TRUE(!field_type->IsPrimitive()); 373 ASSERT_EQ(current_ref_offset.Uint32Value(), field->GetOffset().Uint32Value()); 374 if (current_ref_offset.Uint32Value() == end_ref_offset.Uint32Value()) { 375 // While Reference.referent is not primitive, the ClassLinker 376 // treats it as such so that the garbage collector won't scan it. 377 EXPECT_EQ(field->PrettyField(), "java.lang.Object java.lang.ref.Reference.referent"); 378 } else { 379 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() + 380 sizeof(mirror::HeapReference<mirror::Object>)); 381 } 382 } else { 383 if (field->GetOffset().Uint32Value() < end_ref_offset.Uint32Value()) { 384 // Shuffled before references. 385 ASSERT_LT(field->GetOffset().Uint32Value(), start_ref_offset.Uint32Value()); 386 CHECK(!IsAligned<4>(field->GetOffset().Uint32Value())); 387 } 388 } 389 } 390 ASSERT_EQ(end_ref_offset.Uint32Value(), current_ref_offset.Uint32Value()); 391 392 uint32_t total_num_reference_instance_fields = 0; 393 mirror::Class* k = klass.Get(); 394 while (k != nullptr) { 395 total_num_reference_instance_fields += k->NumReferenceInstanceFields(); 396 k = k->GetSuperClass(); 397 } 398 EXPECT_GE(total_num_reference_instance_fields, 1U); // Should always have Object's class. 399 if (klass->GetReferenceInstanceOffsets() != mirror::Class::kClassWalkSuper) { 400 // The reference instance offsets have a bit set for each reference offset. 401 // +1 for Object's class. 402 EXPECT_EQ(static_cast<uint32_t>(POPCOUNT(klass->GetReferenceInstanceOffsets())) + 1, 403 total_num_reference_instance_fields); 404 } 405 } 406 407 void AssertDexFileClass(mirror::ClassLoader* class_loader, const std::string& descriptor) 408 REQUIRES_SHARED(Locks::mutator_lock_) { 409 ASSERT_TRUE(descriptor != nullptr); 410 Thread* self = Thread::Current(); 411 StackHandleScope<1> hs(self); 412 Handle<mirror::Class> klass( 413 hs.NewHandle(class_linker_->FindSystemClass(self, descriptor.c_str()))); 414 ASSERT_TRUE(klass != nullptr); 415 std::string temp; 416 EXPECT_STREQ(descriptor.c_str(), klass.Get()->GetDescriptor(&temp)); 417 EXPECT_EQ(class_loader, klass->GetClassLoader()); 418 if (klass->IsPrimitive()) { 419 AssertPrimitiveClass(descriptor, klass.Get()); 420 } else if (klass->IsArrayClass()) { 421 AssertArrayClass(descriptor, klass); 422 } else { 423 AssertClass(descriptor, klass); 424 } 425 } 426 427 void AssertDexFile(const DexFile& dex, mirror::ClassLoader* class_loader) 428 REQUIRES_SHARED(Locks::mutator_lock_) { 429 // Verify all the classes defined in this file 430 for (size_t i = 0; i < dex.NumClassDefs(); i++) { 431 const DexFile::ClassDef& class_def = dex.GetClassDef(i); 432 const char* descriptor = dex.GetClassDescriptor(class_def); 433 AssertDexFileClass(class_loader, descriptor); 434 } 435 // Verify all the types referenced by this file 436 for (size_t i = 0; i < dex.NumTypeIds(); i++) { 437 const DexFile::TypeId& type_id = dex.GetTypeId(dex::TypeIndex(i)); 438 const char* descriptor = dex.GetTypeDescriptor(type_id); 439 AssertDexFileClass(class_loader, descriptor); 440 } 441 TestRootVisitor visitor; 442 class_linker_->VisitRoots(&visitor, kVisitRootFlagAllRoots); 443 } 444 445 class TestRootVisitor : public SingleRootVisitor { 446 public: 447 void VisitRoot(mirror::Object* root, const RootInfo& info ATTRIBUTE_UNUSED) OVERRIDE { 448 EXPECT_TRUE(root != nullptr); 449 } 450 }; 451 }; 452 453 class ClassLinkerMethodHandlesTest : public ClassLinkerTest { 454 protected: 455 virtual void SetUpRuntimeOptions(RuntimeOptions* options) OVERRIDE { 456 CommonRuntimeTest::SetUpRuntimeOptions(options); 457 } 458 }; 459 460 struct CheckOffset { 461 size_t cpp_offset; 462 const char* java_name; 463 CheckOffset(size_t c, const char* j) : cpp_offset(c), java_name(j) {} 464 }; 465 466 template <typename T> 467 struct CheckOffsets { 468 CheckOffsets(bool is_static_in, const char* class_descriptor_in) 469 : is_static(is_static_in), class_descriptor(class_descriptor_in) {} 470 bool is_static; 471 std::string class_descriptor; 472 std::vector<CheckOffset> offsets; 473 474 bool Check() REQUIRES_SHARED(Locks::mutator_lock_) { 475 Thread* self = Thread::Current(); 476 mirror::Class* klass = 477 Runtime::Current()->GetClassLinker()->FindSystemClass(self, class_descriptor.c_str()); 478 CHECK(klass != nullptr) << class_descriptor; 479 480 bool error = false; 481 482 // Classes have a different size due to padding field. Strings are variable length. 483 if (!klass->IsClassClass() && !klass->IsStringClass() && !is_static) { 484 // Currently only required for AccessibleObject since of the padding fields. The class linker 485 // says AccessibleObject is 9 bytes but sizeof(AccessibleObject) is 12 bytes due to padding. 486 // The RoundUp is to get around this case. 487 static constexpr size_t kPackAlignment = 4; 488 size_t expected_size = RoundUp(is_static ? klass->GetClassSize() : klass->GetObjectSize(), 489 kPackAlignment); 490 if (sizeof(T) != expected_size) { 491 LOG(ERROR) << "Class size mismatch:" 492 << " class=" << class_descriptor 493 << " Java=" << expected_size 494 << " C++=" << sizeof(T); 495 error = true; 496 } 497 } 498 499 size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields(); 500 if (offsets.size() != num_fields) { 501 LOG(ERROR) << "Field count mismatch:" 502 << " class=" << class_descriptor 503 << " Java=" << num_fields 504 << " C++=" << offsets.size(); 505 error = true; 506 } 507 508 for (size_t i = 0; i < offsets.size(); i++) { 509 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i); 510 StringPiece field_name(field->GetName()); 511 if (field_name != offsets[i].java_name) { 512 error = true; 513 } 514 } 515 if (error) { 516 for (size_t i = 0; i < offsets.size(); i++) { 517 CheckOffset& offset = offsets[i]; 518 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i); 519 StringPiece field_name(field->GetName()); 520 if (field_name != offsets[i].java_name) { 521 LOG(ERROR) << "JAVA FIELD ORDER MISMATCH NEXT LINE:"; 522 } 523 LOG(ERROR) << "Java field order:" 524 << " i=" << i << " class=" << class_descriptor 525 << " Java=" << field_name 526 << " CheckOffsets=" << offset.java_name; 527 } 528 } 529 530 for (size_t i = 0; i < offsets.size(); i++) { 531 CheckOffset& offset = offsets[i]; 532 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i); 533 if (field->GetOffset().Uint32Value() != offset.cpp_offset) { 534 error = true; 535 } 536 } 537 if (error) { 538 for (size_t i = 0; i < offsets.size(); i++) { 539 CheckOffset& offset = offsets[i]; 540 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i); 541 if (field->GetOffset().Uint32Value() != offset.cpp_offset) { 542 LOG(ERROR) << "OFFSET MISMATCH NEXT LINE:"; 543 } 544 LOG(ERROR) << "Offset: class=" << class_descriptor << " field=" << offset.java_name 545 << " Java=" << field->GetOffset().Uint32Value() << " C++=" << offset.cpp_offset; 546 } 547 } 548 549 return !error; 550 }; 551 552 void addOffset(size_t offset, const char* name) { 553 offsets.push_back(CheckOffset(offset, name)); 554 } 555 556 private: 557 DISALLOW_IMPLICIT_CONSTRUCTORS(CheckOffsets); 558 }; 559 560 // Note that ClassLinkerTest.ValidateFieldOrderOfJavaCppUnionClasses 561 // is first since if it is failing, others are unlikely to succeed. 562 563 struct ObjectOffsets : public CheckOffsets<mirror::Object> { 564 ObjectOffsets() : CheckOffsets<mirror::Object>(false, "Ljava/lang/Object;") { 565 addOffset(OFFSETOF_MEMBER(mirror::Object, klass_), "shadow$_klass_"); 566 addOffset(OFFSETOF_MEMBER(mirror::Object, monitor_), "shadow$_monitor_"); 567 #ifdef USE_BROOKS_READ_BARRIER 568 addOffset(OFFSETOF_MEMBER(mirror::Object, x_rb_ptr_), "shadow$_x_rb_ptr_"); 569 addOffset(OFFSETOF_MEMBER(mirror::Object, x_xpadding_), "shadow$_x_xpadding_"); 570 #endif 571 }; 572 }; 573 574 struct ClassOffsets : public CheckOffsets<mirror::Class> { 575 ClassOffsets() : CheckOffsets<mirror::Class>(false, "Ljava/lang/Class;") { 576 addOffset(OFFSETOF_MEMBER(mirror::Class, access_flags_), "accessFlags"); 577 addOffset(OFFSETOF_MEMBER(mirror::Class, class_flags_), "classFlags"); 578 addOffset(OFFSETOF_MEMBER(mirror::Class, class_loader_), "classLoader"); 579 addOffset(OFFSETOF_MEMBER(mirror::Class, class_size_), "classSize"); 580 addOffset(OFFSETOF_MEMBER(mirror::Class, clinit_thread_id_), "clinitThreadId"); 581 addOffset(OFFSETOF_MEMBER(mirror::Class, component_type_), "componentType"); 582 addOffset(OFFSETOF_MEMBER(mirror::Class, copied_methods_offset_), "copiedMethodsOffset"); 583 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_cache_), "dexCache"); 584 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_class_def_idx_), "dexClassDefIndex"); 585 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_type_idx_), "dexTypeIndex"); 586 addOffset(OFFSETOF_MEMBER(mirror::Class, ext_data_), "extData"); 587 addOffset(OFFSETOF_MEMBER(mirror::Class, ifields_), "iFields"); 588 addOffset(OFFSETOF_MEMBER(mirror::Class, iftable_), "ifTable"); 589 addOffset(OFFSETOF_MEMBER(mirror::Class, methods_), "methods"); 590 addOffset(OFFSETOF_MEMBER(mirror::Class, name_), "name"); 591 addOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_instance_fields_), 592 "numReferenceInstanceFields"); 593 addOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_static_fields_), 594 "numReferenceStaticFields"); 595 addOffset(OFFSETOF_MEMBER(mirror::Class, object_size_), "objectSize"); 596 addOffset(OFFSETOF_MEMBER(mirror::Class, object_size_alloc_fast_path_), 597 "objectSizeAllocFastPath"); 598 addOffset(OFFSETOF_MEMBER(mirror::Class, primitive_type_), "primitiveType"); 599 addOffset(OFFSETOF_MEMBER(mirror::Class, reference_instance_offsets_), 600 "referenceInstanceOffsets"); 601 addOffset(OFFSETOF_MEMBER(mirror::Class, sfields_), "sFields"); 602 addOffset(OFFSETOF_MEMBER(mirror::Class, status_), "status"); 603 addOffset(OFFSETOF_MEMBER(mirror::Class, super_class_), "superClass"); 604 addOffset(OFFSETOF_MEMBER(mirror::Class, virtual_methods_offset_), "virtualMethodsOffset"); 605 addOffset(OFFSETOF_MEMBER(mirror::Class, vtable_), "vtable"); 606 }; 607 }; 608 609 struct ClassExtOffsets : public CheckOffsets<mirror::ClassExt> { 610 ClassExtOffsets() : CheckOffsets<mirror::ClassExt>(false, "Ldalvik/system/ClassExt;") { 611 addOffset(OFFSETOF_MEMBER(mirror::ClassExt, obsolete_dex_caches_), "obsoleteDexCaches"); 612 addOffset(OFFSETOF_MEMBER(mirror::ClassExt, obsolete_methods_), "obsoleteMethods"); 613 addOffset(OFFSETOF_MEMBER(mirror::ClassExt, original_dex_file_), "originalDexFile"); 614 addOffset(OFFSETOF_MEMBER(mirror::ClassExt, verify_error_), "verifyError"); 615 } 616 }; 617 618 struct StringOffsets : public CheckOffsets<mirror::String> { 619 StringOffsets() : CheckOffsets<mirror::String>(false, "Ljava/lang/String;") { 620 addOffset(OFFSETOF_MEMBER(mirror::String, count_), "count"); 621 addOffset(OFFSETOF_MEMBER(mirror::String, hash_code_), "hash"); 622 }; 623 }; 624 625 struct ThrowableOffsets : public CheckOffsets<mirror::Throwable> { 626 ThrowableOffsets() : CheckOffsets<mirror::Throwable>(false, "Ljava/lang/Throwable;") { 627 addOffset(OFFSETOF_MEMBER(mirror::Throwable, backtrace_), "backtrace"); 628 addOffset(OFFSETOF_MEMBER(mirror::Throwable, cause_), "cause"); 629 addOffset(OFFSETOF_MEMBER(mirror::Throwable, detail_message_), "detailMessage"); 630 addOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_trace_), "stackTrace"); 631 addOffset(OFFSETOF_MEMBER(mirror::Throwable, suppressed_exceptions_), "suppressedExceptions"); 632 }; 633 }; 634 635 struct StackTraceElementOffsets : public CheckOffsets<mirror::StackTraceElement> { 636 StackTraceElementOffsets() : CheckOffsets<mirror::StackTraceElement>( 637 false, "Ljava/lang/StackTraceElement;") { 638 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, declaring_class_), "declaringClass"); 639 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, file_name_), "fileName"); 640 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, line_number_), "lineNumber"); 641 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, method_name_), "methodName"); 642 }; 643 }; 644 645 struct ClassLoaderOffsets : public CheckOffsets<mirror::ClassLoader> { 646 ClassLoaderOffsets() : CheckOffsets<mirror::ClassLoader>(false, "Ljava/lang/ClassLoader;") { 647 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, allocator_), "allocator"); 648 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, class_table_), "classTable"); 649 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, packages_), "packages"); 650 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, parent_), "parent"); 651 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, proxyCache_), "proxyCache"); 652 }; 653 }; 654 655 struct ProxyOffsets : public CheckOffsets<mirror::Proxy> { 656 ProxyOffsets() : CheckOffsets<mirror::Proxy>(false, "Ljava/lang/reflect/Proxy;") { 657 addOffset(OFFSETOF_MEMBER(mirror::Proxy, h_), "h"); 658 }; 659 }; 660 661 struct DexCacheOffsets : public CheckOffsets<mirror::DexCache> { 662 DexCacheOffsets() : CheckOffsets<mirror::DexCache>(false, "Ljava/lang/DexCache;") { 663 addOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_file_), "dexFile"); 664 addOffset(OFFSETOF_MEMBER(mirror::DexCache, location_), "location"); 665 addOffset(OFFSETOF_MEMBER(mirror::DexCache, num_resolved_call_sites_), "numResolvedCallSites"); 666 addOffset(OFFSETOF_MEMBER(mirror::DexCache, num_resolved_fields_), "numResolvedFields"); 667 addOffset(OFFSETOF_MEMBER(mirror::DexCache, num_resolved_method_types_), "numResolvedMethodTypes"); 668 addOffset(OFFSETOF_MEMBER(mirror::DexCache, num_resolved_methods_), "numResolvedMethods"); 669 addOffset(OFFSETOF_MEMBER(mirror::DexCache, num_resolved_types_), "numResolvedTypes"); 670 addOffset(OFFSETOF_MEMBER(mirror::DexCache, num_strings_), "numStrings"); 671 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_call_sites_), "resolvedCallSites"); 672 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_fields_), "resolvedFields"); 673 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_method_types_), "resolvedMethodTypes"); 674 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_methods_), "resolvedMethods"); 675 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_types_), "resolvedTypes"); 676 addOffset(OFFSETOF_MEMBER(mirror::DexCache, strings_), "strings"); 677 }; 678 }; 679 680 struct ReferenceOffsets : public CheckOffsets<mirror::Reference> { 681 ReferenceOffsets() : CheckOffsets<mirror::Reference>(false, "Ljava/lang/ref/Reference;") { 682 addOffset(OFFSETOF_MEMBER(mirror::Reference, pending_next_), "pendingNext"); 683 addOffset(OFFSETOF_MEMBER(mirror::Reference, queue_), "queue"); 684 addOffset(OFFSETOF_MEMBER(mirror::Reference, queue_next_), "queueNext"); 685 addOffset(OFFSETOF_MEMBER(mirror::Reference, referent_), "referent"); 686 }; 687 }; 688 689 struct FinalizerReferenceOffsets : public CheckOffsets<mirror::FinalizerReference> { 690 FinalizerReferenceOffsets() : CheckOffsets<mirror::FinalizerReference>( 691 false, "Ljava/lang/ref/FinalizerReference;") { 692 addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, next_), "next"); 693 addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, prev_), "prev"); 694 addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, zombie_), "zombie"); 695 }; 696 }; 697 698 struct AccessibleObjectOffsets : public CheckOffsets<mirror::AccessibleObject> { 699 AccessibleObjectOffsets() : CheckOffsets<mirror::AccessibleObject>( 700 false, "Ljava/lang/reflect/AccessibleObject;") { 701 addOffset(mirror::AccessibleObject::FlagOffset().Uint32Value(), "override"); 702 }; 703 }; 704 705 struct FieldOffsets : public CheckOffsets<mirror::Field> { 706 FieldOffsets() : CheckOffsets<mirror::Field>(false, "Ljava/lang/reflect/Field;") { 707 addOffset(OFFSETOF_MEMBER(mirror::Field, access_flags_), "accessFlags"); 708 addOffset(OFFSETOF_MEMBER(mirror::Field, declaring_class_), "declaringClass"); 709 addOffset(OFFSETOF_MEMBER(mirror::Field, dex_field_index_), "dexFieldIndex"); 710 addOffset(OFFSETOF_MEMBER(mirror::Field, offset_), "offset"); 711 addOffset(OFFSETOF_MEMBER(mirror::Field, type_), "type"); 712 }; 713 }; 714 715 struct ExecutableOffsets : public CheckOffsets<mirror::Executable> { 716 ExecutableOffsets() : CheckOffsets<mirror::Executable>( 717 false, "Ljava/lang/reflect/Executable;") { 718 addOffset(OFFSETOF_MEMBER(mirror::Executable, access_flags_), "accessFlags"); 719 addOffset(OFFSETOF_MEMBER(mirror::Executable, art_method_), "artMethod"); 720 addOffset(OFFSETOF_MEMBER(mirror::Executable, declaring_class_), "declaringClass"); 721 addOffset(OFFSETOF_MEMBER(mirror::Executable, declaring_class_of_overridden_method_), 722 "declaringClassOfOverriddenMethod"); 723 addOffset(OFFSETOF_MEMBER(mirror::Executable, dex_method_index_), "dexMethodIndex"); 724 addOffset(OFFSETOF_MEMBER(mirror::Executable, has_real_parameter_data_), 725 "hasRealParameterData"); 726 addOffset(OFFSETOF_MEMBER(mirror::Executable, parameters_), "parameters"); 727 }; 728 }; 729 730 struct MethodTypeOffsets : public CheckOffsets<mirror::MethodType> { 731 MethodTypeOffsets() : CheckOffsets<mirror::MethodType>( 732 false, "Ljava/lang/invoke/MethodType;") { 733 addOffset(OFFSETOF_MEMBER(mirror::MethodType, form_), "form"); 734 addOffset(OFFSETOF_MEMBER(mirror::MethodType, method_descriptor_), "methodDescriptor"); 735 addOffset(OFFSETOF_MEMBER(mirror::MethodType, p_types_), "ptypes"); 736 addOffset(OFFSETOF_MEMBER(mirror::MethodType, r_type_), "rtype"); 737 addOffset(OFFSETOF_MEMBER(mirror::MethodType, wrap_alt_), "wrapAlt"); 738 } 739 }; 740 741 struct MethodHandleOffsets : public CheckOffsets<mirror::MethodHandle> { 742 MethodHandleOffsets() : CheckOffsets<mirror::MethodHandle>( 743 false, "Ljava/lang/invoke/MethodHandle;") { 744 addOffset(OFFSETOF_MEMBER(mirror::MethodHandle, art_field_or_method_), "artFieldOrMethod"); 745 addOffset(OFFSETOF_MEMBER(mirror::MethodHandle, cached_spread_invoker_), 746 "cachedSpreadInvoker"); 747 addOffset(OFFSETOF_MEMBER(mirror::MethodHandle, handle_kind_), "handleKind"); 748 addOffset(OFFSETOF_MEMBER(mirror::MethodHandle, nominal_type_), "nominalType"); 749 addOffset(OFFSETOF_MEMBER(mirror::MethodHandle, method_type_), "type"); 750 } 751 }; 752 753 struct MethodHandleImplOffsets : public CheckOffsets<mirror::MethodHandleImpl> { 754 MethodHandleImplOffsets() : CheckOffsets<mirror::MethodHandleImpl>( 755 false, "Ljava/lang/invoke/MethodHandleImpl;") { 756 addOffset(OFFSETOF_MEMBER(mirror::MethodHandleImpl, info_), "info"); 757 } 758 }; 759 760 struct MethodHandlesLookupOffsets : public CheckOffsets<mirror::MethodHandlesLookup> { 761 MethodHandlesLookupOffsets() : CheckOffsets<mirror::MethodHandlesLookup>( 762 false, "Ljava/lang/invoke/MethodHandles$Lookup;") { 763 addOffset(OFFSETOF_MEMBER(mirror::MethodHandlesLookup, allowed_modes_), "allowedModes"); 764 addOffset(OFFSETOF_MEMBER(mirror::MethodHandlesLookup, lookup_class_), "lookupClass"); 765 } 766 }; 767 768 struct EmulatedStackFrameOffsets : public CheckOffsets<mirror::EmulatedStackFrame> { 769 EmulatedStackFrameOffsets() : CheckOffsets<mirror::EmulatedStackFrame>( 770 false, "Ldalvik/system/EmulatedStackFrame;") { 771 addOffset(OFFSETOF_MEMBER(mirror::EmulatedStackFrame, callsite_type_), "callsiteType"); 772 addOffset(OFFSETOF_MEMBER(mirror::EmulatedStackFrame, references_), "references"); 773 addOffset(OFFSETOF_MEMBER(mirror::EmulatedStackFrame, stack_frame_), "stackFrame"); 774 addOffset(OFFSETOF_MEMBER(mirror::EmulatedStackFrame, type_), "type"); 775 } 776 }; 777 778 struct CallSiteOffsets : public CheckOffsets<mirror::CallSite> { 779 CallSiteOffsets() : CheckOffsets<mirror::CallSite>( 780 false, "Ljava/lang/invoke/CallSite;") { 781 addOffset(OFFSETOF_MEMBER(mirror::CallSite, target_), "target"); 782 } 783 }; 784 785 // C++ fields must exactly match the fields in the Java classes. If this fails, 786 // reorder the fields in the C++ class. Managed class fields are ordered by 787 // ClassLinker::LinkFields. 788 TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) { 789 ScopedObjectAccess soa(Thread::Current()); 790 EXPECT_TRUE(ObjectOffsets().Check()); 791 EXPECT_TRUE(ClassOffsets().Check()); 792 EXPECT_TRUE(ClassExtOffsets().Check()); 793 EXPECT_TRUE(StringOffsets().Check()); 794 EXPECT_TRUE(ThrowableOffsets().Check()); 795 EXPECT_TRUE(StackTraceElementOffsets().Check()); 796 EXPECT_TRUE(ClassLoaderOffsets().Check()); 797 EXPECT_TRUE(ProxyOffsets().Check()); 798 EXPECT_TRUE(DexCacheOffsets().Check()); 799 EXPECT_TRUE(ReferenceOffsets().Check()); 800 EXPECT_TRUE(FinalizerReferenceOffsets().Check()); 801 EXPECT_TRUE(AccessibleObjectOffsets().Check()); 802 EXPECT_TRUE(FieldOffsets().Check()); 803 EXPECT_TRUE(ExecutableOffsets().Check()); 804 EXPECT_TRUE(MethodTypeOffsets().Check()); 805 EXPECT_TRUE(MethodHandleOffsets().Check()); 806 EXPECT_TRUE(MethodHandleImplOffsets().Check()); 807 EXPECT_TRUE(MethodHandlesLookupOffsets().Check()); 808 EXPECT_TRUE(EmulatedStackFrameOffsets().Check()); 809 EXPECT_TRUE(CallSiteOffsets().Check()); 810 } 811 812 TEST_F(ClassLinkerTest, FindClassNonexistent) { 813 ScopedObjectAccess soa(Thread::Current()); 814 AssertNonExistentClass("NoSuchClass;"); 815 AssertNonExistentClass("LNoSuchClass;"); 816 } 817 818 TEST_F(ClassLinkerTest, GetDexFiles) { 819 ScopedObjectAccess soa(Thread::Current()); 820 821 jobject jclass_loader = LoadDex("Nested"); 822 std::vector<const DexFile*> dex_files(GetDexFiles(jclass_loader)); 823 ASSERT_EQ(dex_files.size(), 1U); 824 EXPECT_TRUE(android::base::EndsWith(dex_files[0]->GetLocation(), "Nested.jar")); 825 826 jobject jclass_loader2 = LoadDex("MultiDex"); 827 std::vector<const DexFile*> dex_files2(GetDexFiles(jclass_loader2)); 828 ASSERT_EQ(dex_files2.size(), 2U); 829 EXPECT_TRUE(android::base::EndsWith(dex_files2[0]->GetLocation(), "MultiDex.jar")); 830 } 831 832 TEST_F(ClassLinkerTest, FindClassNested) { 833 ScopedObjectAccess soa(Thread::Current()); 834 StackHandleScope<1> hs(soa.Self()); 835 Handle<mirror::ClassLoader> class_loader( 836 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Nested")))); 837 838 mirror::Class* outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader); 839 ASSERT_TRUE(outer != nullptr); 840 EXPECT_EQ(0U, outer->NumVirtualMethods()); 841 EXPECT_EQ(1U, outer->NumDirectMethods()); 842 843 mirror::Class* inner = class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader); 844 ASSERT_TRUE(inner != nullptr); 845 EXPECT_EQ(0U, inner->NumVirtualMethods()); 846 EXPECT_EQ(1U, inner->NumDirectMethods()); 847 } 848 849 TEST_F(ClassLinkerTest, FindClass_Primitives) { 850 ScopedObjectAccess soa(Thread::Current()); 851 const std::string expected("BCDFIJSZV"); 852 for (int ch = 1; ch < 256; ++ch) { 853 std::string descriptor; 854 descriptor.push_back(ch); 855 if (expected.find(ch) == std::string::npos) { 856 AssertNonExistentClass(descriptor); 857 } else { 858 AssertPrimitiveClass(descriptor); 859 } 860 } 861 } 862 863 TEST_F(ClassLinkerTest, FindClass) { 864 ScopedObjectAccess soa(Thread::Current()); 865 mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"); 866 AssertObjectClass(JavaLangObject); 867 868 StackHandleScope<1> hs(soa.Self()); 869 Handle<mirror::ClassLoader> class_loader( 870 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass")))); 871 AssertNonExistentClass("LMyClass;"); 872 mirror::Class* MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader); 873 ASSERT_TRUE(MyClass != nullptr); 874 ASSERT_TRUE(MyClass->GetClass() != nullptr); 875 ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass()); 876 EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass()); 877 std::string temp; 878 ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;"); 879 EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject); 880 EXPECT_TRUE(MyClass->HasSuperClass()); 881 EXPECT_EQ(class_loader.Get(), MyClass->GetClassLoader()); 882 EXPECT_EQ(mirror::Class::kStatusResolved, MyClass->GetStatus()); 883 EXPECT_FALSE(MyClass->IsErroneous()); 884 EXPECT_TRUE(MyClass->IsLoaded()); 885 EXPECT_TRUE(MyClass->IsResolved()); 886 EXPECT_FALSE(MyClass->IsErroneousResolved()); 887 EXPECT_FALSE(MyClass->IsVerified()); 888 EXPECT_FALSE(MyClass->IsInitialized()); 889 EXPECT_FALSE(MyClass->IsArrayInstance()); 890 EXPECT_FALSE(MyClass->IsArrayClass()); 891 EXPECT_TRUE(MyClass->GetComponentType() == nullptr); 892 EXPECT_FALSE(MyClass->IsInterface()); 893 EXPECT_FALSE(MyClass->IsPublic()); 894 EXPECT_FALSE(MyClass->IsFinal()); 895 EXPECT_FALSE(MyClass->IsPrimitive()); 896 EXPECT_FALSE(MyClass->IsSynthetic()); 897 EXPECT_EQ(1U, MyClass->NumDirectMethods()); 898 EXPECT_EQ(0U, MyClass->NumVirtualMethods()); 899 EXPECT_EQ(0U, MyClass->NumInstanceFields()); 900 EXPECT_EQ(0U, MyClass->NumStaticFields()); 901 EXPECT_EQ(0U, MyClass->NumDirectInterfaces()); 902 903 EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass()); 904 905 // created by class_linker 906 AssertArrayClass("[C", "C", nullptr); 907 AssertArrayClass("[Ljava/lang/Object;", "Ljava/lang/Object;", nullptr); 908 // synthesized on the fly 909 AssertArrayClass("[[C", "[C", nullptr); 910 AssertArrayClass("[[[LMyClass;", "[[LMyClass;", class_loader.Get()); 911 // or not available at all 912 AssertNonExistentClass("[[[[LNonExistentClass;"); 913 } 914 915 TEST_F(ClassLinkerTest, LookupResolvedType) { 916 ScopedObjectAccess soa(Thread::Current()); 917 StackHandleScope<1> hs(soa.Self()); 918 Handle<mirror::ClassLoader> class_loader( 919 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass")))); 920 AssertNonExistentClass("LMyClass;"); 921 ObjPtr<mirror::Class> klass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader); 922 dex::TypeIndex type_idx = klass->GetClassDef()->class_idx_; 923 ObjPtr<mirror::DexCache> dex_cache = klass->GetDexCache(); 924 const DexFile& dex_file = klass->GetDexFile(); 925 EXPECT_OBJ_PTR_EQ( 926 class_linker_->LookupResolvedType(dex_file, type_idx, dex_cache, class_loader.Get()), 927 klass); 928 // Zero out the resolved type and make sure LookupResolvedType still finds it. 929 dex_cache->ClearResolvedType(type_idx); 930 EXPECT_TRUE(dex_cache->GetResolvedType(type_idx) == nullptr); 931 EXPECT_OBJ_PTR_EQ( 932 class_linker_->LookupResolvedType(dex_file, type_idx, dex_cache, class_loader.Get()), 933 klass); 934 } 935 936 TEST_F(ClassLinkerTest, LookupResolvedTypeArray) { 937 ScopedObjectAccess soa(Thread::Current()); 938 StackHandleScope<2> hs(soa.Self()); 939 Handle<mirror::ClassLoader> class_loader( 940 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("AllFields")))); 941 // Get the AllFields class for the dex cache and dex file. 942 ObjPtr<mirror::Class> all_fields_klass 943 = class_linker_->FindClass(soa.Self(), "LAllFields;", class_loader); 944 ASSERT_OBJ_PTR_NE(all_fields_klass, ObjPtr<mirror::Class>(nullptr)); 945 Handle<mirror::DexCache> dex_cache = hs.NewHandle(all_fields_klass->GetDexCache()); 946 const DexFile& dex_file = *dex_cache->GetDexFile(); 947 // Get the index of the array class we want to test. 948 const DexFile::TypeId* array_id = dex_file.FindTypeId("[Ljava/lang/Object;"); 949 ASSERT_TRUE(array_id != nullptr); 950 dex::TypeIndex array_idx = dex_file.GetIndexForTypeId(*array_id); 951 // Check that the array class wasn't resolved yet. 952 EXPECT_OBJ_PTR_EQ( 953 class_linker_->LookupResolvedType(dex_file, array_idx, dex_cache.Get(), class_loader.Get()), 954 ObjPtr<mirror::Class>(nullptr)); 955 // Resolve the array class we want to test. 956 ObjPtr<mirror::Class> array_klass 957 = class_linker_->FindClass(soa.Self(), "[Ljava/lang/Object;", class_loader); 958 ASSERT_OBJ_PTR_NE(array_klass, ObjPtr<mirror::Class>(nullptr)); 959 // Test that LookupResolvedType() finds the array class. 960 EXPECT_OBJ_PTR_EQ( 961 class_linker_->LookupResolvedType(dex_file, array_idx, dex_cache.Get(), class_loader.Get()), 962 array_klass); 963 // Zero out the resolved type and make sure LookupResolvedType() still finds it. 964 dex_cache->ClearResolvedType(array_idx); 965 EXPECT_TRUE(dex_cache->GetResolvedType(array_idx) == nullptr); 966 EXPECT_OBJ_PTR_EQ( 967 class_linker_->LookupResolvedType(dex_file, array_idx, dex_cache.Get(), class_loader.Get()), 968 array_klass); 969 } 970 971 TEST_F(ClassLinkerTest, LookupResolvedTypeErroneousInit) { 972 ScopedObjectAccess soa(Thread::Current()); 973 StackHandleScope<3> hs(soa.Self()); 974 Handle<mirror::ClassLoader> class_loader( 975 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("ErroneousInit")))); 976 AssertNonExistentClass("LErroneousInit;"); 977 Handle<mirror::Class> klass = 978 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LErroneousInit;", class_loader)); 979 ASSERT_OBJ_PTR_NE(klass.Get(), ObjPtr<mirror::Class>(nullptr)); 980 dex::TypeIndex type_idx = klass->GetClassDef()->class_idx_; 981 Handle<mirror::DexCache> dex_cache = hs.NewHandle(klass->GetDexCache()); 982 const DexFile& dex_file = klass->GetDexFile(); 983 EXPECT_OBJ_PTR_EQ( 984 class_linker_->LookupResolvedType(dex_file, type_idx, dex_cache.Get(), class_loader.Get()), 985 klass.Get()); 986 // Zero out the resolved type and make sure LookupResolvedType still finds it. 987 dex_cache->ClearResolvedType(type_idx); 988 EXPECT_TRUE(dex_cache->GetResolvedType(type_idx) == nullptr); 989 EXPECT_OBJ_PTR_EQ( 990 class_linker_->LookupResolvedType(dex_file, type_idx, dex_cache.Get(), class_loader.Get()), 991 klass.Get()); 992 // Force initialization to turn the class erroneous. 993 bool initialized = class_linker_->EnsureInitialized(soa.Self(), 994 klass, 995 /* can_init_fields */ true, 996 /* can_init_parents */ true); 997 EXPECT_FALSE(initialized); 998 EXPECT_TRUE(soa.Self()->IsExceptionPending()); 999 soa.Self()->ClearException(); 1000 // Check that the LookupResolvedType() can still find the resolved type. 1001 EXPECT_OBJ_PTR_EQ( 1002 class_linker_->LookupResolvedType(dex_file, type_idx, dex_cache.Get(), class_loader.Get()), 1003 klass.Get()); 1004 // Zero out the resolved type and make sure LookupResolvedType() still finds it. 1005 dex_cache->ClearResolvedType(type_idx); 1006 EXPECT_TRUE(dex_cache->GetResolvedType(type_idx) == nullptr); 1007 EXPECT_OBJ_PTR_EQ( 1008 class_linker_->LookupResolvedType(dex_file, type_idx, dex_cache.Get(), class_loader.Get()), 1009 klass.Get()); 1010 } 1011 1012 TEST_F(ClassLinkerTest, LibCore) { 1013 ScopedObjectAccess soa(Thread::Current()); 1014 ASSERT_TRUE(java_lang_dex_file_ != nullptr); 1015 AssertDexFile(*java_lang_dex_file_, nullptr); 1016 } 1017 1018 // The first reference array element must be a multiple of 4 bytes from the 1019 // start of the object 1020 TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) { 1021 ScopedObjectAccess soa(Thread::Current()); 1022 mirror::Class* array_class = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;"); 1023 mirror::ObjectArray<mirror::String>* array = 1024 mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), array_class, 0); 1025 uintptr_t data_offset = 1026 reinterpret_cast<uintptr_t>(array->GetRawData(sizeof(mirror::HeapReference<mirror::String>), 1027 0)); 1028 if (sizeof(mirror::HeapReference<mirror::String>) == sizeof(int32_t)) { 1029 EXPECT_TRUE(IsAligned<4>(data_offset)); // Check 4 byte alignment. 1030 } else { 1031 EXPECT_TRUE(IsAligned<8>(data_offset)); // Check 8 byte alignment. 1032 } 1033 } 1034 1035 TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) { 1036 ScopedObjectAccess soa(Thread::Current()); 1037 StackHandleScope<5> hs(soa.Self()); 1038 Handle<mirror::LongArray> long_array(hs.NewHandle(mirror::LongArray::Alloc(soa.Self(), 0))); 1039 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[J"), long_array->GetClass()); 1040 uintptr_t data_offset = reinterpret_cast<uintptr_t>(long_array->GetData()); 1041 EXPECT_TRUE(IsAligned<8>(data_offset)); // Longs require 8 byte alignment 1042 1043 Handle<mirror::DoubleArray> double_array(hs.NewHandle(mirror::DoubleArray::Alloc(soa.Self(), 0))); 1044 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[D"), double_array->GetClass()); 1045 data_offset = reinterpret_cast<uintptr_t>(double_array->GetData()); 1046 EXPECT_TRUE(IsAligned<8>(data_offset)); // Doubles require 8 byte alignment 1047 1048 Handle<mirror::IntArray> int_array(hs.NewHandle(mirror::IntArray::Alloc(soa.Self(), 0))); 1049 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[I"), int_array->GetClass()); 1050 data_offset = reinterpret_cast<uintptr_t>(int_array->GetData()); 1051 EXPECT_TRUE(IsAligned<4>(data_offset)); // Ints require 4 byte alignment 1052 1053 Handle<mirror::CharArray> char_array(hs.NewHandle(mirror::CharArray::Alloc(soa.Self(), 0))); 1054 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[C"), char_array->GetClass()); 1055 data_offset = reinterpret_cast<uintptr_t>(char_array->GetData()); 1056 EXPECT_TRUE(IsAligned<2>(data_offset)); // Chars require 2 byte alignment 1057 1058 Handle<mirror::ShortArray> short_array(hs.NewHandle(mirror::ShortArray::Alloc(soa.Self(), 0))); 1059 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[S"), short_array->GetClass()); 1060 data_offset = reinterpret_cast<uintptr_t>(short_array->GetData()); 1061 EXPECT_TRUE(IsAligned<2>(data_offset)); // Shorts require 2 byte alignment 1062 1063 // Take it as given that bytes and booleans have byte alignment 1064 } 1065 1066 TEST_F(ClassLinkerTest, ValidateBoxedTypes) { 1067 // Validate that the "value" field is always the 0th field in each of java.lang's box classes. 1068 // This lets UnboxPrimitive avoid searching for the field by name at runtime. 1069 ScopedObjectAccess soa(Thread::Current()); 1070 ScopedNullHandle<mirror::ClassLoader> class_loader; 1071 mirror::Class* c; 1072 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Boolean;", class_loader); 1073 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1074 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Byte;", class_loader); 1075 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1076 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Character;", class_loader); 1077 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1078 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Double;", class_loader); 1079 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1080 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Float;", class_loader); 1081 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1082 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Integer;", class_loader); 1083 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1084 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Long;", class_loader); 1085 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1086 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Short;", class_loader); 1087 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName()); 1088 } 1089 1090 TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) { 1091 ScopedObjectAccess soa(Thread::Current()); 1092 StackHandleScope<2> hs(soa.Self()); 1093 Handle<mirror::ClassLoader> class_loader_1( 1094 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass")))); 1095 Handle<mirror::ClassLoader> class_loader_2( 1096 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MyClass")))); 1097 mirror::Class* MyClass_1 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1); 1098 mirror::Class* MyClass_2 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2); 1099 EXPECT_TRUE(MyClass_1 != nullptr); 1100 EXPECT_TRUE(MyClass_2 != nullptr); 1101 EXPECT_NE(MyClass_1, MyClass_2); 1102 } 1103 1104 TEST_F(ClassLinkerTest, StaticFields) { 1105 ScopedObjectAccess soa(Thread::Current()); 1106 StackHandleScope<2> hs(soa.Self()); 1107 Handle<mirror::ClassLoader> class_loader( 1108 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Statics")))); 1109 Handle<mirror::Class> statics( 1110 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader))); 1111 class_linker_->EnsureInitialized(soa.Self(), statics, true, true); 1112 1113 // Static final primitives that are initialized by a compile-time constant 1114 // expression resolve to a copy of a constant value from the constant pool. 1115 // So <clinit> should be null. 1116 ArtMethod* clinit = statics->FindClassMethod("<clinit>", "()V", kRuntimePointerSize); 1117 EXPECT_TRUE(clinit == nullptr); 1118 1119 EXPECT_EQ(9U, statics->NumStaticFields()); 1120 1121 ArtField* s0 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s0", "Z"); 1122 EXPECT_EQ(s0->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean); 1123 EXPECT_EQ(true, s0->GetBoolean(statics.Get())); 1124 s0->SetBoolean<false>(statics.Get(), false); 1125 1126 ArtField* s1 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s1", "B"); 1127 EXPECT_EQ(s1->GetTypeAsPrimitiveType(), Primitive::kPrimByte); 1128 EXPECT_EQ(5, s1->GetByte(statics.Get())); 1129 s1->SetByte<false>(statics.Get(), 6); 1130 1131 ArtField* s2 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s2", "C"); 1132 EXPECT_EQ(s2->GetTypeAsPrimitiveType(), Primitive::kPrimChar); 1133 EXPECT_EQ('a', s2->GetChar(statics.Get())); 1134 s2->SetChar<false>(statics.Get(), 'b'); 1135 1136 ArtField* s3 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s3", "S"); 1137 EXPECT_EQ(s3->GetTypeAsPrimitiveType(), Primitive::kPrimShort); 1138 EXPECT_EQ(-536, s3->GetShort(statics.Get())); 1139 s3->SetShort<false>(statics.Get(), -535); 1140 1141 ArtField* s4 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s4", "I"); 1142 EXPECT_EQ(s4->GetTypeAsPrimitiveType(), Primitive::kPrimInt); 1143 EXPECT_EQ(2000000000, s4->GetInt(statics.Get())); 1144 s4->SetInt<false>(statics.Get(), 2000000001); 1145 1146 ArtField* s5 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s5", "J"); 1147 EXPECT_EQ(s5->GetTypeAsPrimitiveType(), Primitive::kPrimLong); 1148 EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong(statics.Get())); 1149 s5->SetLong<false>(statics.Get(), INT64_C(0x34567890abcdef12)); 1150 1151 ArtField* s6 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s6", "F"); 1152 EXPECT_EQ(s6->GetTypeAsPrimitiveType(), Primitive::kPrimFloat); 1153 EXPECT_DOUBLE_EQ(0.5, s6->GetFloat(statics.Get())); 1154 s6->SetFloat<false>(statics.Get(), 0.75); 1155 1156 ArtField* s7 = mirror::Class::FindStaticField(soa.Self(), statics.Get(), "s7", "D"); 1157 EXPECT_EQ(s7->GetTypeAsPrimitiveType(), Primitive::kPrimDouble); 1158 EXPECT_DOUBLE_EQ(16777217.0, s7->GetDouble(statics.Get())); 1159 s7->SetDouble<false>(statics.Get(), 16777219); 1160 1161 ArtField* s8 = mirror::Class::FindStaticField( 1162 soa.Self(), statics.Get(), "s8", "Ljava/lang/String;"); 1163 EXPECT_EQ(s8->GetTypeAsPrimitiveType(), Primitive::kPrimNot); 1164 EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("android")); 1165 mirror::String* str_value = mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot"); 1166 s8->SetObject<false>(s8->GetDeclaringClass(), str_value); 1167 1168 // TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ 1169 // http://code.google.com/p/googletest/issues/detail?id=322 1170 EXPECT_FALSE(s0->GetBoolean(statics.Get())); 1171 EXPECT_EQ(6, s1->GetByte(statics.Get())); 1172 EXPECT_EQ('b', s2->GetChar(statics.Get())); 1173 EXPECT_EQ(-535, s3->GetShort(statics.Get())); 1174 EXPECT_EQ(2000000001, s4->GetInt(statics.Get())); 1175 EXPECT_EQ(INT64_C(0x34567890abcdef12), s5->GetLong(statics.Get())); 1176 EXPECT_FLOAT_EQ(0.75, s6->GetFloat(statics.Get())); 1177 EXPECT_DOUBLE_EQ(16777219.0, s7->GetDouble(statics.Get())); 1178 EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("robot")); 1179 } 1180 1181 TEST_F(ClassLinkerTest, Interfaces) { 1182 ScopedObjectAccess soa(Thread::Current()); 1183 StackHandleScope<6> hs(soa.Self()); 1184 Handle<mirror::ClassLoader> class_loader( 1185 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Interfaces")))); 1186 Handle<mirror::Class> I( 1187 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$I;", class_loader))); 1188 Handle<mirror::Class> J( 1189 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$J;", class_loader))); 1190 Handle<mirror::Class> K( 1191 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$K;", class_loader))); 1192 Handle<mirror::Class> A( 1193 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$A;", class_loader))); 1194 Handle<mirror::Class> B( 1195 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$B;", class_loader))); 1196 EXPECT_TRUE(I->IsAssignableFrom(A.Get())); 1197 EXPECT_TRUE(J->IsAssignableFrom(A.Get())); 1198 EXPECT_TRUE(J->IsAssignableFrom(K.Get())); 1199 EXPECT_TRUE(K->IsAssignableFrom(B.Get())); 1200 EXPECT_TRUE(J->IsAssignableFrom(B.Get())); 1201 1202 const Signature void_sig = I->GetDexCache()->GetDexFile()->CreateSignature("()V"); 1203 ArtMethod* Ii = I->FindClassMethod("i", void_sig, kRuntimePointerSize); 1204 ArtMethod* Jj1 = J->FindClassMethod("j1", void_sig, kRuntimePointerSize); 1205 ArtMethod* Jj2 = J->FindClassMethod("j2", void_sig, kRuntimePointerSize); 1206 ArtMethod* Kj1 = K->FindInterfaceMethod("j1", void_sig, kRuntimePointerSize); 1207 ArtMethod* Kj2 = K->FindInterfaceMethod("j2", void_sig, kRuntimePointerSize); 1208 ArtMethod* Kk = K->FindInterfaceMethod("k", void_sig, kRuntimePointerSize); 1209 ArtMethod* Ai = A->FindClassMethod("i", void_sig, kRuntimePointerSize); 1210 ArtMethod* Aj1 = A->FindClassMethod("j1", void_sig, kRuntimePointerSize); 1211 ArtMethod* Aj2 = A->FindClassMethod("j2", void_sig, kRuntimePointerSize); 1212 ASSERT_TRUE(Ii != nullptr); 1213 ASSERT_FALSE(Ii->IsDirect()); 1214 ASSERT_TRUE(Jj1 != nullptr); 1215 ASSERT_FALSE(Jj1->IsDirect()); 1216 ASSERT_TRUE(Jj2 != nullptr); 1217 ASSERT_FALSE(Jj2->IsDirect()); 1218 ASSERT_TRUE(Kj1 != nullptr); 1219 ASSERT_TRUE(Kj2 != nullptr); 1220 ASSERT_TRUE(Kk != nullptr); 1221 ASSERT_TRUE(Ai != nullptr); 1222 ASSERT_FALSE(Ai->IsDirect()); 1223 ASSERT_TRUE(Aj1 != nullptr); 1224 ASSERT_FALSE(Aj1->IsDirect()); 1225 ASSERT_TRUE(Aj2 != nullptr); 1226 ASSERT_FALSE(Aj2->IsDirect()); 1227 EXPECT_NE(Ii, Ai); 1228 EXPECT_NE(Jj1, Aj1); 1229 EXPECT_NE(Jj2, Aj2); 1230 EXPECT_EQ(Kj1, Jj1); 1231 EXPECT_EQ(Kj2, Jj2); 1232 EXPECT_EQ(Ai, A->FindVirtualMethodForInterface(Ii, kRuntimePointerSize)); 1233 EXPECT_EQ(Aj1, A->FindVirtualMethodForInterface(Jj1, kRuntimePointerSize)); 1234 EXPECT_EQ(Aj2, A->FindVirtualMethodForInterface(Jj2, kRuntimePointerSize)); 1235 EXPECT_EQ(Ai, A->FindVirtualMethodForVirtualOrInterface(Ii, kRuntimePointerSize)); 1236 EXPECT_EQ(Aj1, A->FindVirtualMethodForVirtualOrInterface(Jj1, kRuntimePointerSize)); 1237 EXPECT_EQ(Aj2, A->FindVirtualMethodForVirtualOrInterface(Jj2, kRuntimePointerSize)); 1238 1239 ArtField* Afoo = 1240 mirror::Class::FindStaticField(soa.Self(), A.Get(), "foo", "Ljava/lang/String;"); 1241 ArtField* Bfoo = 1242 mirror::Class::FindStaticField(soa.Self(), B.Get(), "foo", "Ljava/lang/String;"); 1243 ArtField* Jfoo = 1244 mirror::Class::FindStaticField(soa.Self(), J.Get(), "foo", "Ljava/lang/String;"); 1245 ArtField* Kfoo = 1246 mirror::Class::FindStaticField(soa.Self(), K.Get(), "foo", "Ljava/lang/String;"); 1247 ASSERT_TRUE(Afoo != nullptr); 1248 EXPECT_EQ(Afoo, Bfoo); 1249 EXPECT_EQ(Afoo, Jfoo); 1250 EXPECT_EQ(Afoo, Kfoo); 1251 } 1252 1253 TEST_F(ClassLinkerTest, ResolveVerifyAndClinit) { 1254 // pretend we are trying to get the static storage for the StaticsFromCode class. 1255 1256 // case 1, get the uninitialized storage from StaticsFromCode.<clinit> 1257 // case 2, get the initialized storage from StaticsFromCode.getS0 1258 1259 ScopedObjectAccess soa(Thread::Current()); 1260 jobject jclass_loader = LoadDex("StaticsFromCode"); 1261 const DexFile* dex_file = GetFirstDexFile(jclass_loader); 1262 StackHandleScope<1> hs(soa.Self()); 1263 Handle<mirror::ClassLoader> class_loader( 1264 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 1265 mirror::Class* klass = class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader); 1266 ArtMethod* clinit = klass->FindClassInitializer(kRuntimePointerSize); 1267 ArtMethod* getS0 = 1268 klass->FindClassMethod("getS0", "()Ljava/lang/Object;", kRuntimePointerSize); 1269 ASSERT_TRUE(getS0 != nullptr); 1270 ASSERT_TRUE(getS0->IsStatic()); 1271 const DexFile::TypeId* type_id = dex_file->FindTypeId("LStaticsFromCode;"); 1272 ASSERT_TRUE(type_id != nullptr); 1273 dex::TypeIndex type_idx = dex_file->GetIndexForTypeId(*type_id); 1274 mirror::Class* uninit = ResolveVerifyAndClinit(type_idx, clinit, soa.Self(), true, false); 1275 EXPECT_TRUE(uninit != nullptr); 1276 EXPECT_FALSE(uninit->IsInitialized()); 1277 mirror::Class* init = ResolveVerifyAndClinit(type_idx, getS0, soa.Self(), true, false); 1278 EXPECT_TRUE(init != nullptr); 1279 EXPECT_TRUE(init->IsInitialized()); 1280 } 1281 1282 TEST_F(ClassLinkerTest, ErroneousClass) { 1283 ScopedObjectAccess soa(Thread::Current()); 1284 jobject jclass_loader = LoadMultiDex("ErroneousA", "ErroneousB"); 1285 StackHandleScope<1> hs(soa.Self()); 1286 Handle<mirror::ClassLoader> class_loader( 1287 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 1288 hs.Self()->AssertNoPendingException(); 1289 const char* descriptor = "LErroneous;"; 1290 ObjPtr<mirror::Class> klass = class_linker_->FindClass(soa.Self(), descriptor, class_loader); 1291 // Erronenous since we are extending final class. 1292 hs.Self()->AssertPendingException(); 1293 EXPECT_TRUE(klass == nullptr); 1294 klass = class_linker_->LookupClass(soa.Self(), descriptor, class_loader.Get()); 1295 EXPECT_FALSE(klass == nullptr); 1296 EXPECT_TRUE(klass->IsErroneous()); 1297 EXPECT_TRUE(klass->GetIfTable() != nullptr); 1298 } 1299 1300 TEST_F(ClassLinkerTest, FinalizableBit) { 1301 ScopedObjectAccess soa(Thread::Current()); 1302 mirror::Class* c; 1303 1304 // Object has a finalize method, but we know it's empty. 1305 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"); 1306 EXPECT_FALSE(c->IsFinalizable()); 1307 1308 // Enum has a finalize method to prevent its subclasses from implementing one. 1309 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Enum;"); 1310 EXPECT_FALSE(c->IsFinalizable()); 1311 1312 // RoundingMode is an enum. 1313 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/math/RoundingMode;"); 1314 EXPECT_FALSE(c->IsFinalizable()); 1315 1316 // RandomAccessFile extends Object and overrides finalize. 1317 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/RandomAccessFile;"); 1318 EXPECT_TRUE(c->IsFinalizable()); 1319 1320 // FileInputStream is finalizable and extends InputStream which isn't. 1321 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/InputStream;"); 1322 EXPECT_FALSE(c->IsFinalizable()); 1323 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/FileInputStream;"); 1324 EXPECT_TRUE(c->IsFinalizable()); 1325 1326 // ScheduledThreadPoolExecutor doesn't have a finalize method but 1327 // extends ThreadPoolExecutor which does. 1328 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ThreadPoolExecutor;"); 1329 EXPECT_TRUE(c->IsFinalizable()); 1330 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ScheduledThreadPoolExecutor;"); 1331 EXPECT_TRUE(c->IsFinalizable()); 1332 } 1333 1334 TEST_F(ClassLinkerTest, ClassRootDescriptors) { 1335 ScopedObjectAccess soa(Thread::Current()); 1336 std::string temp; 1337 for (int i = 0; i < ClassLinker::kClassRootsMax; i++) { 1338 mirror::Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i)); 1339 EXPECT_GT(strlen(klass->GetDescriptor(&temp)), 0U); 1340 EXPECT_STREQ(klass->GetDescriptor(&temp), 1341 class_linker_->GetClassRootDescriptor(ClassLinker::ClassRoot(i))) << " i = " << i; 1342 } 1343 } 1344 1345 TEST_F(ClassLinkerTest, ValidatePredefinedClassSizes) { 1346 ScopedObjectAccess soa(Thread::Current()); 1347 ScopedNullHandle<mirror::ClassLoader> class_loader; 1348 mirror::Class* c; 1349 1350 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Class;", class_loader); 1351 ASSERT_TRUE(c != nullptr); 1352 EXPECT_EQ(c->GetClassSize(), mirror::Class::ClassClassSize(kRuntimePointerSize)); 1353 1354 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Object;", class_loader); 1355 ASSERT_TRUE(c != nullptr); 1356 EXPECT_EQ(c->GetClassSize(), mirror::Object::ClassSize(kRuntimePointerSize)); 1357 1358 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/String;", class_loader); 1359 ASSERT_TRUE(c != nullptr); 1360 EXPECT_EQ(c->GetClassSize(), mirror::String::ClassSize(kRuntimePointerSize)); 1361 1362 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/DexCache;", class_loader); 1363 ASSERT_TRUE(c != nullptr); 1364 EXPECT_EQ(c->GetClassSize(), mirror::DexCache::ClassSize(kRuntimePointerSize)); 1365 } 1366 1367 static void CheckMethod(ArtMethod* method, bool verified) 1368 REQUIRES_SHARED(Locks::mutator_lock_) { 1369 if (!method->IsNative() && !method->IsAbstract()) { 1370 EXPECT_EQ((method->GetAccessFlags() & kAccSkipAccessChecks) != 0U, verified) 1371 << method->PrettyMethod(true); 1372 } 1373 } 1374 1375 static void CheckVerificationAttempted(mirror::Class* c, bool preverified) 1376 REQUIRES_SHARED(Locks::mutator_lock_) { 1377 EXPECT_EQ((c->GetAccessFlags() & kAccVerificationAttempted) != 0U, preverified) 1378 << "Class " << mirror::Class::PrettyClass(c) << " not as expected"; 1379 for (auto& m : c->GetMethods(kRuntimePointerSize)) { 1380 CheckMethod(&m, preverified); 1381 } 1382 } 1383 1384 TEST_F(ClassLinkerTest, Preverified_InitializedBoot) { 1385 ScopedObjectAccess soa(Thread::Current()); 1386 1387 mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"); 1388 ASSERT_TRUE(JavaLangObject != nullptr); 1389 EXPECT_TRUE(JavaLangObject->IsInitialized()) << "Not testing already initialized class from the " 1390 "core"; 1391 CheckVerificationAttempted(JavaLangObject, true); 1392 } 1393 1394 TEST_F(ClassLinkerTest, Preverified_UninitializedBoot) { 1395 ScopedObjectAccess soa(Thread::Current()); 1396 1397 StackHandleScope<1> hs(soa.Self()); 1398 1399 Handle<mirror::Class> security_manager(hs.NewHandle(class_linker_->FindSystemClass( 1400 soa.Self(), "Ljava/lang/SecurityManager;"))); 1401 EXPECT_FALSE(security_manager->IsInitialized()) << "Not testing uninitialized class from the " 1402 "core"; 1403 1404 CheckVerificationAttempted(security_manager.Get(), false); 1405 1406 class_linker_->EnsureInitialized(soa.Self(), security_manager, true, true); 1407 CheckVerificationAttempted(security_manager.Get(), true); 1408 } 1409 1410 TEST_F(ClassLinkerTest, Preverified_App) { 1411 ScopedObjectAccess soa(Thread::Current()); 1412 1413 StackHandleScope<2> hs(soa.Self()); 1414 Handle<mirror::ClassLoader> class_loader( 1415 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Statics")))); 1416 Handle<mirror::Class> statics( 1417 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader))); 1418 1419 CheckVerificationAttempted(statics.Get(), false); 1420 1421 class_linker_->EnsureInitialized(soa.Self(), statics, true, true); 1422 CheckVerificationAttempted(statics.Get(), true); 1423 } 1424 1425 TEST_F(ClassLinkerTest, IsBootStrapClassLoaded) { 1426 ScopedObjectAccess soa(Thread::Current()); 1427 1428 StackHandleScope<3> hs(soa.Self()); 1429 Handle<mirror::ClassLoader> class_loader( 1430 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("Statics")))); 1431 1432 // java.lang.Object is a bootstrap class. 1433 Handle<mirror::Class> jlo_class( 1434 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;"))); 1435 ASSERT_TRUE(jlo_class != nullptr); 1436 EXPECT_TRUE(jlo_class.Get()->IsBootStrapClassLoaded()); 1437 1438 // Statics is not a bootstrap class. 1439 Handle<mirror::Class> statics( 1440 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader))); 1441 ASSERT_TRUE(statics != nullptr); 1442 EXPECT_FALSE(statics.Get()->IsBootStrapClassLoaded()); 1443 } 1444 1445 // Regression test for b/26799552. 1446 TEST_F(ClassLinkerTest, RegisterDexFileName) { 1447 ScopedObjectAccess soa(Thread::Current()); 1448 StackHandleScope<2> hs(soa.Self()); 1449 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1450 MutableHandle<mirror::DexCache> dex_cache(hs.NewHandle<mirror::DexCache>(nullptr)); 1451 { 1452 ReaderMutexLock mu(soa.Self(), *Locks::dex_lock_); 1453 for (const ClassLinker::DexCacheData& data : class_linker->GetDexCachesData()) { 1454 dex_cache.Assign(soa.Self()->DecodeJObject(data.weak_root)->AsDexCache()); 1455 if (dex_cache != nullptr) { 1456 break; 1457 } 1458 } 1459 ASSERT_TRUE(dex_cache != nullptr); 1460 } 1461 // Make a copy of the dex cache and change the name. 1462 dex_cache.Assign(dex_cache->Clone(soa.Self())->AsDexCache()); 1463 const uint16_t data[] = { 0x20AC, 0x20A1 }; 1464 Handle<mirror::String> location(hs.NewHandle(mirror::String::AllocFromUtf16(soa.Self(), 1465 arraysize(data), 1466 data))); 1467 dex_cache->SetLocation(location.Get()); 1468 const DexFile* old_dex_file = dex_cache->GetDexFile(); 1469 1470 std::unique_ptr<DexFile> dex_file(new DexFile(old_dex_file->Begin(), 1471 old_dex_file->Size(), 1472 location->ToModifiedUtf8(), 1473 0u, 1474 nullptr)); 1475 { 1476 WriterMutexLock mu(soa.Self(), *Locks::dex_lock_); 1477 // Check that inserting with a UTF16 name works. 1478 class_linker->RegisterDexFileLocked(*dex_file, dex_cache.Get(), /* class_loader */ nullptr); 1479 } 1480 } 1481 1482 TEST_F(ClassLinkerMethodHandlesTest, TestResolveMethodTypes) { 1483 ScopedObjectAccess soa(Thread::Current()); 1484 1485 StackHandleScope<7> hs(soa.Self()); 1486 1487 Handle<mirror::ClassLoader> class_loader( 1488 hs.NewHandle(soa.Decode<mirror::ClassLoader>(LoadDex("MethodTypes")))); 1489 Handle<mirror::Class> method_types( 1490 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LMethodTypes;", class_loader))); 1491 class_linker_->EnsureInitialized(soa.Self(), method_types, true, true); 1492 1493 ArtMethod* method1 = method_types->FindClassMethod( 1494 "method1", 1495 "(Ljava/lang/String;)Ljava/lang/String;", 1496 kRuntimePointerSize); 1497 ASSERT_TRUE(method1 != nullptr); 1498 ASSERT_FALSE(method1->IsDirect()); 1499 1500 const DexFile& dex_file = *(method1->GetDexFile()); 1501 Handle<mirror::DexCache> dex_cache = hs.NewHandle( 1502 class_linker_->FindDexCache(Thread::Current(), dex_file)); 1503 1504 const DexFile::MethodId& method1_id = dex_file.GetMethodId(method1->GetDexMethodIndex()); 1505 1506 // This is the MethodType corresponding to the prototype of 1507 // String MethodTypes# method1(String). 1508 // Its RType = Ljava/lang/String; 1509 // Its PTypes = { Ljava/lang/String; } 1510 Handle<mirror::MethodType> method1_type = hs.NewHandle( 1511 class_linker_->ResolveMethodType(dex_file, method1_id.proto_idx_, dex_cache, class_loader)); 1512 1513 // Assert that the method type was resolved successfully. 1514 ASSERT_TRUE(method1_type != nullptr); 1515 1516 // Assert that the return type and the method arguments are as we expect. 1517 Handle<mirror::Class> string_class( 1518 hs.NewHandle(class_linker_->FindClass(soa.Self(), "Ljava/lang/String;", class_loader))); 1519 ASSERT_EQ(string_class.Get(), method1_type->GetRType()); 1520 ASSERT_EQ(string_class.Get(), method1_type->GetPTypes()->Get(0)); 1521 1522 // Resolve the method type again and assert that we get back the same value. 1523 Handle<mirror::MethodType> method1_type2 = hs.NewHandle( 1524 class_linker_->ResolveMethodType(dex_file, method1_id.proto_idx_, dex_cache, class_loader)); 1525 ASSERT_EQ(method1_type.Get(), method1_type2.Get()); 1526 1527 // Resolve the MethodType associated with a different method signature 1528 // and assert it's different. 1529 ArtMethod* method2 = method_types->FindClassMethod( 1530 "method2", 1531 "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;", 1532 kRuntimePointerSize); 1533 ASSERT_TRUE(method2 != nullptr); 1534 ASSERT_FALSE(method2->IsDirect()); 1535 const DexFile::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex()); 1536 Handle<mirror::MethodType> method2_type = hs.NewHandle( 1537 class_linker_->ResolveMethodType(dex_file, method2_id.proto_idx_, dex_cache, class_loader)); 1538 1539 ASSERT_TRUE(method1_type.Get() != method2_type.Get()); 1540 } 1541 1542 // Verify that ClassLinker's CreateWellknownClassLoader works as expected 1543 // by creating a chain of class loaders with various dex files. 1544 TEST_F(ClassLinkerTest, CreateWellKnownClassLoader) { 1545 // LoadDexIn*ClassLoader methods already assert that the parent loader is the expected one. 1546 // No need to check again. 1547 jobject class_loader_a = LoadDexInPathClassLoader("MyClass", nullptr); 1548 jobject class_loader_b = LoadDexInDelegateLastClassLoader("Nested", class_loader_a); 1549 jobject class_loader_c = LoadDexInPathClassLoader("MultiDex", class_loader_b); 1550 LoadDexInDelegateLastClassLoader("Interfaces", class_loader_c); 1551 } 1552 1553 class ClassLinkerClassLoaderTest : public ClassLinkerTest { 1554 protected: 1555 // Verifies that the class identified by the given descriptor is loaded with 1556 // the expected_class_loader_obj when search from class_loader_to_search_obj. 1557 // When expected_class_loader_obj is null the check will be done against BootClassLoader. 1558 void VerifyClassResolution(const std::string& descriptor, 1559 jobject class_loader_to_search_obj, 1560 jobject expected_class_loader_obj, 1561 bool should_find = true) { 1562 Thread* self = Thread::Current(); 1563 ScopedObjectAccess soa(self); 1564 StackHandleScope<3> hs(self); 1565 Handle<mirror::ClassLoader> class_loader_to_search( 1566 hs.NewHandle(soa.Decode<mirror::ClassLoader>(class_loader_to_search_obj))); 1567 1568 Handle<mirror::Class> klass = hs.NewHandle( 1569 class_linker_->FindClass(soa.Self(), descriptor.c_str(), class_loader_to_search)); 1570 1571 if (!should_find) { 1572 if (self->IsExceptionPending()) { 1573 self->ClearException(); 1574 } 1575 ASSERT_TRUE(klass == nullptr); 1576 } else if (expected_class_loader_obj == nullptr) { 1577 ASSERT_TRUE(ClassLinker::IsBootClassLoader(soa, klass->GetClassLoader())); 1578 } else { 1579 ASSERT_TRUE(klass != nullptr) << descriptor; 1580 Handle<mirror::ClassLoader> expected_class_loader( 1581 hs.NewHandle(soa.Decode<mirror::ClassLoader>(expected_class_loader_obj))); 1582 ASSERT_EQ(klass->GetClassLoader(), expected_class_loader.Get()); 1583 } 1584 } 1585 }; 1586 1587 TEST_F(ClassLinkerClassLoaderTest, CreatePathClassLoader) { 1588 jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr); 1589 VerifyClassResolution("LDefinedInA;", class_loader_a, class_loader_a); 1590 VerifyClassResolution("Ljava/lang/String;", class_loader_a, nullptr); 1591 VerifyClassResolution("LDefinedInB;", class_loader_a, nullptr, /*should_find*/ false); 1592 } 1593 1594 TEST_F(ClassLinkerClassLoaderTest, CreateDelegateLastClassLoader) { 1595 jobject class_loader_a = LoadDexInDelegateLastClassLoader("ForClassLoaderA", nullptr); 1596 VerifyClassResolution("LDefinedInA;", class_loader_a, class_loader_a); 1597 VerifyClassResolution("Ljava/lang/String;", class_loader_a, nullptr); 1598 VerifyClassResolution("LDefinedInB;", class_loader_a, nullptr, /*should_find*/ false); 1599 } 1600 1601 TEST_F(ClassLinkerClassLoaderTest, CreateClassLoaderChain) { 1602 // The chain is 1603 // ClassLoaderA (PathClassLoader, defines: A, AB, AC, AD) 1604 // ^ 1605 // | 1606 // ClassLoaderB (DelegateLastClassLoader, defines: B, AB, BC, BD) 1607 // ^ 1608 // | 1609 // ClassLoaderC (PathClassLoader, defines: C, AC, BC, CD) 1610 // ^ 1611 // | 1612 // ClassLoaderD (DelegateLastClassLoader, defines: D, AD, BD, CD) 1613 1614 jobject class_loader_a = LoadDexInPathClassLoader("ForClassLoaderA", nullptr); 1615 jobject class_loader_b = LoadDexInDelegateLastClassLoader("ForClassLoaderB", class_loader_a); 1616 jobject class_loader_c = LoadDexInPathClassLoader("ForClassLoaderC", class_loader_b); 1617 jobject class_loader_d = LoadDexInDelegateLastClassLoader("ForClassLoaderD", class_loader_c); 1618 1619 // Verify exclusive classes (present in only one class loader). 1620 VerifyClassResolution("LDefinedInD;", class_loader_d, class_loader_d); 1621 VerifyClassResolution("LDefinedInC;", class_loader_d, class_loader_c); 1622 VerifyClassResolution("LDefinedInB;", class_loader_d, class_loader_b); 1623 VerifyClassResolution("LDefinedInA;", class_loader_d, class_loader_a); 1624 1625 // Verify classes that are defined in multiple classloader. 1626 1627 // Classes defined in B should be found in B even if they are defined in A or C because 1628 // B is a DelegateLastClassLoader. 1629 VerifyClassResolution("LDefinedInAB;", class_loader_d, class_loader_b); 1630 VerifyClassResolution("LDefinedInABC;", class_loader_d, class_loader_b); 1631 VerifyClassResolution("LDefinedInBC;", class_loader_d, class_loader_b); 1632 1633 // Classes defined in D should be found in D even if they are defined in parent class loaders 1634 // as well because D is a DelegateLastClassLoader. 1635 VerifyClassResolution("LDefinedInAD;", class_loader_d, class_loader_d); 1636 VerifyClassResolution("LDefinedInBD;", class_loader_d, class_loader_d); 1637 VerifyClassResolution("LDefinedInCD;", class_loader_d, class_loader_d); 1638 1639 1640 // Classes not defined in the DelegateLastClassLoaders (i.e. D or B) should be found 1641 // in the top parent. 1642 VerifyClassResolution("LDefinedInAC;", class_loader_d, class_loader_a); 1643 1644 // Sanity check that we don't find an undefined class. 1645 VerifyClassResolution("LNotDefined;", class_loader_d, nullptr, /*should_find*/ false); 1646 } 1647 1648 } // namespace art 1649