blob: 91579e9daf0e60432f2a61829296bc918942332a [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Brian Carlstromdb4d5402011-08-09 12:18:28 -070016
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080017#include "image.h"
18
Ian Rogers700a4022014-05-19 16:49:03 -070019#include <memory>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070020#include <string>
21#include <vector>
22
Ian Rogerse63db272014-07-15 15:36:11 -070023#include "base/unix_file/fd_file.h"
Vladimir Marko3481ba22015-04-13 12:22:36 +010024#include "class_linker-inl.h"
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080025#include "common_compiler_test.h"
David Srbecky4fda4eb2016-02-05 13:34:46 +000026#include "debug/method_debug_info.h"
Andreas Gampe3f41a012016-02-18 16:53:41 -080027#include "driver/compiler_options.h"
Tong Shen62d1ca32014-09-03 17:24:56 -070028#include "elf_writer.h"
Vladimir Marko10c13562015-11-25 14:33:36 +000029#include "elf_writer_quick.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070030#include "gc/space/image_space.h"
Ian Rogerse63db272014-07-15 15:36:11 -070031#include "image_writer.h"
Vladimir Marko944da602016-02-19 12:27:55 +000032#include "linker/multi_oat_relative_patcher.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070033#include "lock_word.h"
34#include "mirror/object-inl.h"
Ian Rogerse63db272014-07-15 15:36:11 -070035#include "oat_writer.h"
36#include "scoped_thread_state_change.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070037#include "signal_catcher.h"
buzbeec143c552011-08-20 17:38:58 -070038#include "utils.h"
Brian Carlstromdb4d5402011-08-09 12:18:28 -070039
Brian Carlstromdb4d5402011-08-09 12:18:28 -070040namespace art {
41
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080042class ImageTest : public CommonCompilerTest {
Ian Rogers10c5b782013-01-10 10:40:53 -080043 protected:
44 virtual void SetUp() {
Brian Carlstrom700c8d32012-11-05 10:42:02 -080045 ReserveImageSpace();
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080046 CommonCompilerTest::SetUp();
Ian Rogers10c5b782013-01-10 10:40:53 -080047 }
Mathieu Chartierceb07b32015-12-10 09:33:21 -080048 void TestWriteRead(ImageHeader::StorageMode storage_mode);
Ian Rogers10c5b782013-01-10 10:40:53 -080049};
Brian Carlstromdb4d5402011-08-09 12:18:28 -070050
Mathieu Chartierceb07b32015-12-10 09:33:21 -080051void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) {
Andreas Gampe3f41a012016-02-18 16:53:41 -080052 CreateCompilerDriver(Compiler::kOptimizing, kRuntimeISA, kIsTargetBuild ? 2U : 16U);
53
54 // Set inline filter values.
55 compiler_options_->SetInlineDepthLimit(CompilerOptions::kDefaultInlineDepthLimit);
56 compiler_options_->SetInlineMaxCodeUnits(CompilerOptions::kDefaultInlineMaxCodeUnits);
57
Mathieu Chartierceb07b32015-12-10 09:33:21 -080058 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
59 // Enable write for dex2dex.
60 for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
61 dex_file->EnableWrite();
62 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -070063 // Create a generic location tmp file, to be the base of the .art and .oat temporary files.
64 ScratchFile location;
65 ScratchFile image_location(location, ".art");
66
67 std::string image_filename(GetSystemImageFilename(image_location.GetFilename().c_str(),
68 kRuntimeISA));
69 size_t pos = image_filename.rfind('/');
70 CHECK_NE(pos, std::string::npos) << image_filename;
71 std::string image_dir(image_filename, 0, pos);
72 int mkdir_result = mkdir(image_dir.c_str(), 0700);
73 CHECK_EQ(0, mkdir_result) << image_dir;
74 ScratchFile image_file(OS::CreateEmptyFile(image_filename.c_str()));
75
76 std::string oat_filename(image_filename, 0, image_filename.size() - 3);
77 oat_filename += "oat";
78 ScratchFile oat_file(OS::CreateEmptyFile(oat_filename.c_str()));
79
Vladimir Markof4da6752014-08-01 19:04:18 +010080 const uintptr_t requested_image_base = ART_BASE_ADDRESS;
Vladimir Marko944da602016-02-19 12:27:55 +000081 std::unordered_map<const DexFile*, size_t> dex_file_to_oat_index_map;
Jeff Haodcdc85b2015-12-04 14:06:18 -080082 std::vector<const char*> oat_filename_vector(1, oat_filename.c_str());
83 for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
Vladimir Marko944da602016-02-19 12:27:55 +000084 dex_file_to_oat_index_map.emplace(dex_file, 0);
Jeff Haodcdc85b2015-12-04 14:06:18 -080085 }
Mathieu Chartierda5b28a2015-11-05 08:03:47 -080086 std::unique_ptr<ImageWriter> writer(new ImageWriter(*compiler_driver_,
87 requested_image_base,
88 /*compile_pic*/false,
Mathieu Chartierceb07b32015-12-10 09:33:21 -080089 /*compile_app_image*/false,
Jeff Haodcdc85b2015-12-04 14:06:18 -080090 storage_mode,
91 oat_filename_vector,
Vladimir Marko944da602016-02-19 12:27:55 +000092 dex_file_to_oat_index_map));
Igor Murashkin46774762014-10-22 11:37:02 -070093 // TODO: compile_pic should be a test argument.
Ian Rogers00f7d0e2012-07-19 15:28:27 -070094 {
Brian Carlstrom700c8d32012-11-05 10:42:02 -080095 {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070096 jobject class_loader = nullptr;
Ian Rogers5fe9af72013-11-14 00:17:20 -080097 TimingLogger timings("ImageTest::WriteRead", false, false);
Mathieu Chartierf5997b42014-06-20 10:37:54 -070098 TimingLogger::ScopedTiming t("CompileAll", &timings);
Vladimir Markod1eaf0d2015-10-29 12:18:29 +000099 compiler_driver_->SetDexFilesForOatFile(class_linker->GetBootClassPath());
Ian Rogers3d504072014-03-01 09:16:49 -0800100 compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
Brian Carlstrom96391602013-06-13 19:49:50 -0700101
Mathieu Chartierf5997b42014-06-20 10:37:54 -0700102 t.NewTiming("WriteElf");
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700103 SafeMap<std::string, std::string> key_value_store;
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000104 const std::vector<const DexFile*>& dex_files = class_linker->GetBootClassPath();
Vladimir Marko10c13562015-11-25 14:33:36 +0000105 std::unique_ptr<ElfWriter> elf_writer = CreateElfWriterQuick(
106 compiler_driver_->GetInstructionSet(),
David Srbecky5d811202016-03-08 13:21:22 +0000107 compiler_driver_->GetInstructionSetFeatures(),
Vladimir Marko10c13562015-11-25 14:33:36 +0000108 &compiler_driver_->GetCompilerOptions(),
109 oat_file.GetFile());
Vladimir Marko919f5532016-01-20 19:13:01 +0000110 elf_writer->Start();
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000111 OatWriter oat_writer(/*compiling_boot_image*/true, &timings);
Vladimir Marko919f5532016-01-20 19:13:01 +0000112 OutputStream* rodata = elf_writer->StartRoData();
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000113 for (const DexFile* dex_file : dex_files) {
114 ArrayRef<const uint8_t> raw_dex_file(
115 reinterpret_cast<const uint8_t*>(&dex_file->GetHeader()),
116 dex_file->GetHeader().file_size_);
117 oat_writer.AddRawDexFileSource(raw_dex_file,
118 dex_file->GetLocation().c_str(),
119 dex_file->GetLocationChecksum());
120 }
121 std::unique_ptr<MemMap> opened_dex_files_map;
122 std::vector<std::unique_ptr<const DexFile>> opened_dex_files;
123 bool dex_files_ok = oat_writer.WriteAndOpenDexFiles(
124 rodata,
125 oat_file.GetFile(),
126 compiler_driver_->GetInstructionSet(),
127 compiler_driver_->GetInstructionSetFeatures(),
128 &key_value_store,
Andreas Gampe3a2bd292016-01-26 17:23:47 -0800129 /* verify */ false, // Dex files may be dex-to-dex-ed, don't verify.
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000130 &opened_dex_files_map,
131 &opened_dex_files);
132 ASSERT_TRUE(dex_files_ok);
Vladimir Marko944da602016-02-19 12:27:55 +0000133
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000134 bool image_space_ok = writer->PrepareImageAddressSpace();
135 ASSERT_TRUE(image_space_ok);
136
Vladimir Marko944da602016-02-19 12:27:55 +0000137 linker::MultiOatRelativePatcher patcher(compiler_driver_->GetInstructionSet(),
138 instruction_set_features_.get());
139 oat_writer.PrepareLayout(compiler_driver_.get(), writer.get(), dex_files, &patcher);
140 size_t rodata_size = oat_writer.GetOatHeader().GetExecutableOffset();
141 size_t text_size = oat_writer.GetSize() - rodata_size;
142 elf_writer->SetLoadedSectionSizes(rodata_size, text_size, oat_writer.GetBssSize());
143
144 writer->UpdateOatFileLayout(/* oat_index */ 0u,
145 elf_writer->GetLoadedSize(),
146 oat_writer.GetOatDataOffset(),
147 oat_writer.GetSize());
148
Vladimir Marko10c13562015-11-25 14:33:36 +0000149 bool rodata_ok = oat_writer.WriteRodata(rodata);
150 ASSERT_TRUE(rodata_ok);
151 elf_writer->EndRoData(rodata);
152
153 OutputStream* text = elf_writer->StartText();
154 bool text_ok = oat_writer.WriteCode(text);
155 ASSERT_TRUE(text_ok);
156 elf_writer->EndText(text);
157
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000158 bool header_ok = oat_writer.WriteHeader(elf_writer->GetStream(), 0u, 0u, 0u);
159 ASSERT_TRUE(header_ok);
160
Vladimir Marko944da602016-02-19 12:27:55 +0000161 writer->UpdateOatFileHeader(/* oat_index */ 0u, oat_writer.GetOatHeader());
162
Vladimir Marko10c13562015-11-25 14:33:36 +0000163 elf_writer->WriteDynamicSection();
Vladimir Marko49b0f452015-12-10 13:49:19 +0000164 elf_writer->WriteDebugInfo(oat_writer.GetMethodDebugInfo());
165 elf_writer->WritePatchLocations(oat_writer.GetAbsolutePatchLocations());
Vladimir Marko10c13562015-11-25 14:33:36 +0000166
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000167 bool success = elf_writer->End();
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700168 ASSERT_TRUE(success);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700169 }
Ian Rogers0571d352011-11-03 19:51:38 -0700170 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700171 // Workound bug that mcld::Linker::emit closes oat_file by reopening as dup_oat.
Ian Rogers700a4022014-05-19 16:49:03 -0700172 std::unique_ptr<File> dup_oat(OS::OpenFileReadWrite(oat_file.GetFilename().c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700173 ASSERT_TRUE(dup_oat.get() != nullptr);
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700174
jeffhao8161c032012-10-31 15:50:00 -0700175 {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800176 std::vector<const char*> dup_oat_filename(1, dup_oat->GetPath().c_str());
177 std::vector<const char*> dup_image_filename(1, image_file.GetFilename().c_str());
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800178 bool success_image = writer->Write(kInvalidFd,
179 dup_image_filename,
Vladimir Marko944da602016-02-19 12:27:55 +0000180 dup_oat_filename);
jeffhao8161c032012-10-31 15:50:00 -0700181 ASSERT_TRUE(success_image);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800182 bool success_fixup = ElfWriter::Fixup(dup_oat.get(),
Vladimir Marko944da602016-02-19 12:27:55 +0000183 writer->GetOatDataBegin(0));
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800184 ASSERT_TRUE(success_fixup);
Andreas Gampe4303ba92014-11-06 01:00:46 -0800185
186 ASSERT_EQ(dup_oat->FlushCloseOrErase(), 0) << "Could not flush and close oat file "
187 << oat_file.GetFilename();
jeffhao8161c032012-10-31 15:50:00 -0700188 }
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700189
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700190 uint64_t image_file_size;
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700191 {
Ian Rogers700a4022014-05-19 16:49:03 -0700192 std::unique_ptr<File> file(OS::OpenFileForReading(image_file.GetFilename().c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700193 ASSERT_TRUE(file.get() != nullptr);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700194 ImageHeader image_header;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800195 ASSERT_EQ(file->ReadFully(&image_header, sizeof(image_header)), true);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700196 ASSERT_TRUE(image_header.IsValid());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700197 const auto& bitmap_section = image_header.GetImageSection(ImageHeader::kSectionImageBitmap);
198 ASSERT_GE(bitmap_section.Offset(), sizeof(image_header));
199 ASSERT_NE(0U, bitmap_section.Size());
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700200
Ian Rogers1d54e732013-05-02 21:10:01 -0700201 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartiera9d82fe2016-01-25 20:06:11 -0800202 ASSERT_TRUE(heap->HaveContinuousSpaces());
Mathieu Chartier590fee92013-09-13 13:46:47 -0700203 gc::space::ContinuousSpace* space = heap->GetNonMovingSpace();
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700204 ASSERT_FALSE(space->IsImageSpace());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700205 ASSERT_TRUE(space != nullptr);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700206 ASSERT_TRUE(space->IsMallocSpace());
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700207
208 image_file_size = file->GetLength();
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700209 }
Brian Carlstrom8a436592011-08-15 21:27:23 -0700210
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700211 ASSERT_TRUE(compiler_driver_->GetImageClasses() != nullptr);
Andreas Gampeb1fcead2015-04-20 18:53:51 -0700212 std::unordered_set<std::string> image_classes(*compiler_driver_->GetImageClasses());
Brian Carlstrom96391602013-06-13 19:49:50 -0700213
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700214 // Need to delete the compiler since it has worker threads which are attached to runtime.
Ian Rogers1212a022013-03-04 10:48:41 -0800215 compiler_driver_.reset();
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700216
Ian Rogers10c5b782013-01-10 10:40:53 -0800217 // Tear down old runtime before making a new one, clearing out misc state.
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700218
219 // Remove the reservation of the memory for use to load the image.
220 // Need to do this before we reset the runtime.
221 UnreserveImageSpace();
222 writer.reset(nullptr);
223
Ian Rogers10c5b782013-01-10 10:40:53 -0800224 runtime_.reset();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700225 java_lang_dex_file_ = nullptr;
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700226
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700227 MemMap::Init();
Przemyslaw Szczepaniak5c0cf122015-09-30 17:41:38 +0100228 std::unique_ptr<const DexFile> dex(LoadExpectSingleDexFile(GetLibCoreDexFileNames()[0].c_str()));
Brian Carlstrom8a436592011-08-15 21:27:23 -0700229
Ian Rogerse63db272014-07-15 15:36:11 -0700230 RuntimeOptions options;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700231 std::string image("-Ximage:");
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700232 image.append(image_location.GetFilename());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700233 options.push_back(std::make_pair(image.c_str(), static_cast<void*>(nullptr)));
Alex Light6e183f22014-07-18 14:57:04 -0700234 // By default the compiler this creates will not include patch information.
235 options.push_back(std::make_pair("-Xnorelocate", nullptr));
Brian Carlstrom8a436592011-08-15 21:27:23 -0700236
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700237 if (!Runtime::Create(options, false)) {
238 LOG(FATAL) << "Failed to create runtime";
239 return;
240 }
241 runtime_.reset(Runtime::Current());
242 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
243 // give it away now and then switch to a more managable ScopedObjectAccess.
244 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
245 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700246 ASSERT_TRUE(runtime_.get() != nullptr);
Brian Carlstrom8a436592011-08-15 21:27:23 -0700247 class_linker_ = runtime_->GetClassLinker();
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700248
Ian Rogers1d54e732013-05-02 21:10:01 -0700249 gc::Heap* heap = Runtime::Current()->GetHeap();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800250 ASSERT_TRUE(heap->HasBootImageSpace());
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700251 ASSERT_TRUE(heap->GetNonMovingSpace()->IsMallocSpace());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700252
Jeff Haodcdc85b2015-12-04 14:06:18 -0800253 // We loaded the runtime with an explicit image, so it must exist.
254 gc::space::ImageSpace* image_space = heap->GetBootImageSpaces()[0];
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700255 ASSERT_TRUE(image_space != nullptr);
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800256 if (storage_mode == ImageHeader::kStorageModeUncompressed) {
257 // Uncompressed, image should be smaller than file.
258 ASSERT_LE(image_space->Size(), image_file_size);
259 } else {
260 // Compressed, file should be smaller than image.
261 ASSERT_LE(image_file_size, image_space->Size());
262 }
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700263
Mathieu Chartier31e89252013-08-28 11:29:12 -0700264 image_space->VerifyImageAllocations();
Ian Rogers13735952014-10-08 12:43:28 -0700265 uint8_t* image_begin = image_space->Begin();
266 uint8_t* image_end = image_space->End();
Ian Rogers30fab402012-01-23 15:43:46 -0800267 CHECK_EQ(requested_image_base, reinterpret_cast<uintptr_t>(image_begin));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800268 for (size_t i = 0; i < dex->NumClassDefs(); ++i) {
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700269 const DexFile::ClassDef& class_def = dex->GetClassDef(i);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700270 const char* descriptor = dex->GetClassDescriptor(class_def);
Ian Rogers98379392014-02-24 16:53:16 -0800271 mirror::Class* klass = class_linker_->FindSystemClass(soa.Self(), descriptor);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800272 EXPECT_TRUE(klass != nullptr) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700273 if (image_classes.find(descriptor) != image_classes.end()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800274 // Image classes should be located inside the image.
Ian Rogers13735952014-10-08 12:43:28 -0700275 EXPECT_LT(image_begin, reinterpret_cast<uint8_t*>(klass)) << descriptor;
276 EXPECT_LT(reinterpret_cast<uint8_t*>(klass), image_end) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700277 } else {
Ian Rogers13735952014-10-08 12:43:28 -0700278 EXPECT_TRUE(reinterpret_cast<uint8_t*>(klass) >= image_end ||
279 reinterpret_cast<uint8_t*>(klass) < image_begin) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700280 }
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700281 EXPECT_TRUE(Monitor::IsValidLockWord(klass->GetLockWord(false)));
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700282 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700283
284 image_file.Unlink();
285 oat_file.Unlink();
286 int rmdir_result = rmdir(image_dir.c_str());
287 CHECK_EQ(0, rmdir_result);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700288}
289
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800290TEST_F(ImageTest, WriteReadUncompressed) {
291 TestWriteRead(ImageHeader::kStorageModeUncompressed);
292}
293
294TEST_F(ImageTest, WriteReadLZ4) {
295 TestWriteRead(ImageHeader::kStorageModeLZ4);
296}
297
Mathieu Chartiera6e81ed2016-02-25 13:52:10 -0800298TEST_F(ImageTest, WriteReadLZ4HC) {
299 TestWriteRead(ImageHeader::kStorageModeLZ4HC);
300}
301
302
Brian Carlstrom179486a2013-09-03 11:51:42 -0700303TEST_F(ImageTest, ImageHeaderIsValid) {
304 uint32_t image_begin = ART_BASE_ADDRESS;
305 uint32_t image_size_ = 16 * KB;
Brian Carlstrom179486a2013-09-03 11:51:42 -0700306 uint32_t image_roots = ART_BASE_ADDRESS + (1 * KB);
307 uint32_t oat_checksum = 0;
308 uint32_t oat_file_begin = ART_BASE_ADDRESS + (4 * KB); // page aligned
309 uint32_t oat_data_begin = ART_BASE_ADDRESS + (8 * KB); // page aligned
310 uint32_t oat_data_end = ART_BASE_ADDRESS + (9 * KB);
311 uint32_t oat_file_end = ART_BASE_ADDRESS + (10 * KB);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700312 ImageSection sections[ImageHeader::kSectionCount];
Brian Carlstrom179486a2013-09-03 11:51:42 -0700313 ImageHeader image_header(image_begin,
314 image_size_,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700315 sections,
Brian Carlstrom179486a2013-09-03 11:51:42 -0700316 image_roots,
317 oat_checksum,
318 oat_file_begin,
319 oat_data_begin,
320 oat_data_end,
Igor Murashkin46774762014-10-22 11:37:02 -0700321 oat_file_end,
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800322 /*boot_image_begin*/0U,
323 /*boot_image_size*/0U,
324 /*boot_oat_begin*/0U,
325 /*boot_oat_size_*/0U,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700326 sizeof(void*),
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800327 /*compile_pic*/false,
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800328 /*is_pic*/false,
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800329 ImageHeader::kDefaultStorageMode,
330 /*data_size*/0u);
Brian Carlstrom179486a2013-09-03 11:51:42 -0700331 ASSERT_TRUE(image_header.IsValid());
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800332 ASSERT_TRUE(!image_header.IsAppImage());
Brian Carlstrom179486a2013-09-03 11:51:42 -0700333
334 char* magic = const_cast<char*>(image_header.GetMagic());
335 strcpy(magic, ""); // bad magic
336 ASSERT_FALSE(image_header.IsValid());
337 strcpy(magic, "art\n000"); // bad version
338 ASSERT_FALSE(image_header.IsValid());
339}
340
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700341} // namespace art