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