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 "image.h" 18 19 #include <memory> 20 #include <string> 21 #include <vector> 22 23 #include "android-base/stringprintf.h" 24 25 #include "art_method-inl.h" 26 #include "base/unix_file/fd_file.h" 27 #include "class_linker-inl.h" 28 #include "compiler_callbacks.h" 29 #include "common_compiler_test.h" 30 #include "debug/method_debug_info.h" 31 #include "dex/quick_compiler_callbacks.h" 32 #include "driver/compiler_options.h" 33 #include "elf_writer.h" 34 #include "elf_writer_quick.h" 35 #include "gc/space/image_space.h" 36 #include "image_writer.h" 37 #include "linker/buffered_output_stream.h" 38 #include "linker/file_output_stream.h" 39 #include "linker/multi_oat_relative_patcher.h" 40 #include "lock_word.h" 41 #include "mirror/object-inl.h" 42 #include "oat_writer.h" 43 #include "scoped_thread_state_change-inl.h" 44 #include "signal_catcher.h" 45 #include "utils.h" 46 47 namespace art { 48 49 static const uintptr_t kRequestedImageBase = ART_BASE_ADDRESS; 50 51 struct CompilationHelper { 52 std::vector<std::string> dex_file_locations; 53 std::vector<ScratchFile> image_locations; 54 std::vector<std::unique_ptr<const DexFile>> extra_dex_files; 55 std::vector<ScratchFile> image_files; 56 std::vector<ScratchFile> oat_files; 57 std::vector<ScratchFile> vdex_files; 58 std::string image_dir; 59 60 void Compile(CompilerDriver* driver, 61 ImageHeader::StorageMode storage_mode); 62 63 std::vector<size_t> GetImageObjectSectionSizes(); 64 65 ~CompilationHelper(); 66 }; 67 68 class ImageTest : public CommonCompilerTest { 69 protected: 70 virtual void SetUp() { 71 ReserveImageSpace(); 72 CommonCompilerTest::SetUp(); 73 } 74 75 void TestWriteRead(ImageHeader::StorageMode storage_mode); 76 77 void Compile(ImageHeader::StorageMode storage_mode, 78 CompilationHelper& out_helper, 79 const std::string& extra_dex = "", 80 const std::initializer_list<std::string>& image_classes = {}); 81 82 void SetUpRuntimeOptions(RuntimeOptions* options) OVERRIDE { 83 CommonCompilerTest::SetUpRuntimeOptions(options); 84 callbacks_.reset(new QuickCompilerCallbacks( 85 verification_results_.get(), 86 CompilerCallbacks::CallbackMode::kCompileBootImage)); 87 options->push_back(std::make_pair("compilercallbacks", callbacks_.get())); 88 } 89 90 std::unordered_set<std::string>* GetImageClasses() OVERRIDE { 91 return new std::unordered_set<std::string>(image_classes_); 92 } 93 94 ArtMethod* FindCopiedMethod(ArtMethod* origin, mirror::Class* klass) 95 REQUIRES_SHARED(Locks::mutator_lock_) { 96 PointerSize pointer_size = class_linker_->GetImagePointerSize(); 97 for (ArtMethod& m : klass->GetCopiedMethods(pointer_size)) { 98 if (strcmp(origin->GetName(), m.GetName()) == 0 && 99 origin->GetSignature() == m.GetSignature()) { 100 return &m; 101 } 102 } 103 return nullptr; 104 } 105 106 private: 107 std::unordered_set<std::string> image_classes_; 108 }; 109 110 CompilationHelper::~CompilationHelper() { 111 for (ScratchFile& image_file : image_files) { 112 image_file.Unlink(); 113 } 114 for (ScratchFile& oat_file : oat_files) { 115 oat_file.Unlink(); 116 } 117 for (ScratchFile& vdex_file : vdex_files) { 118 vdex_file.Unlink(); 119 } 120 const int rmdir_result = rmdir(image_dir.c_str()); 121 CHECK_EQ(0, rmdir_result); 122 } 123 124 std::vector<size_t> CompilationHelper::GetImageObjectSectionSizes() { 125 std::vector<size_t> ret; 126 for (ScratchFile& image_file : image_files) { 127 std::unique_ptr<File> file(OS::OpenFileForReading(image_file.GetFilename().c_str())); 128 CHECK(file.get() != nullptr); 129 ImageHeader image_header; 130 CHECK_EQ(file->ReadFully(&image_header, sizeof(image_header)), true); 131 CHECK(image_header.IsValid()); 132 ret.push_back(image_header.GetImageSize()); 133 } 134 return ret; 135 } 136 137 void CompilationHelper::Compile(CompilerDriver* driver, 138 ImageHeader::StorageMode storage_mode) { 139 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 140 std::vector<const DexFile*> class_path = class_linker->GetBootClassPath(); 141 142 for (const std::unique_ptr<const DexFile>& dex_file : extra_dex_files) { 143 { 144 ScopedObjectAccess soa(Thread::Current()); 145 // Inject in boot class path so that the compiler driver can see it. 146 class_linker->AppendToBootClassPath(soa.Self(), *dex_file.get()); 147 } 148 class_path.push_back(dex_file.get()); 149 } 150 151 // Enable write for dex2dex. 152 for (const DexFile* dex_file : class_path) { 153 dex_file_locations.push_back(dex_file->GetLocation()); 154 if (dex_file->IsReadOnly()) { 155 dex_file->EnableWrite(); 156 } 157 } 158 { 159 // Create a generic tmp file, to be the base of the .art and .oat temporary files. 160 ScratchFile location; 161 for (int i = 0; i < static_cast<int>(class_path.size()); ++i) { 162 std::string cur_location = 163 android::base::StringPrintf("%s-%d.art", location.GetFilename().c_str(), i); 164 image_locations.push_back(ScratchFile(cur_location)); 165 } 166 } 167 std::vector<std::string> image_filenames; 168 for (ScratchFile& file : image_locations) { 169 std::string image_filename(GetSystemImageFilename(file.GetFilename().c_str(), kRuntimeISA)); 170 image_filenames.push_back(image_filename); 171 size_t pos = image_filename.rfind('/'); 172 CHECK_NE(pos, std::string::npos) << image_filename; 173 if (image_dir.empty()) { 174 image_dir = image_filename.substr(0, pos); 175 int mkdir_result = mkdir(image_dir.c_str(), 0700); 176 CHECK_EQ(0, mkdir_result) << image_dir; 177 } 178 image_files.push_back(ScratchFile(OS::CreateEmptyFile(image_filename.c_str()))); 179 } 180 181 std::vector<std::string> oat_filenames; 182 std::vector<std::string> vdex_filenames; 183 for (const std::string& image_filename : image_filenames) { 184 std::string oat_filename = ReplaceFileExtension(image_filename, "oat"); 185 oat_files.push_back(ScratchFile(OS::CreateEmptyFile(oat_filename.c_str()))); 186 oat_filenames.push_back(oat_filename); 187 std::string vdex_filename = ReplaceFileExtension(image_filename, "vdex"); 188 vdex_files.push_back(ScratchFile(OS::CreateEmptyFile(vdex_filename.c_str()))); 189 vdex_filenames.push_back(vdex_filename); 190 } 191 192 std::unordered_map<const DexFile*, size_t> dex_file_to_oat_index_map; 193 std::vector<const char*> oat_filename_vector; 194 for (const std::string& file : oat_filenames) { 195 oat_filename_vector.push_back(file.c_str()); 196 } 197 std::vector<const char*> image_filename_vector; 198 for (const std::string& file : image_filenames) { 199 image_filename_vector.push_back(file.c_str()); 200 } 201 size_t image_idx = 0; 202 for (const DexFile* dex_file : class_path) { 203 dex_file_to_oat_index_map.emplace(dex_file, image_idx); 204 ++image_idx; 205 } 206 // TODO: compile_pic should be a test argument. 207 std::unique_ptr<ImageWriter> writer(new ImageWriter(*driver, 208 kRequestedImageBase, 209 /*compile_pic*/false, 210 /*compile_app_image*/false, 211 storage_mode, 212 oat_filename_vector, 213 dex_file_to_oat_index_map)); 214 { 215 { 216 jobject class_loader = nullptr; 217 TimingLogger timings("ImageTest::WriteRead", false, false); 218 TimingLogger::ScopedTiming t("CompileAll", &timings); 219 driver->SetDexFilesForOatFile(class_path); 220 driver->CompileAll(class_loader, class_path, /* verifier_deps */ nullptr, &timings); 221 222 t.NewTiming("WriteElf"); 223 SafeMap<std::string, std::string> key_value_store; 224 std::vector<const char*> dex_filename_vector; 225 for (size_t i = 0; i < class_path.size(); ++i) { 226 dex_filename_vector.push_back(""); 227 } 228 key_value_store.Put(OatHeader::kBootClassPathKey, 229 gc::space::ImageSpace::GetMultiImageBootClassPath( 230 dex_filename_vector, 231 oat_filename_vector, 232 image_filename_vector)); 233 234 std::vector<std::unique_ptr<ElfWriter>> elf_writers; 235 std::vector<std::unique_ptr<OatWriter>> oat_writers; 236 for (ScratchFile& oat_file : oat_files) { 237 elf_writers.emplace_back(CreateElfWriterQuick(driver->GetInstructionSet(), 238 driver->GetInstructionSetFeatures(), 239 &driver->GetCompilerOptions(), 240 oat_file.GetFile())); 241 elf_writers.back()->Start(); 242 oat_writers.emplace_back(new OatWriter(/*compiling_boot_image*/true, 243 &timings, 244 /*profile_compilation_info*/nullptr)); 245 } 246 247 std::vector<OutputStream*> rodata; 248 std::vector<std::unique_ptr<MemMap>> opened_dex_files_map; 249 std::vector<std::unique_ptr<const DexFile>> opened_dex_files; 250 // Now that we have finalized key_value_store_, start writing the oat file. 251 for (size_t i = 0, size = oat_writers.size(); i != size; ++i) { 252 const DexFile* dex_file = class_path[i]; 253 rodata.push_back(elf_writers[i]->StartRoData()); 254 ArrayRef<const uint8_t> raw_dex_file( 255 reinterpret_cast<const uint8_t*>(&dex_file->GetHeader()), 256 dex_file->GetHeader().file_size_); 257 oat_writers[i]->AddRawDexFileSource(raw_dex_file, 258 dex_file->GetLocation().c_str(), 259 dex_file->GetLocationChecksum()); 260 261 std::unique_ptr<MemMap> cur_opened_dex_files_map; 262 std::vector<std::unique_ptr<const DexFile>> cur_opened_dex_files; 263 bool dex_files_ok = oat_writers[i]->WriteAndOpenDexFiles( 264 kIsVdexEnabled ? vdex_files[i].GetFile() : oat_files[i].GetFile(), 265 rodata.back(), 266 driver->GetInstructionSet(), 267 driver->GetInstructionSetFeatures(), 268 &key_value_store, 269 /* verify */ false, // Dex files may be dex-to-dex-ed, don't verify. 270 /* update_input_vdex */ false, 271 &cur_opened_dex_files_map, 272 &cur_opened_dex_files); 273 ASSERT_TRUE(dex_files_ok); 274 275 if (cur_opened_dex_files_map != nullptr) { 276 opened_dex_files_map.push_back(std::move(cur_opened_dex_files_map)); 277 for (std::unique_ptr<const DexFile>& cur_dex_file : cur_opened_dex_files) { 278 // dex_file_oat_index_map_.emplace(dex_file.get(), i); 279 opened_dex_files.push_back(std::move(cur_dex_file)); 280 } 281 } else { 282 ASSERT_TRUE(cur_opened_dex_files.empty()); 283 } 284 } 285 bool image_space_ok = writer->PrepareImageAddressSpace(); 286 ASSERT_TRUE(image_space_ok); 287 288 if (kIsVdexEnabled) { 289 for (size_t i = 0, size = vdex_files.size(); i != size; ++i) { 290 std::unique_ptr<BufferedOutputStream> vdex_out( 291 MakeUnique<BufferedOutputStream>( 292 MakeUnique<FileOutputStream>(vdex_files[i].GetFile()))); 293 oat_writers[i]->WriteVerifierDeps(vdex_out.get(), nullptr); 294 oat_writers[i]->WriteChecksumsAndVdexHeader(vdex_out.get()); 295 } 296 } 297 298 for (size_t i = 0, size = oat_files.size(); i != size; ++i) { 299 linker::MultiOatRelativePatcher patcher(driver->GetInstructionSet(), 300 driver->GetInstructionSetFeatures()); 301 OatWriter* const oat_writer = oat_writers[i].get(); 302 ElfWriter* const elf_writer = elf_writers[i].get(); 303 std::vector<const DexFile*> cur_dex_files(1u, class_path[i]); 304 oat_writer->Initialize(driver, writer.get(), cur_dex_files); 305 oat_writer->PrepareLayout(&patcher); 306 size_t rodata_size = oat_writer->GetOatHeader().GetExecutableOffset(); 307 size_t text_size = oat_writer->GetOatSize() - rodata_size; 308 elf_writer->PrepareDynamicSection(rodata_size, 309 text_size, 310 oat_writer->GetBssSize(), 311 oat_writer->GetBssRootsOffset()); 312 313 writer->UpdateOatFileLayout(i, 314 elf_writer->GetLoadedSize(), 315 oat_writer->GetOatDataOffset(), 316 oat_writer->GetOatSize()); 317 318 bool rodata_ok = oat_writer->WriteRodata(rodata[i]); 319 ASSERT_TRUE(rodata_ok); 320 elf_writer->EndRoData(rodata[i]); 321 322 OutputStream* text = elf_writer->StartText(); 323 bool text_ok = oat_writer->WriteCode(text); 324 ASSERT_TRUE(text_ok); 325 elf_writer->EndText(text); 326 327 bool header_ok = oat_writer->WriteHeader(elf_writer->GetStream(), 0u, 0u, 0u); 328 ASSERT_TRUE(header_ok); 329 330 writer->UpdateOatFileHeader(i, oat_writer->GetOatHeader()); 331 332 elf_writer->WriteDynamicSection(); 333 elf_writer->WriteDebugInfo(oat_writer->GetMethodDebugInfo()); 334 335 bool success = elf_writer->End(); 336 ASSERT_TRUE(success); 337 } 338 } 339 340 bool success_image = writer->Write(kInvalidFd, 341 image_filename_vector, 342 oat_filename_vector); 343 ASSERT_TRUE(success_image); 344 345 for (size_t i = 0, size = oat_filenames.size(); i != size; ++i) { 346 const char* oat_filename = oat_filenames[i].c_str(); 347 std::unique_ptr<File> oat_file(OS::OpenFileReadWrite(oat_filename)); 348 ASSERT_TRUE(oat_file != nullptr); 349 bool success_fixup = ElfWriter::Fixup(oat_file.get(), 350 writer->GetOatDataBegin(i)); 351 ASSERT_TRUE(success_fixup); 352 ASSERT_EQ(oat_file->FlushCloseOrErase(), 0) << "Could not flush and close oat file " 353 << oat_filename; 354 } 355 } 356 } 357 358 void ImageTest::Compile(ImageHeader::StorageMode storage_mode, 359 CompilationHelper& helper, 360 const std::string& extra_dex, 361 const std::initializer_list<std::string>& image_classes) { 362 for (const std::string& image_class : image_classes) { 363 image_classes_.insert(image_class); 364 } 365 CreateCompilerDriver(Compiler::kOptimizing, kRuntimeISA, kIsTargetBuild ? 2U : 16U); 366 // Set inline filter values. 367 compiler_options_->SetInlineMaxCodeUnits(CompilerOptions::kDefaultInlineMaxCodeUnits); 368 image_classes_.clear(); 369 if (!extra_dex.empty()) { 370 helper.extra_dex_files = OpenTestDexFiles(extra_dex.c_str()); 371 } 372 helper.Compile(compiler_driver_.get(), storage_mode); 373 if (image_classes.begin() != image_classes.end()) { 374 // Make sure the class got initialized. 375 ScopedObjectAccess soa(Thread::Current()); 376 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker(); 377 for (const std::string& image_class : image_classes) { 378 mirror::Class* klass = class_linker->FindSystemClass(Thread::Current(), image_class.c_str()); 379 EXPECT_TRUE(klass != nullptr); 380 EXPECT_TRUE(klass->IsInitialized()); 381 } 382 } 383 } 384 385 void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) { 386 CompilationHelper helper; 387 Compile(storage_mode, /*out*/ helper); 388 std::vector<uint64_t> image_file_sizes; 389 for (ScratchFile& image_file : helper.image_files) { 390 std::unique_ptr<File> file(OS::OpenFileForReading(image_file.GetFilename().c_str())); 391 ASSERT_TRUE(file.get() != nullptr); 392 ImageHeader image_header; 393 ASSERT_EQ(file->ReadFully(&image_header, sizeof(image_header)), true); 394 ASSERT_TRUE(image_header.IsValid()); 395 const auto& bitmap_section = image_header.GetImageSection(ImageHeader::kSectionImageBitmap); 396 ASSERT_GE(bitmap_section.Offset(), sizeof(image_header)); 397 ASSERT_NE(0U, bitmap_section.Size()); 398 399 gc::Heap* heap = Runtime::Current()->GetHeap(); 400 ASSERT_TRUE(heap->HaveContinuousSpaces()); 401 gc::space::ContinuousSpace* space = heap->GetNonMovingSpace(); 402 ASSERT_FALSE(space->IsImageSpace()); 403 ASSERT_TRUE(space != nullptr); 404 ASSERT_TRUE(space->IsMallocSpace()); 405 image_file_sizes.push_back(file->GetLength()); 406 } 407 408 ASSERT_TRUE(compiler_driver_->GetImageClasses() != nullptr); 409 std::unordered_set<std::string> image_classes(*compiler_driver_->GetImageClasses()); 410 411 // Need to delete the compiler since it has worker threads which are attached to runtime. 412 compiler_driver_.reset(); 413 414 // Tear down old runtime before making a new one, clearing out misc state. 415 416 // Remove the reservation of the memory for use to load the image. 417 // Need to do this before we reset the runtime. 418 UnreserveImageSpace(); 419 420 helper.extra_dex_files.clear(); 421 runtime_.reset(); 422 java_lang_dex_file_ = nullptr; 423 424 MemMap::Init(); 425 426 RuntimeOptions options; 427 std::string image("-Ximage:"); 428 image.append(helper.image_locations[0].GetFilename()); 429 options.push_back(std::make_pair(image.c_str(), static_cast<void*>(nullptr))); 430 // By default the compiler this creates will not include patch information. 431 options.push_back(std::make_pair("-Xnorelocate", nullptr)); 432 433 if (!Runtime::Create(options, false)) { 434 LOG(FATAL) << "Failed to create runtime"; 435 return; 436 } 437 runtime_.reset(Runtime::Current()); 438 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start, 439 // give it away now and then switch to a more managable ScopedObjectAccess. 440 Thread::Current()->TransitionFromRunnableToSuspended(kNative); 441 ScopedObjectAccess soa(Thread::Current()); 442 ASSERT_TRUE(runtime_.get() != nullptr); 443 class_linker_ = runtime_->GetClassLinker(); 444 445 gc::Heap* heap = Runtime::Current()->GetHeap(); 446 ASSERT_TRUE(heap->HasBootImageSpace()); 447 ASSERT_TRUE(heap->GetNonMovingSpace()->IsMallocSpace()); 448 449 // We loaded the runtime with an explicit image, so it must exist. 450 ASSERT_EQ(heap->GetBootImageSpaces().size(), image_file_sizes.size()); 451 for (size_t i = 0; i < helper.dex_file_locations.size(); ++i) { 452 std::unique_ptr<const DexFile> dex( 453 LoadExpectSingleDexFile(helper.dex_file_locations[i].c_str())); 454 ASSERT_TRUE(dex != nullptr); 455 uint64_t image_file_size = image_file_sizes[i]; 456 gc::space::ImageSpace* image_space = heap->GetBootImageSpaces()[i]; 457 ASSERT_TRUE(image_space != nullptr); 458 if (storage_mode == ImageHeader::kStorageModeUncompressed) { 459 // Uncompressed, image should be smaller than file. 460 ASSERT_LE(image_space->GetImageHeader().GetImageSize(), image_file_size); 461 } else if (image_file_size > 16 * KB) { 462 // Compressed, file should be smaller than image. Not really valid for small images. 463 ASSERT_LE(image_file_size, image_space->GetImageHeader().GetImageSize()); 464 } 465 466 image_space->VerifyImageAllocations(); 467 uint8_t* image_begin = image_space->Begin(); 468 uint8_t* image_end = image_space->End(); 469 if (i == 0) { 470 // This check is only valid for image 0. 471 CHECK_EQ(kRequestedImageBase, reinterpret_cast<uintptr_t>(image_begin)); 472 } 473 for (size_t j = 0; j < dex->NumClassDefs(); ++j) { 474 const DexFile::ClassDef& class_def = dex->GetClassDef(j); 475 const char* descriptor = dex->GetClassDescriptor(class_def); 476 mirror::Class* klass = class_linker_->FindSystemClass(soa.Self(), descriptor); 477 EXPECT_TRUE(klass != nullptr) << descriptor; 478 if (image_classes.find(descriptor) == image_classes.end()) { 479 EXPECT_TRUE(reinterpret_cast<uint8_t*>(klass) >= image_end || 480 reinterpret_cast<uint8_t*>(klass) < image_begin) << descriptor; 481 } else { 482 // Image classes should be located inside the image. 483 EXPECT_LT(image_begin, reinterpret_cast<uint8_t*>(klass)) << descriptor; 484 EXPECT_LT(reinterpret_cast<uint8_t*>(klass), image_end) << descriptor; 485 } 486 EXPECT_TRUE(Monitor::IsValidLockWord(klass->GetLockWord(false))); 487 } 488 } 489 } 490 491 TEST_F(ImageTest, WriteReadUncompressed) { 492 TestWriteRead(ImageHeader::kStorageModeUncompressed); 493 } 494 495 TEST_F(ImageTest, WriteReadLZ4) { 496 TestWriteRead(ImageHeader::kStorageModeLZ4); 497 } 498 499 TEST_F(ImageTest, WriteReadLZ4HC) { 500 TestWriteRead(ImageHeader::kStorageModeLZ4HC); 501 } 502 503 TEST_F(ImageTest, TestImageLayout) { 504 std::vector<size_t> image_sizes; 505 std::vector<size_t> image_sizes_extra; 506 // Compile multi-image with ImageLayoutA being the last image. 507 { 508 CompilationHelper helper; 509 Compile(ImageHeader::kStorageModeUncompressed, helper, "ImageLayoutA", {"LMyClass;"}); 510 image_sizes = helper.GetImageObjectSectionSizes(); 511 } 512 TearDown(); 513 runtime_.reset(); 514 SetUp(); 515 // Compile multi-image with ImageLayoutB being the last image. 516 { 517 CompilationHelper helper; 518 Compile(ImageHeader::kStorageModeUncompressed, helper, "ImageLayoutB", {"LMyClass;"}); 519 image_sizes_extra = helper.GetImageObjectSectionSizes(); 520 } 521 // Make sure that the new stuff in the clinit in ImageLayoutB is in the last image and not in the 522 // first two images. 523 ASSERT_EQ(image_sizes.size(), image_sizes.size()); 524 // Sizes of the images should be the same. These sizes are for the whole image unrounded. 525 for (size_t i = 0; i < image_sizes.size() - 1; ++i) { 526 EXPECT_EQ(image_sizes[i], image_sizes_extra[i]); 527 } 528 // Last image should be larger since it has a hash map and a string. 529 EXPECT_LT(image_sizes.back(), image_sizes_extra.back()); 530 } 531 532 TEST_F(ImageTest, ImageHeaderIsValid) { 533 uint32_t image_begin = ART_BASE_ADDRESS; 534 uint32_t image_size_ = 16 * KB; 535 uint32_t image_roots = ART_BASE_ADDRESS + (1 * KB); 536 uint32_t oat_checksum = 0; 537 uint32_t oat_file_begin = ART_BASE_ADDRESS + (4 * KB); // page aligned 538 uint32_t oat_data_begin = ART_BASE_ADDRESS + (8 * KB); // page aligned 539 uint32_t oat_data_end = ART_BASE_ADDRESS + (9 * KB); 540 uint32_t oat_file_end = ART_BASE_ADDRESS + (10 * KB); 541 ImageSection sections[ImageHeader::kSectionCount]; 542 ImageHeader image_header(image_begin, 543 image_size_, 544 sections, 545 image_roots, 546 oat_checksum, 547 oat_file_begin, 548 oat_data_begin, 549 oat_data_end, 550 oat_file_end, 551 /*boot_image_begin*/0U, 552 /*boot_image_size*/0U, 553 /*boot_oat_begin*/0U, 554 /*boot_oat_size_*/0U, 555 sizeof(void*), 556 /*compile_pic*/false, 557 /*is_pic*/false, 558 ImageHeader::kDefaultStorageMode, 559 /*data_size*/0u); 560 ASSERT_TRUE(image_header.IsValid()); 561 ASSERT_TRUE(!image_header.IsAppImage()); 562 563 char* magic = const_cast<char*>(image_header.GetMagic()); 564 strcpy(magic, ""); // bad magic 565 ASSERT_FALSE(image_header.IsValid()); 566 strcpy(magic, "art\n000"); // bad version 567 ASSERT_FALSE(image_header.IsValid()); 568 } 569 570 // Test that pointer to quick code is the same in 571 // a default method of an interface and in a copied method 572 // of a class which implements the interface. This should be true 573 // only if the copied method and the origin method are located in the 574 // same oat file. 575 TEST_F(ImageTest, TestDefaultMethods) { 576 CompilationHelper helper; 577 Compile(ImageHeader::kStorageModeUncompressed, 578 helper, 579 "DefaultMethods", 580 {"LIface;", "LImpl;", "LIterableBase;"}); 581 582 PointerSize pointer_size = class_linker_->GetImagePointerSize(); 583 Thread* self = Thread::Current(); 584 ScopedObjectAccess soa(self); 585 586 // Test the pointer to quick code is the same in origin method 587 // and in the copied method form the same oat file. 588 mirror::Class* iface_klass = class_linker_->LookupClass( 589 self, "LIface;", ObjPtr<mirror::ClassLoader>()); 590 ASSERT_NE(nullptr, iface_klass); 591 ArtMethod* origin = iface_klass->FindDeclaredVirtualMethod( 592 "defaultMethod", "()V", pointer_size); 593 ASSERT_NE(nullptr, origin); 594 const void* code = origin->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size); 595 // The origin method should have a pointer to quick code 596 ASSERT_NE(nullptr, code); 597 ASSERT_FALSE(class_linker_->IsQuickToInterpreterBridge(code)); 598 mirror::Class* impl_klass = class_linker_->LookupClass( 599 self, "LImpl;", ObjPtr<mirror::ClassLoader>()); 600 ASSERT_NE(nullptr, impl_klass); 601 ArtMethod* copied = FindCopiedMethod(origin, impl_klass); 602 ASSERT_NE(nullptr, copied); 603 // the copied method should have pointer to the same quick code as the origin method 604 ASSERT_EQ(code, copied->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size)); 605 606 // Test the origin method has pointer to quick code 607 // but the copied method has pointer to interpreter 608 // because these methods are in different oat files. 609 mirror::Class* iterable_klass = class_linker_->LookupClass( 610 self, "Ljava/lang/Iterable;", ObjPtr<mirror::ClassLoader>()); 611 ASSERT_NE(nullptr, iterable_klass); 612 origin = iterable_klass->FindDeclaredVirtualMethod( 613 "forEach", "(Ljava/util/function/Consumer;)V", pointer_size); 614 ASSERT_NE(nullptr, origin); 615 code = origin->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size); 616 // the origin method should have a pointer to quick code 617 ASSERT_NE(nullptr, code); 618 ASSERT_FALSE(class_linker_->IsQuickToInterpreterBridge(code)); 619 mirror::Class* iterablebase_klass = class_linker_->LookupClass( 620 self, "LIterableBase;", ObjPtr<mirror::ClassLoader>()); 621 ASSERT_NE(nullptr, iterablebase_klass); 622 copied = FindCopiedMethod(origin, iterablebase_klass); 623 ASSERT_NE(nullptr, copied); 624 code = copied->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size); 625 // the copied method should have a pointer to interpreter 626 ASSERT_TRUE(class_linker_->IsQuickToInterpreterBridge(code)); 627 } 628 629 } // namespace art 630
