blob: 4920f9baa5affa71ce71acc1981db7a073f58bf8 [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"
Tong Shen62d1ca32014-09-03 17:24:56 -070027#include "elf_writer.h"
Vladimir Marko10c13562015-11-25 14:33:36 +000028#include "elf_writer_quick.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070029#include "gc/space/image_space.h"
Ian Rogerse63db272014-07-15 15:36:11 -070030#include "image_writer.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070031#include "lock_word.h"
32#include "mirror/object-inl.h"
Ian Rogerse63db272014-07-15 15:36:11 -070033#include "oat_writer.h"
34#include "scoped_thread_state_change.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070035#include "signal_catcher.h"
buzbeec143c552011-08-20 17:38:58 -070036#include "utils.h"
Brian Carlstromdb4d5402011-08-09 12:18:28 -070037
Brian Carlstromdb4d5402011-08-09 12:18:28 -070038namespace art {
39
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080040class ImageTest : public CommonCompilerTest {
Ian Rogers10c5b782013-01-10 10:40:53 -080041 protected:
42 virtual void SetUp() {
Brian Carlstrom700c8d32012-11-05 10:42:02 -080043 ReserveImageSpace();
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080044 CommonCompilerTest::SetUp();
Ian Rogers10c5b782013-01-10 10:40:53 -080045 }
Mathieu Chartierceb07b32015-12-10 09:33:21 -080046 void TestWriteRead(ImageHeader::StorageMode storage_mode);
Ian Rogers10c5b782013-01-10 10:40:53 -080047};
Brian Carlstromdb4d5402011-08-09 12:18:28 -070048
Mathieu Chartierceb07b32015-12-10 09:33:21 -080049void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) {
50 // TODO: Test does not currently work with optimizing.
51 CreateCompilerDriver(Compiler::kQuick, kRuntimeISA);
52 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
53 // Enable write for dex2dex.
54 for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
55 dex_file->EnableWrite();
56 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -070057 // Create a generic location tmp file, to be the base of the .art and .oat temporary files.
58 ScratchFile location;
59 ScratchFile image_location(location, ".art");
60
61 std::string image_filename(GetSystemImageFilename(image_location.GetFilename().c_str(),
62 kRuntimeISA));
63 size_t pos = image_filename.rfind('/');
64 CHECK_NE(pos, std::string::npos) << image_filename;
65 std::string image_dir(image_filename, 0, pos);
66 int mkdir_result = mkdir(image_dir.c_str(), 0700);
67 CHECK_EQ(0, mkdir_result) << image_dir;
68 ScratchFile image_file(OS::CreateEmptyFile(image_filename.c_str()));
69
70 std::string oat_filename(image_filename, 0, image_filename.size() - 3);
71 oat_filename += "oat";
72 ScratchFile oat_file(OS::CreateEmptyFile(oat_filename.c_str()));
73
Vladimir Markof4da6752014-08-01 19:04:18 +010074 const uintptr_t requested_image_base = ART_BASE_ADDRESS;
Jeff Haodcdc85b2015-12-04 14:06:18 -080075 std::unordered_map<const DexFile*, const char*> dex_file_to_oat_filename_map;
76 std::vector<const char*> oat_filename_vector(1, oat_filename.c_str());
77 for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
78 dex_file_to_oat_filename_map.emplace(dex_file, oat_filename.c_str());
79 }
Mathieu Chartierda5b28a2015-11-05 08:03:47 -080080 std::unique_ptr<ImageWriter> writer(new ImageWriter(*compiler_driver_,
81 requested_image_base,
82 /*compile_pic*/false,
Mathieu Chartierceb07b32015-12-10 09:33:21 -080083 /*compile_app_image*/false,
Jeff Haodcdc85b2015-12-04 14:06:18 -080084 storage_mode,
85 oat_filename_vector,
86 dex_file_to_oat_filename_map));
Igor Murashkin46774762014-10-22 11:37:02 -070087 // TODO: compile_pic should be a test argument.
Ian Rogers00f7d0e2012-07-19 15:28:27 -070088 {
Brian Carlstrom700c8d32012-11-05 10:42:02 -080089 {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070090 jobject class_loader = nullptr;
Ian Rogers5fe9af72013-11-14 00:17:20 -080091 TimingLogger timings("ImageTest::WriteRead", false, false);
Mathieu Chartierf5997b42014-06-20 10:37:54 -070092 TimingLogger::ScopedTiming t("CompileAll", &timings);
Vladimir Markod1eaf0d2015-10-29 12:18:29 +000093 compiler_driver_->SetDexFilesForOatFile(class_linker->GetBootClassPath());
Ian Rogers3d504072014-03-01 09:16:49 -080094 compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
Brian Carlstrom96391602013-06-13 19:49:50 -070095
Mathieu Chartierf5997b42014-06-20 10:37:54 -070096 t.NewTiming("WriteElf");
Andreas Gampe22f8e5c2014-07-09 11:38:21 -070097 SafeMap<std::string, std::string> key_value_store;
Vladimir Marko9bdf1082016-01-21 12:15:52 +000098 const std::vector<const DexFile*>& dex_files = class_linker->GetBootClassPath();
Vladimir Marko10c13562015-11-25 14:33:36 +000099 std::unique_ptr<ElfWriter> elf_writer = CreateElfWriterQuick(
100 compiler_driver_->GetInstructionSet(),
101 &compiler_driver_->GetCompilerOptions(),
102 oat_file.GetFile());
Vladimir Marko919f5532016-01-20 19:13:01 +0000103 elf_writer->Start();
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000104 OatWriter oat_writer(/*compiling_boot_image*/true, &timings);
Vladimir Marko919f5532016-01-20 19:13:01 +0000105 OutputStream* rodata = elf_writer->StartRoData();
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000106 for (const DexFile* dex_file : dex_files) {
107 ArrayRef<const uint8_t> raw_dex_file(
108 reinterpret_cast<const uint8_t*>(&dex_file->GetHeader()),
109 dex_file->GetHeader().file_size_);
110 oat_writer.AddRawDexFileSource(raw_dex_file,
111 dex_file->GetLocation().c_str(),
112 dex_file->GetLocationChecksum());
113 }
114 std::unique_ptr<MemMap> opened_dex_files_map;
115 std::vector<std::unique_ptr<const DexFile>> opened_dex_files;
116 bool dex_files_ok = oat_writer.WriteAndOpenDexFiles(
117 rodata,
118 oat_file.GetFile(),
119 compiler_driver_->GetInstructionSet(),
120 compiler_driver_->GetInstructionSetFeatures(),
121 &key_value_store,
Andreas Gampe3a2bd292016-01-26 17:23:47 -0800122 /* verify */ false, // Dex files may be dex-to-dex-ed, don't verify.
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000123 &opened_dex_files_map,
124 &opened_dex_files);
125 ASSERT_TRUE(dex_files_ok);
126 oat_writer.PrepareLayout(compiler_driver_.get(), writer.get(), dex_files);
127 bool image_space_ok = writer->PrepareImageAddressSpace();
128 ASSERT_TRUE(image_space_ok);
129
Vladimir Marko10c13562015-11-25 14:33:36 +0000130 bool rodata_ok = oat_writer.WriteRodata(rodata);
131 ASSERT_TRUE(rodata_ok);
132 elf_writer->EndRoData(rodata);
133
134 OutputStream* text = elf_writer->StartText();
135 bool text_ok = oat_writer.WriteCode(text);
136 ASSERT_TRUE(text_ok);
137 elf_writer->EndText(text);
138
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000139 bool header_ok = oat_writer.WriteHeader(elf_writer->GetStream(), 0u, 0u, 0u);
140 ASSERT_TRUE(header_ok);
141
Vladimir Marko10c13562015-11-25 14:33:36 +0000142 elf_writer->SetBssSize(oat_writer.GetBssSize());
Vladimir Marko10c13562015-11-25 14:33:36 +0000143 elf_writer->WriteDynamicSection();
Vladimir Marko49b0f452015-12-10 13:49:19 +0000144 elf_writer->WriteDebugInfo(oat_writer.GetMethodDebugInfo());
145 elf_writer->WritePatchLocations(oat_writer.GetAbsolutePatchLocations());
Vladimir Marko10c13562015-11-25 14:33:36 +0000146
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000147 bool success = elf_writer->End();
Vladimir Marko10c13562015-11-25 14:33:36 +0000148
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700149 ASSERT_TRUE(success);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700150 }
Ian Rogers0571d352011-11-03 19:51:38 -0700151 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700152 // Workound bug that mcld::Linker::emit closes oat_file by reopening as dup_oat.
Ian Rogers700a4022014-05-19 16:49:03 -0700153 std::unique_ptr<File> dup_oat(OS::OpenFileReadWrite(oat_file.GetFilename().c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700154 ASSERT_TRUE(dup_oat.get() != nullptr);
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700155
jeffhao8161c032012-10-31 15:50:00 -0700156 {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800157 std::vector<const char*> dup_oat_filename(1, dup_oat->GetPath().c_str());
158 std::vector<const char*> dup_image_filename(1, image_file.GetFilename().c_str());
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800159 bool success_image = writer->Write(kInvalidFd,
160 dup_image_filename,
161 kInvalidFd,
162 dup_oat_filename,
163 dup_oat_filename[0]);
jeffhao8161c032012-10-31 15:50:00 -0700164 ASSERT_TRUE(success_image);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800165 bool success_fixup = ElfWriter::Fixup(dup_oat.get(),
166 writer->GetOatDataBegin(dup_oat_filename[0]));
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800167 ASSERT_TRUE(success_fixup);
Andreas Gampe4303ba92014-11-06 01:00:46 -0800168
169 ASSERT_EQ(dup_oat->FlushCloseOrErase(), 0) << "Could not flush and close oat file "
170 << oat_file.GetFilename();
jeffhao8161c032012-10-31 15:50:00 -0700171 }
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700172
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700173 uint64_t image_file_size;
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700174 {
Ian Rogers700a4022014-05-19 16:49:03 -0700175 std::unique_ptr<File> file(OS::OpenFileForReading(image_file.GetFilename().c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700176 ASSERT_TRUE(file.get() != nullptr);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700177 ImageHeader image_header;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800178 ASSERT_EQ(file->ReadFully(&image_header, sizeof(image_header)), true);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700179 ASSERT_TRUE(image_header.IsValid());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700180 const auto& bitmap_section = image_header.GetImageSection(ImageHeader::kSectionImageBitmap);
181 ASSERT_GE(bitmap_section.Offset(), sizeof(image_header));
182 ASSERT_NE(0U, bitmap_section.Size());
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700183
Ian Rogers1d54e732013-05-02 21:10:01 -0700184 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartiera9d82fe2016-01-25 20:06:11 -0800185 ASSERT_TRUE(heap->HaveContinuousSpaces());
Mathieu Chartier590fee92013-09-13 13:46:47 -0700186 gc::space::ContinuousSpace* space = heap->GetNonMovingSpace();
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700187 ASSERT_FALSE(space->IsImageSpace());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700188 ASSERT_TRUE(space != nullptr);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700189 ASSERT_TRUE(space->IsMallocSpace());
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700190
191 image_file_size = file->GetLength();
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700192 }
Brian Carlstrom8a436592011-08-15 21:27:23 -0700193
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700194 ASSERT_TRUE(compiler_driver_->GetImageClasses() != nullptr);
Andreas Gampeb1fcead2015-04-20 18:53:51 -0700195 std::unordered_set<std::string> image_classes(*compiler_driver_->GetImageClasses());
Brian Carlstrom96391602013-06-13 19:49:50 -0700196
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700197 // Need to delete the compiler since it has worker threads which are attached to runtime.
Ian Rogers1212a022013-03-04 10:48:41 -0800198 compiler_driver_.reset();
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700199
Ian Rogers10c5b782013-01-10 10:40:53 -0800200 // Tear down old runtime before making a new one, clearing out misc state.
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700201
202 // Remove the reservation of the memory for use to load the image.
203 // Need to do this before we reset the runtime.
204 UnreserveImageSpace();
205 writer.reset(nullptr);
206
Ian Rogers10c5b782013-01-10 10:40:53 -0800207 runtime_.reset();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700208 java_lang_dex_file_ = nullptr;
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700209
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700210 MemMap::Init();
Przemyslaw Szczepaniak5c0cf122015-09-30 17:41:38 +0100211 std::unique_ptr<const DexFile> dex(LoadExpectSingleDexFile(GetLibCoreDexFileNames()[0].c_str()));
Brian Carlstrom8a436592011-08-15 21:27:23 -0700212
Ian Rogerse63db272014-07-15 15:36:11 -0700213 RuntimeOptions options;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700214 std::string image("-Ximage:");
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700215 image.append(image_location.GetFilename());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700216 options.push_back(std::make_pair(image.c_str(), static_cast<void*>(nullptr)));
Alex Light6e183f22014-07-18 14:57:04 -0700217 // By default the compiler this creates will not include patch information.
218 options.push_back(std::make_pair("-Xnorelocate", nullptr));
Brian Carlstrom8a436592011-08-15 21:27:23 -0700219
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700220 if (!Runtime::Create(options, false)) {
221 LOG(FATAL) << "Failed to create runtime";
222 return;
223 }
224 runtime_.reset(Runtime::Current());
225 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
226 // give it away now and then switch to a more managable ScopedObjectAccess.
227 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
228 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700229 ASSERT_TRUE(runtime_.get() != nullptr);
Brian Carlstrom8a436592011-08-15 21:27:23 -0700230 class_linker_ = runtime_->GetClassLinker();
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700231
Ian Rogers1d54e732013-05-02 21:10:01 -0700232 gc::Heap* heap = Runtime::Current()->GetHeap();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800233 ASSERT_TRUE(heap->HasBootImageSpace());
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700234 ASSERT_TRUE(heap->GetNonMovingSpace()->IsMallocSpace());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700235
Jeff Haodcdc85b2015-12-04 14:06:18 -0800236 // We loaded the runtime with an explicit image, so it must exist.
237 gc::space::ImageSpace* image_space = heap->GetBootImageSpaces()[0];
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700238 ASSERT_TRUE(image_space != nullptr);
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800239 if (storage_mode == ImageHeader::kStorageModeUncompressed) {
240 // Uncompressed, image should be smaller than file.
241 ASSERT_LE(image_space->Size(), image_file_size);
242 } else {
243 // Compressed, file should be smaller than image.
244 ASSERT_LE(image_file_size, image_space->Size());
245 }
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700246
Mathieu Chartier31e89252013-08-28 11:29:12 -0700247 image_space->VerifyImageAllocations();
Ian Rogers13735952014-10-08 12:43:28 -0700248 uint8_t* image_begin = image_space->Begin();
249 uint8_t* image_end = image_space->End();
Ian Rogers30fab402012-01-23 15:43:46 -0800250 CHECK_EQ(requested_image_base, reinterpret_cast<uintptr_t>(image_begin));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800251 for (size_t i = 0; i < dex->NumClassDefs(); ++i) {
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700252 const DexFile::ClassDef& class_def = dex->GetClassDef(i);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700253 const char* descriptor = dex->GetClassDescriptor(class_def);
Ian Rogers98379392014-02-24 16:53:16 -0800254 mirror::Class* klass = class_linker_->FindSystemClass(soa.Self(), descriptor);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800255 EXPECT_TRUE(klass != nullptr) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700256 if (image_classes.find(descriptor) != image_classes.end()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800257 // Image classes should be located inside the image.
Ian Rogers13735952014-10-08 12:43:28 -0700258 EXPECT_LT(image_begin, reinterpret_cast<uint8_t*>(klass)) << descriptor;
259 EXPECT_LT(reinterpret_cast<uint8_t*>(klass), image_end) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700260 } else {
Ian Rogers13735952014-10-08 12:43:28 -0700261 EXPECT_TRUE(reinterpret_cast<uint8_t*>(klass) >= image_end ||
262 reinterpret_cast<uint8_t*>(klass) < image_begin) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700263 }
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700264 EXPECT_TRUE(Monitor::IsValidLockWord(klass->GetLockWord(false)));
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700265 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700266
267 image_file.Unlink();
268 oat_file.Unlink();
269 int rmdir_result = rmdir(image_dir.c_str());
270 CHECK_EQ(0, rmdir_result);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700271}
272
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800273TEST_F(ImageTest, WriteReadUncompressed) {
274 TestWriteRead(ImageHeader::kStorageModeUncompressed);
275}
276
277TEST_F(ImageTest, WriteReadLZ4) {
278 TestWriteRead(ImageHeader::kStorageModeLZ4);
279}
280
Brian Carlstrom179486a2013-09-03 11:51:42 -0700281TEST_F(ImageTest, ImageHeaderIsValid) {
282 uint32_t image_begin = ART_BASE_ADDRESS;
283 uint32_t image_size_ = 16 * KB;
Brian Carlstrom179486a2013-09-03 11:51:42 -0700284 uint32_t image_roots = ART_BASE_ADDRESS + (1 * KB);
285 uint32_t oat_checksum = 0;
286 uint32_t oat_file_begin = ART_BASE_ADDRESS + (4 * KB); // page aligned
287 uint32_t oat_data_begin = ART_BASE_ADDRESS + (8 * KB); // page aligned
288 uint32_t oat_data_end = ART_BASE_ADDRESS + (9 * KB);
289 uint32_t oat_file_end = ART_BASE_ADDRESS + (10 * KB);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700290 ImageSection sections[ImageHeader::kSectionCount];
Brian Carlstrom179486a2013-09-03 11:51:42 -0700291 ImageHeader image_header(image_begin,
292 image_size_,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700293 sections,
Brian Carlstrom179486a2013-09-03 11:51:42 -0700294 image_roots,
295 oat_checksum,
296 oat_file_begin,
297 oat_data_begin,
298 oat_data_end,
Igor Murashkin46774762014-10-22 11:37:02 -0700299 oat_file_end,
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800300 /*boot_image_begin*/0U,
301 /*boot_image_size*/0U,
302 /*boot_oat_begin*/0U,
303 /*boot_oat_size_*/0U,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700304 sizeof(void*),
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800305 /*compile_pic*/false,
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800306 /*is_pic*/false,
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800307 ImageHeader::kDefaultStorageMode,
308 /*data_size*/0u);
Brian Carlstrom179486a2013-09-03 11:51:42 -0700309 ASSERT_TRUE(image_header.IsValid());
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800310 ASSERT_TRUE(!image_header.IsAppImage());
Brian Carlstrom179486a2013-09-03 11:51:42 -0700311
312 char* magic = const_cast<char*>(image_header.GetMagic());
313 strcpy(magic, ""); // bad magic
314 ASSERT_FALSE(image_header.IsValid());
315 strcpy(magic, "art\n000"); // bad version
316 ASSERT_FALSE(image_header.IsValid());
317}
318
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700319} // namespace art