blob: 772cc801463930ecb4673d99710abe7a9de7f4c0 [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"
Tong Shen62d1ca32014-09-03 17:24:56 -070026#include "elf_writer.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070027#include "gc/space/image_space.h"
Ian Rogerse63db272014-07-15 15:36:11 -070028#include "image_writer.h"
Ian Rogersd9c4fc92013-10-01 19:45:43 -070029#include "lock_word.h"
30#include "mirror/object-inl.h"
Ian Rogerse63db272014-07-15 15:36:11 -070031#include "oat_writer.h"
32#include "scoped_thread_state_change.h"
Brian Carlstrom51c24672013-07-11 16:00:56 -070033#include "signal_catcher.h"
buzbeec143c552011-08-20 17:38:58 -070034#include "utils.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080035#include "vector_output_stream.h"
Brian Carlstromdb4d5402011-08-09 12:18:28 -070036
Brian Carlstromdb4d5402011-08-09 12:18:28 -070037namespace art {
38
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080039class ImageTest : public CommonCompilerTest {
Ian Rogers10c5b782013-01-10 10:40:53 -080040 protected:
41 virtual void SetUp() {
Brian Carlstrom700c8d32012-11-05 10:42:02 -080042 ReserveImageSpace();
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080043 CommonCompilerTest::SetUp();
Ian Rogers10c5b782013-01-10 10:40:53 -080044 }
Ian Rogers10c5b782013-01-10 10:40:53 -080045};
Brian Carlstromdb4d5402011-08-09 12:18:28 -070046
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070047TEST_F(ImageTest, WriteRead) {
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -070048 // Create a generic location tmp file, to be the base of the .art and .oat temporary files.
49 ScratchFile location;
50 ScratchFile image_location(location, ".art");
51
52 std::string image_filename(GetSystemImageFilename(image_location.GetFilename().c_str(),
53 kRuntimeISA));
54 size_t pos = image_filename.rfind('/');
55 CHECK_NE(pos, std::string::npos) << image_filename;
56 std::string image_dir(image_filename, 0, pos);
57 int mkdir_result = mkdir(image_dir.c_str(), 0700);
58 CHECK_EQ(0, mkdir_result) << image_dir;
59 ScratchFile image_file(OS::CreateEmptyFile(image_filename.c_str()));
60
61 std::string oat_filename(image_filename, 0, image_filename.size() - 3);
62 oat_filename += "oat";
63 ScratchFile oat_file(OS::CreateEmptyFile(oat_filename.c_str()));
64
Vladimir Markof4da6752014-08-01 19:04:18 +010065 const uintptr_t requested_image_base = ART_BASE_ADDRESS;
Igor Murashkin46774762014-10-22 11:37:02 -070066 std::unique_ptr<ImageWriter> writer(new ImageWriter(*compiler_driver_, requested_image_base,
67 /*compile_pic*/false));
68 // TODO: compile_pic should be a test argument.
Ian Rogers00f7d0e2012-07-19 15:28:27 -070069 {
Brian Carlstrom700c8d32012-11-05 10:42:02 -080070 {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070071 jobject class_loader = nullptr;
Brian Carlstrom96391602013-06-13 19:49:50 -070072 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogers5fe9af72013-11-14 00:17:20 -080073 TimingLogger timings("ImageTest::WriteRead", false, false);
Mathieu Chartierf5997b42014-06-20 10:37:54 -070074 TimingLogger::ScopedTiming t("CompileAll", &timings);
Brian Carlstrom5f675322013-09-03 22:45:51 -070075 for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
76 dex_file->EnableWrite();
77 }
Ian Rogers3d504072014-03-01 09:16:49 -080078 compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
Brian Carlstrom96391602013-06-13 19:49:50 -070079
Mathieu Chartierf5997b42014-06-20 10:37:54 -070080 t.NewTiming("WriteElf");
Andreas Gampe22f8e5c2014-07-09 11:38:21 -070081 SafeMap<std::string, std::string> key_value_store;
Vladimir Markof4da6752014-08-01 19:04:18 +010082 OatWriter oat_writer(class_linker->GetBootClassPath(), 0, 0, 0, compiler_driver_.get(),
Mathieu Chartier6e88ef62014-10-14 15:01:24 -070083 writer.get(), &timings, &key_value_store);
84 bool success = writer->PrepareImageAddressSpace() &&
Vladimir Markof4da6752014-08-01 19:04:18 +010085 compiler_driver_->WriteElf(GetTestAndroidRoot(),
86 !kIsTargetBuild,
87 class_linker->GetBootClassPath(),
88 &oat_writer,
89 oat_file.GetFile());
Brian Carlstromc50d8e12013-07-23 22:35:16 -070090 ASSERT_TRUE(success);
Ian Rogers00f7d0e2012-07-19 15:28:27 -070091 }
Ian Rogers0571d352011-11-03 19:51:38 -070092 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -070093 // Workound bug that mcld::Linker::emit closes oat_file by reopening as dup_oat.
Ian Rogers700a4022014-05-19 16:49:03 -070094 std::unique_ptr<File> dup_oat(OS::OpenFileReadWrite(oat_file.GetFilename().c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -070095 ASSERT_TRUE(dup_oat.get() != nullptr);
Mathieu Chartier357e9be2012-08-01 11:00:14 -070096
jeffhao8161c032012-10-31 15:50:00 -070097 {
Vladimir Markof4da6752014-08-01 19:04:18 +010098 bool success_image =
Mathieu Chartier6e88ef62014-10-14 15:01:24 -070099 writer->Write(image_file.GetFilename(), dup_oat->GetPath(), dup_oat->GetPath());
jeffhao8161c032012-10-31 15:50:00 -0700100 ASSERT_TRUE(success_image);
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700101 bool success_fixup = ElfWriter::Fixup(dup_oat.get(), writer->GetOatDataBegin());
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800102 ASSERT_TRUE(success_fixup);
Andreas Gampe4303ba92014-11-06 01:00:46 -0800103
104 ASSERT_EQ(dup_oat->FlushCloseOrErase(), 0) << "Could not flush and close oat file "
105 << oat_file.GetFilename();
jeffhao8161c032012-10-31 15:50:00 -0700106 }
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700107
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700108 uint64_t image_file_size;
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700109 {
Ian Rogers700a4022014-05-19 16:49:03 -0700110 std::unique_ptr<File> file(OS::OpenFileForReading(image_file.GetFilename().c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700111 ASSERT_TRUE(file.get() != nullptr);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700112 ImageHeader image_header;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800113 ASSERT_EQ(file->ReadFully(&image_header, sizeof(image_header)), true);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700114 ASSERT_TRUE(image_header.IsValid());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700115 const auto& bitmap_section = image_header.GetImageSection(ImageHeader::kSectionImageBitmap);
116 ASSERT_GE(bitmap_section.Offset(), sizeof(image_header));
117 ASSERT_NE(0U, bitmap_section.Size());
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700118
Ian Rogers1d54e732013-05-02 21:10:01 -0700119 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700120 ASSERT_TRUE(!heap->GetContinuousSpaces().empty());
121 gc::space::ContinuousSpace* space = heap->GetNonMovingSpace();
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700122 ASSERT_FALSE(space->IsImageSpace());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700123 ASSERT_TRUE(space != nullptr);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700124 ASSERT_TRUE(space->IsMallocSpace());
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700125
126 image_file_size = file->GetLength();
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700127 }
Brian Carlstrom8a436592011-08-15 21:27:23 -0700128
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700129 ASSERT_TRUE(compiler_driver_->GetImageClasses() != nullptr);
Andreas Gampeb1fcead2015-04-20 18:53:51 -0700130 std::unordered_set<std::string> image_classes(*compiler_driver_->GetImageClasses());
Brian Carlstrom96391602013-06-13 19:49:50 -0700131
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700132 // Need to delete the compiler since it has worker threads which are attached to runtime.
Ian Rogers1212a022013-03-04 10:48:41 -0800133 compiler_driver_.reset();
Mathieu Chartier0e4627e2012-10-23 16:13:36 -0700134
Ian Rogers10c5b782013-01-10 10:40:53 -0800135 // Tear down old runtime before making a new one, clearing out misc state.
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700136
137 // Remove the reservation of the memory for use to load the image.
138 // Need to do this before we reset the runtime.
139 UnreserveImageSpace();
140 writer.reset(nullptr);
141
Ian Rogers10c5b782013-01-10 10:40:53 -0800142 runtime_.reset();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700143 java_lang_dex_file_ = nullptr;
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700144
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700145 MemMap::Init();
Andreas Gampe833a4852014-05-21 18:46:59 -0700146 std::unique_ptr<const DexFile> dex(LoadExpectSingleDexFile(GetLibCoreDexFileName().c_str()));
Brian Carlstrom8a436592011-08-15 21:27:23 -0700147
Ian Rogerse63db272014-07-15 15:36:11 -0700148 RuntimeOptions options;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700149 std::string image("-Ximage:");
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700150 image.append(image_location.GetFilename());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700151 options.push_back(std::make_pair(image.c_str(), static_cast<void*>(nullptr)));
Alex Light6e183f22014-07-18 14:57:04 -0700152 // By default the compiler this creates will not include patch information.
153 options.push_back(std::make_pair("-Xnorelocate", nullptr));
Brian Carlstrom8a436592011-08-15 21:27:23 -0700154
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700155 if (!Runtime::Create(options, false)) {
156 LOG(FATAL) << "Failed to create runtime";
157 return;
158 }
159 runtime_.reset(Runtime::Current());
160 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
161 // give it away now and then switch to a more managable ScopedObjectAccess.
162 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
163 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700164 ASSERT_TRUE(runtime_.get() != nullptr);
Brian Carlstrom8a436592011-08-15 21:27:23 -0700165 class_linker_ = runtime_->GetClassLinker();
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700166
Ian Rogers1d54e732013-05-02 21:10:01 -0700167 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700168 ASSERT_TRUE(heap->HasImageSpace());
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700169 ASSERT_TRUE(heap->GetNonMovingSpace()->IsMallocSpace());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700170
Ian Rogers1d54e732013-05-02 21:10:01 -0700171 gc::space::ImageSpace* image_space = heap->GetImageSpace();
Mathieu Chartier68c868e2015-06-01 16:33:53 -0700172 ASSERT_TRUE(image_space != nullptr);
173 ASSERT_LE(image_space->Size(), image_file_size);
174
Mathieu Chartier31e89252013-08-28 11:29:12 -0700175 image_space->VerifyImageAllocations();
Ian Rogers13735952014-10-08 12:43:28 -0700176 uint8_t* image_begin = image_space->Begin();
177 uint8_t* image_end = image_space->End();
Ian Rogers30fab402012-01-23 15:43:46 -0800178 CHECK_EQ(requested_image_base, reinterpret_cast<uintptr_t>(image_begin));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800179 for (size_t i = 0; i < dex->NumClassDefs(); ++i) {
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700180 const DexFile::ClassDef& class_def = dex->GetClassDef(i);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700181 const char* descriptor = dex->GetClassDescriptor(class_def);
Ian Rogers98379392014-02-24 16:53:16 -0800182 mirror::Class* klass = class_linker_->FindSystemClass(soa.Self(), descriptor);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800183 EXPECT_TRUE(klass != nullptr) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700184 if (image_classes.find(descriptor) != image_classes.end()) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800185 // Image classes should be located inside the image.
Ian Rogers13735952014-10-08 12:43:28 -0700186 EXPECT_LT(image_begin, reinterpret_cast<uint8_t*>(klass)) << descriptor;
187 EXPECT_LT(reinterpret_cast<uint8_t*>(klass), image_end) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700188 } else {
Ian Rogers13735952014-10-08 12:43:28 -0700189 EXPECT_TRUE(reinterpret_cast<uint8_t*>(klass) >= image_end ||
190 reinterpret_cast<uint8_t*>(klass) < image_begin) << descriptor;
Brian Carlstrom96391602013-06-13 19:49:50 -0700191 }
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700192 EXPECT_TRUE(Monitor::IsValidLockWord(klass->GetLockWord(false)));
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700193 }
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700194
195 image_file.Unlink();
196 oat_file.Unlink();
197 int rmdir_result = rmdir(image_dir.c_str());
198 CHECK_EQ(0, rmdir_result);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700199}
200
Brian Carlstrom179486a2013-09-03 11:51:42 -0700201TEST_F(ImageTest, ImageHeaderIsValid) {
202 uint32_t image_begin = ART_BASE_ADDRESS;
203 uint32_t image_size_ = 16 * KB;
Brian Carlstrom179486a2013-09-03 11:51:42 -0700204 uint32_t image_roots = ART_BASE_ADDRESS + (1 * KB);
205 uint32_t oat_checksum = 0;
206 uint32_t oat_file_begin = ART_BASE_ADDRESS + (4 * KB); // page aligned
207 uint32_t oat_data_begin = ART_BASE_ADDRESS + (8 * KB); // page aligned
208 uint32_t oat_data_end = ART_BASE_ADDRESS + (9 * KB);
209 uint32_t oat_file_end = ART_BASE_ADDRESS + (10 * KB);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700210 ImageSection sections[ImageHeader::kSectionCount];
Brian Carlstrom179486a2013-09-03 11:51:42 -0700211 ImageHeader image_header(image_begin,
212 image_size_,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700213 sections,
Brian Carlstrom179486a2013-09-03 11:51:42 -0700214 image_roots,
215 oat_checksum,
216 oat_file_begin,
217 oat_data_begin,
218 oat_data_end,
Igor Murashkin46774762014-10-22 11:37:02 -0700219 oat_file_end,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700220 sizeof(void*),
Igor Murashkin46774762014-10-22 11:37:02 -0700221 /*compile_pic*/false);
Brian Carlstrom179486a2013-09-03 11:51:42 -0700222 ASSERT_TRUE(image_header.IsValid());
223
224 char* magic = const_cast<char*>(image_header.GetMagic());
225 strcpy(magic, ""); // bad magic
226 ASSERT_FALSE(image_header.IsValid());
227 strcpy(magic, "art\n000"); // bad version
228 ASSERT_FALSE(image_header.IsValid());
229}
230
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700231} // namespace art