1 /*
2 * Copyright (C) 2017 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 <string>
18 #include <vector>
19
20 #include <backtrace/BacktraceMap.h>
21 #include <gtest/gtest.h>
22
23 #include "base/file_utils.h"
24 #include "common_runtime_test.h"
25 #include "compiler_callbacks.h"
26 #include "dex2oat_environment_test.h"
27 #include "dexopt_test.h"
28 #include "gc/space/image_space.h"
29 #include "mem_map.h"
30
31 namespace art {
SetUp()32 void DexoptTest::SetUp() {
33 ReserveImageSpace();
34 Dex2oatEnvironmentTest::SetUp();
35 }
36
PreRuntimeCreate()37 void DexoptTest::PreRuntimeCreate() {
38 std::string error_msg;
39 ASSERT_TRUE(PreRelocateImage(GetImageLocation(), &error_msg)) << error_msg;
40 ASSERT_TRUE(PreRelocateImage(GetImageLocation2(), &error_msg)) << error_msg;
41 UnreserveImageSpace();
42 }
43
PostRuntimeCreate()44 void DexoptTest::PostRuntimeCreate() {
45 ReserveImageSpace();
46 }
47
GenerateOatForTest(const std::string & dex_location,const std::string & oat_location_in,CompilerFilter::Filter filter,bool relocate,bool pic,bool with_alternate_image,const char * compilation_reason)48 void DexoptTest::GenerateOatForTest(const std::string& dex_location,
49 const std::string& oat_location_in,
50 CompilerFilter::Filter filter,
51 bool relocate,
52 bool pic,
53 bool with_alternate_image,
54 const char* compilation_reason) {
55 std::string dalvik_cache = GetDalvikCache(GetInstructionSetString(kRuntimeISA));
56 std::string dalvik_cache_tmp = dalvik_cache + ".redirected";
57 std::string oat_location = oat_location_in;
58 if (!relocate) {
59 // Temporarily redirect the dalvik cache so dex2oat doesn't find the
60 // relocated image file.
61 ASSERT_EQ(0, rename(dalvik_cache.c_str(), dalvik_cache_tmp.c_str())) << strerror(errno);
62 // If the oat location is in dalvik cache, replace the cache path with the temporary one.
63 size_t pos = oat_location.find(dalvik_cache);
64 if (pos != std::string::npos) {
65 oat_location = oat_location.replace(pos, dalvik_cache.length(), dalvik_cache_tmp);
66 }
67 }
68
69 std::vector<std::string> args;
70 args.push_back("--dex-file=" + dex_location);
71 args.push_back("--oat-file=" + oat_location);
72 args.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(filter));
73 args.push_back("--runtime-arg");
74
75 // Use -Xnorelocate regardless of the relocate argument.
76 // We control relocation by redirecting the dalvik cache when needed
77 // rather than use this flag.
78 args.push_back("-Xnorelocate");
79
80 ScratchFile profile_file;
81 if (CompilerFilter::DependsOnProfile(filter)) {
82 args.push_back("--profile-file=" + profile_file.GetFilename());
83 }
84
85 if (pic) {
86 args.push_back("--compile-pic");
87 }
88
89 std::string image_location = GetImageLocation();
90 if (with_alternate_image) {
91 args.push_back("--boot-image=" + GetImageLocation2());
92 }
93
94 if (compilation_reason != nullptr) {
95 args.push_back("--compilation-reason=" + std::string(compilation_reason));
96 }
97
98 std::string error_msg;
99 ASSERT_TRUE(OatFileAssistant::Dex2Oat(args, &error_msg)) << error_msg;
100
101 if (!relocate) {
102 // Restore the dalvik cache if needed.
103 ASSERT_EQ(0, rename(dalvik_cache_tmp.c_str(), dalvik_cache.c_str())) << strerror(errno);
104 oat_location = oat_location_in;
105 }
106
107 // Verify the odex file was generated as expected.
108 std::unique_ptr<OatFile> odex_file(OatFile::Open(/* zip_fd */ -1,
109 oat_location.c_str(),
110 oat_location.c_str(),
111 nullptr,
112 nullptr,
113 false,
114 /*low_4gb*/false,
115 dex_location.c_str(),
116 &error_msg));
117 ASSERT_TRUE(odex_file.get() != nullptr) << error_msg;
118 EXPECT_EQ(pic, odex_file->IsPic());
119 EXPECT_EQ(filter, odex_file->GetCompilerFilter());
120
121 std::unique_ptr<ImageHeader> image_header(
122 gc::space::ImageSpace::ReadImageHeader(image_location.c_str(),
123 kRuntimeISA,
124 &error_msg));
125 ASSERT_TRUE(image_header != nullptr) << error_msg;
126 const OatHeader& oat_header = odex_file->GetOatHeader();
127 uint32_t combined_checksum = image_header->GetOatChecksum();
128
129 if (CompilerFilter::DependsOnImageChecksum(filter)) {
130 if (with_alternate_image) {
131 EXPECT_NE(combined_checksum, oat_header.GetImageFileLocationOatChecksum());
132 } else {
133 EXPECT_EQ(combined_checksum, oat_header.GetImageFileLocationOatChecksum());
134 }
135 }
136
137 if (!with_alternate_image) {
138 if (CompilerFilter::IsAotCompilationEnabled(filter)) {
139 if (relocate) {
140 EXPECT_EQ(reinterpret_cast<uintptr_t>(image_header->GetOatDataBegin()),
141 oat_header.GetImageFileLocationOatDataBegin());
142 EXPECT_EQ(image_header->GetPatchDelta(), oat_header.GetImagePatchDelta());
143 } else {
144 EXPECT_NE(reinterpret_cast<uintptr_t>(image_header->GetOatDataBegin()),
145 oat_header.GetImageFileLocationOatDataBegin());
146 EXPECT_NE(image_header->GetPatchDelta(), oat_header.GetImagePatchDelta());
147 }
148 }
149 }
150 }
151
GenerateOdexForTest(const std::string & dex_location,const std::string & odex_location,CompilerFilter::Filter filter)152 void DexoptTest::GenerateOdexForTest(const std::string& dex_location,
153 const std::string& odex_location,
154 CompilerFilter::Filter filter) {
155 GenerateOatForTest(dex_location,
156 odex_location,
157 filter,
158 /*relocate*/false,
159 /*pic*/false,
160 /*with_alternate_image*/false);
161 }
162
GeneratePicOdexForTest(const std::string & dex_location,const std::string & odex_location,CompilerFilter::Filter filter,const char * compilation_reason)163 void DexoptTest::GeneratePicOdexForTest(const std::string& dex_location,
164 const std::string& odex_location,
165 CompilerFilter::Filter filter,
166 const char* compilation_reason) {
167 GenerateOatForTest(dex_location,
168 odex_location,
169 filter,
170 /*relocate*/false,
171 /*pic*/true,
172 /*with_alternate_image*/false,
173 compilation_reason);
174 }
175
GenerateOatForTest(const char * dex_location,CompilerFilter::Filter filter,bool relocate,bool pic,bool with_alternate_image)176 void DexoptTest::GenerateOatForTest(const char* dex_location,
177 CompilerFilter::Filter filter,
178 bool relocate,
179 bool pic,
180 bool with_alternate_image) {
181 std::string oat_location;
182 std::string error_msg;
183 ASSERT_TRUE(OatFileAssistant::DexLocationToOatFilename(
184 dex_location, kRuntimeISA, &oat_location, &error_msg)) << error_msg;
185 GenerateOatForTest(dex_location,
186 oat_location,
187 filter,
188 relocate,
189 pic,
190 with_alternate_image);
191 }
192
GenerateOatForTest(const char * dex_location,CompilerFilter::Filter filter)193 void DexoptTest::GenerateOatForTest(const char* dex_location, CompilerFilter::Filter filter) {
194 GenerateOatForTest(dex_location,
195 filter,
196 /*relocate*/true,
197 /*pic*/false,
198 /*with_alternate_image*/false);
199 }
200
PreRelocateImage(const std::string & image_location,std::string * error_msg)201 bool DexoptTest::PreRelocateImage(const std::string& image_location, std::string* error_msg) {
202 std::string dalvik_cache;
203 bool have_android_data;
204 bool dalvik_cache_exists;
205 bool is_global_cache;
206 GetDalvikCache(GetInstructionSetString(kRuntimeISA),
207 true,
208 &dalvik_cache,
209 &have_android_data,
210 &dalvik_cache_exists,
211 &is_global_cache);
212 if (!dalvik_cache_exists) {
213 *error_msg = "Failed to create dalvik cache";
214 return false;
215 }
216
217 std::string patchoat = GetAndroidRoot();
218 patchoat += kIsDebugBuild ? "/bin/patchoatd" : "/bin/patchoat";
219
220 std::vector<std::string> argv;
221 argv.push_back(patchoat);
222 argv.push_back("--input-image-location=" + image_location);
223 argv.push_back("--output-image-directory=" + dalvik_cache);
224 argv.push_back("--instruction-set=" + std::string(GetInstructionSetString(kRuntimeISA)));
225 argv.push_back("--base-offset-delta=0x00008000");
226 return Exec(argv, error_msg);
227 }
228
ReserveImageSpace()229 void DexoptTest::ReserveImageSpace() {
230 MemMap::Init();
231
232 // Ensure a chunk of memory is reserved for the image space.
233 // The reservation_end includes room for the main space that has to come
234 // right after the image in case of the GSS collector.
235 uint64_t reservation_start = ART_BASE_ADDRESS;
236 uint64_t reservation_end = ART_BASE_ADDRESS + 384 * MB;
237
238 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid(), true));
239 ASSERT_TRUE(map.get() != nullptr) << "Failed to build process map";
240 for (BacktraceMap::iterator it = map->begin();
241 reservation_start < reservation_end && it != map->end(); ++it) {
242 const backtrace_map_t* entry = *it;
243 ReserveImageSpaceChunk(reservation_start, std::min(entry->start, reservation_end));
244 reservation_start = std::max(reservation_start, entry->end);
245 }
246 ReserveImageSpaceChunk(reservation_start, reservation_end);
247 }
248
ReserveImageSpaceChunk(uintptr_t start,uintptr_t end)249 void DexoptTest::ReserveImageSpaceChunk(uintptr_t start, uintptr_t end) {
250 if (start < end) {
251 std::string error_msg;
252 image_reservation_.push_back(std::unique_ptr<MemMap>(
253 MemMap::MapAnonymous("image reservation",
254 reinterpret_cast<uint8_t*>(start), end - start,
255 PROT_NONE, false, false, &error_msg)));
256 ASSERT_TRUE(image_reservation_.back().get() != nullptr) << error_msg;
257 LOG(INFO) << "Reserved space for image " <<
258 reinterpret_cast<void*>(image_reservation_.back()->Begin()) << "-" <<
259 reinterpret_cast<void*>(image_reservation_.back()->End());
260 }
261 }
262
UnreserveImageSpace()263 void DexoptTest::UnreserveImageSpace() {
264 image_reservation_.clear();
265 }
266
267 } // namespace art
268