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 <fstream>
18 #include <regex>
19 #include <sstream>
20 #include <string>
21 #include <vector>
22
23 #include <sys/mman.h>
24 #include <sys/wait.h>
25 #include <unistd.h>
26
27 #include <android-base/logging.h>
28 #include <android-base/stringprintf.h>
29 #include <android-base/strings.h>
30
31 #include "common_runtime_test.h"
32
33 #include "base/array_ref.h"
34 #include "base/file_utils.h"
35 #include "base/macros.h"
36 #include "base/mem_map.h"
37 #include "base/string_view_cpp20.h"
38 #include "base/unix_file/fd_file.h"
39 #include "base/utils.h"
40 #include "dex/art_dex_file_loader.h"
41 #include "dex/dex_file-inl.h"
42 #include "dex/dex_file_loader.h"
43 #include "dex/method_reference.h"
44 #include "dex/type_reference.h"
45 #include "gc/space/image_space.h"
46 #include "runtime.h"
47 #include "scoped_thread_state_change-inl.h"
48 #include "thread-current-inl.h"
49
50 namespace art {
51
52 // A suitable address for loading the core images.
53 constexpr uint32_t kBaseAddress = ART_BASE_ADDRESS;
54
55 struct ImageSizes {
56 size_t art_size = 0;
57 size_t oat_size = 0;
58 size_t vdex_size = 0;
59 };
60
operator <<(std::ostream & os,const ImageSizes & sizes)61 std::ostream& operator<<(std::ostream& os, const ImageSizes& sizes) {
62 os << "art=" << sizes.art_size << " oat=" << sizes.oat_size << " vdex=" << sizes.vdex_size;
63 return os;
64 }
65
66 class Dex2oatImageTest : public CommonRuntimeTest {
67 public:
TearDown()68 void TearDown() override {}
69
70 protected:
SetUpRuntimeOptions(RuntimeOptions * options)71 void SetUpRuntimeOptions(RuntimeOptions* options) override {
72 // Disable implicit dex2oat invocations when loading image spaces.
73 options->emplace_back("-Xnoimage-dex2oat", nullptr);
74 }
75
WriteLine(File * file,std::string line)76 static void WriteLine(File* file, std::string line) {
77 line += '\n';
78 EXPECT_TRUE(file->WriteFully(&line[0], line.length()));
79 }
80
AddRuntimeArg(std::vector<std::string> & args,const std::string & arg)81 void AddRuntimeArg(std::vector<std::string>& args, const std::string& arg) {
82 args.push_back("--runtime-arg");
83 args.push_back(arg);
84 }
85
CompileImageAndGetSizes(ArrayRef<const std::string> dex_files,const std::vector<std::string> & extra_args)86 ImageSizes CompileImageAndGetSizes(ArrayRef<const std::string> dex_files,
87 const std::vector<std::string>& extra_args) {
88 ImageSizes ret;
89 ScratchDir scratch;
90 std::string filename_prefix = scratch.GetPath() + "boot";
91 std::vector<std::string> local_extra_args = extra_args;
92 local_extra_args.push_back(android::base::StringPrintf("--base=0x%08x", kBaseAddress));
93 std::string error_msg;
94 if (!CompileBootImage(local_extra_args, filename_prefix, dex_files, &error_msg)) {
95 LOG(ERROR) << "Failed to compile image " << filename_prefix << error_msg;
96 }
97 std::string art_file = filename_prefix + ".art";
98 std::string oat_file = filename_prefix + ".oat";
99 std::string vdex_file = filename_prefix + ".vdex";
100 int64_t art_size = OS::GetFileSizeBytes(art_file.c_str());
101 int64_t oat_size = OS::GetFileSizeBytes(oat_file.c_str());
102 int64_t vdex_size = OS::GetFileSizeBytes(vdex_file.c_str());
103 CHECK_GT(art_size, 0u) << art_file;
104 CHECK_GT(oat_size, 0u) << oat_file;
105 CHECK_GT(vdex_size, 0u) << vdex_file;
106 ret.art_size = art_size;
107 ret.oat_size = oat_size;
108 ret.vdex_size = vdex_size;
109 return ret;
110 }
111
ReserveCoreImageAddressSpace(std::string * error_msg)112 MemMap ReserveCoreImageAddressSpace(/*out*/std::string* error_msg) {
113 constexpr size_t kReservationSize = 256 * MB; // This should be enough for the compiled images.
114 // Extend to both directions for maximum relocation difference.
115 static_assert(ART_BASE_ADDRESS_MIN_DELTA < 0);
116 static_assert(ART_BASE_ADDRESS_MAX_DELTA > 0);
117 static_assert(IsAligned<kPageSize>(ART_BASE_ADDRESS_MIN_DELTA));
118 static_assert(IsAligned<kPageSize>(ART_BASE_ADDRESS_MAX_DELTA));
119 constexpr size_t kExtra = ART_BASE_ADDRESS_MAX_DELTA - ART_BASE_ADDRESS_MIN_DELTA;
120 uint32_t min_relocated_address = kBaseAddress + ART_BASE_ADDRESS_MIN_DELTA;
121 return MemMap::MapAnonymous("Reservation",
122 reinterpret_cast<uint8_t*>(min_relocated_address),
123 kReservationSize + kExtra,
124 PROT_NONE,
125 /*low_4gb=*/ true,
126 /*reuse=*/ false,
127 /*reservation=*/ nullptr,
128 error_msg);
129 }
130
CopyDexFiles(const std::string & dir,std::vector<std::string> * dex_files)131 void CopyDexFiles(const std::string& dir, /*inout*/std::vector<std::string>* dex_files) {
132 CHECK(EndsWith(dir, "/"));
133 for (std::string& dex_file : *dex_files) {
134 size_t slash_pos = dex_file.rfind('/');
135 CHECK(OS::FileExists(dex_file.c_str())) << dex_file;
136 CHECK_NE(std::string::npos, slash_pos);
137 std::string new_location = dir + dex_file.substr(slash_pos + 1u);
138 std::ifstream src_stream(dex_file, std::ios::binary);
139 std::ofstream dst_stream(new_location, std::ios::binary);
140 dst_stream << src_stream.rdbuf();
141 dex_file = new_location;
142 }
143 }
144
CompareFiles(const std::string & filename1,const std::string & filename2)145 bool CompareFiles(const std::string& filename1, const std::string& filename2) {
146 std::unique_ptr<File> file1(OS::OpenFileForReading(filename1.c_str()));
147 std::unique_ptr<File> file2(OS::OpenFileForReading(filename2.c_str()));
148 // Did we open the files?
149 if (file1 == nullptr || file2 == nullptr) {
150 return false;
151 }
152 // Are they non-empty and the same length?
153 if (file1->GetLength() <= 0 || file2->GetLength() != file1->GetLength()) {
154 return false;
155 }
156 return file1->Compare(file2.get()) == 0;
157 }
158
AddAndroidRootToImageCompilerOptions()159 void AddAndroidRootToImageCompilerOptions() {
160 const char* android_root = getenv("ANDROID_ROOT");
161 CHECK(android_root != nullptr);
162 Runtime::Current()->image_compiler_options_.push_back(
163 "--android-root=" + std::string(android_root));
164 }
165
EnableImageDex2Oat()166 void EnableImageDex2Oat() {
167 Runtime::Current()->image_dex2oat_enabled_ = true;
168 }
169
DisableImageDex2Oat()170 void DisableImageDex2Oat() {
171 Runtime::Current()->image_dex2oat_enabled_ = false;
172 }
173 };
174
TEST_F(Dex2oatImageTest,TestModesAndFilters)175 TEST_F(Dex2oatImageTest, TestModesAndFilters) {
176 // This test crashes on the gtest-heap-poisoning configuration
177 // (AddressSanitizer + CMS/RosAlloc + heap-poisoning); see b/111061592.
178 // Temporarily disable this test on this configuration to keep
179 // our automated build/testing green while we work on a fix.
180 TEST_DISABLED_FOR_MEMORY_TOOL_WITH_HEAP_POISONING_WITHOUT_READ_BARRIERS();
181 if (kIsTargetBuild) {
182 // This test is too slow for target builds.
183 return;
184 }
185 // Compile only a subset of the libcore dex files to make this test shorter.
186 std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames();
187 // The primary image must contain at least core-oj and core-libart to initialize the runtime.
188 ASSERT_NE(std::string::npos, libcore_dex_files[0].find("core-oj"));
189 ASSERT_NE(std::string::npos, libcore_dex_files[1].find("core-libart"));
190 ArrayRef<const std::string> dex_files =
191 ArrayRef<const std::string>(libcore_dex_files).SubArray(/*pos=*/ 0u, /*length=*/ 2u);
192
193 ImageSizes base_sizes = CompileImageAndGetSizes(dex_files, {});
194 ImageSizes everything_sizes;
195 ImageSizes filter_sizes;
196 std::cout << "Base compile sizes " << base_sizes << std::endl;
197 // Compile all methods and classes
198 std::vector<std::string> libcore_dexes = GetLibCoreDexFileNames();
199 ArrayRef<const std::string> libcore_dexes_array(libcore_dexes);
200 {
201 ScratchFile profile_file;
202 GenerateBootProfile(libcore_dexes_array,
203 profile_file.GetFile(),
204 /*method_frequency=*/ 1u,
205 /*type_frequency=*/ 1u);
206 everything_sizes = CompileImageAndGetSizes(
207 dex_files,
208 {"--profile-file=" + profile_file.GetFilename(),
209 "--compiler-filter=speed-profile"});
210 profile_file.Close();
211 std::cout << "All methods and classes sizes " << everything_sizes << std::endl;
212 // Putting all classes as image classes should increase art size
213 EXPECT_GE(everything_sizes.art_size, base_sizes.art_size);
214 // Check that dex is the same size.
215 EXPECT_EQ(everything_sizes.vdex_size, base_sizes.vdex_size);
216 }
217 static size_t kMethodFrequency = 3;
218 static size_t kTypeFrequency = 4;
219 // Test compiling fewer methods and classes.
220 {
221 ScratchFile profile_file;
222 GenerateBootProfile(libcore_dexes_array,
223 profile_file.GetFile(),
224 kMethodFrequency,
225 kTypeFrequency);
226 filter_sizes = CompileImageAndGetSizes(
227 dex_files,
228 {"--profile-file=" + profile_file.GetFilename(),
229 "--compiler-filter=speed-profile"});
230 profile_file.Close();
231 std::cout << "Fewer methods and classes sizes " << filter_sizes << std::endl;
232 EXPECT_LE(filter_sizes.art_size, everything_sizes.art_size);
233 EXPECT_LE(filter_sizes.oat_size, everything_sizes.oat_size);
234 EXPECT_LE(filter_sizes.vdex_size, everything_sizes.vdex_size);
235 }
236 // Test dirty image objects.
237 {
238 ScratchFile classes;
239 VisitDexes(libcore_dexes_array,
240 VoidFunctor(),
241 [&](TypeReference ref) {
242 WriteLine(classes.GetFile(), ref.dex_file->PrettyType(ref.TypeIndex()));
243 }, /*method_frequency=*/ 1u, /*class_frequency=*/ 1u);
244 ImageSizes image_classes_sizes = CompileImageAndGetSizes(
245 dex_files,
246 {"--dirty-image-objects=" + classes.GetFilename()});
247 classes.Close();
248 std::cout << "Dirty image object sizes " << image_classes_sizes << std::endl;
249 }
250 }
251
TEST_F(Dex2oatImageTest,TestExtension)252 TEST_F(Dex2oatImageTest, TestExtension) {
253 std::string error_msg;
254 MemMap reservation = ReserveCoreImageAddressSpace(&error_msg);
255 ASSERT_TRUE(reservation.IsValid()) << error_msg;
256
257 ScratchDir scratch;
258 const std::string& scratch_dir = scratch.GetPath();
259 std::string image_dir = scratch_dir + GetInstructionSetString(kRuntimeISA);
260 int mkdir_result = mkdir(image_dir.c_str(), 0700);
261 ASSERT_EQ(0, mkdir_result);
262 std::string filename_prefix = image_dir + "/boot";
263
264 // Copy the libcore dex files to a custom dir inside `scratch_dir` so that we do not
265 // accidentally load pre-compiled core images from their original directory based on BCP paths.
266 std::string jar_dir = scratch_dir + "jars";
267 mkdir_result = mkdir(jar_dir.c_str(), 0700);
268 ASSERT_EQ(0, mkdir_result);
269 jar_dir += '/';
270 std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames();
271 CopyDexFiles(jar_dir, &libcore_dex_files);
272
273 ArrayRef<const std::string> full_bcp(libcore_dex_files);
274 size_t total_dex_files = full_bcp.size();
275 ASSERT_GE(total_dex_files, 4u); // 2 for "head", 1 for "tail", at least one for "mid", see below.
276
277 // The primary image must contain at least core-oj and core-libart to initialize the runtime.
278 ASSERT_NE(std::string::npos, full_bcp[0].find("core-oj"));
279 ASSERT_NE(std::string::npos, full_bcp[1].find("core-libart"));
280 ArrayRef<const std::string> head_dex_files = full_bcp.SubArray(/*pos=*/ 0u, /*length=*/ 2u);
281 // Middle part is everything else except for conscrypt.
282 ASSERT_NE(std::string::npos, full_bcp[full_bcp.size() - 1u].find("conscrypt"));
283 ArrayRef<const std::string> mid_bcp =
284 full_bcp.SubArray(/*pos=*/ 0u, /*length=*/ total_dex_files - 1u);
285 ArrayRef<const std::string> mid_dex_files = mid_bcp.SubArray(/*pos=*/ 2u);
286 // Tail is just the conscrypt.
287 ArrayRef<const std::string> tail_dex_files =
288 full_bcp.SubArray(/*pos=*/ total_dex_files - 1u, /*length=*/ 1u);
289
290 // Prepare the "head", "mid" and "tail" names and locations.
291 std::string base_name = "boot.art";
292 std::string base_location = scratch_dir + base_name;
293 std::vector<std::string> expanded_mid = gc::space::ImageSpace::ExpandMultiImageLocations(
294 mid_dex_files.SubArray(/*pos=*/ 0u, /*length=*/ 1u),
295 base_location,
296 /*boot_image_extension=*/ true);
297 CHECK_EQ(1u, expanded_mid.size());
298 std::string mid_location = expanded_mid[0];
299 size_t mid_slash_pos = mid_location.rfind('/');
300 ASSERT_NE(std::string::npos, mid_slash_pos);
301 std::string mid_name = mid_location.substr(mid_slash_pos + 1u);
302 CHECK_EQ(1u, tail_dex_files.size());
303 std::vector<std::string> expanded_tail = gc::space::ImageSpace::ExpandMultiImageLocations(
304 tail_dex_files, base_location, /*boot_image_extension=*/ true);
305 CHECK_EQ(1u, expanded_tail.size());
306 std::string tail_location = expanded_tail[0];
307 size_t tail_slash_pos = tail_location.rfind('/');
308 ASSERT_NE(std::string::npos, tail_slash_pos);
309 std::string tail_name = tail_location.substr(tail_slash_pos + 1u);
310
311 // Create profiles.
312 ScratchFile head_profile_file;
313 GenerateBootProfile(head_dex_files,
314 head_profile_file.GetFile(),
315 /*method_frequency=*/ 1u,
316 /*type_frequency=*/ 1u);
317 const std::string& head_profile_filename = head_profile_file.GetFilename();
318 ScratchFile mid_profile_file;
319 GenerateBootProfile(mid_dex_files,
320 mid_profile_file.GetFile(),
321 /*method_frequency=*/ 5u,
322 /*type_frequency=*/ 4u);
323 const std::string& mid_profile_filename = mid_profile_file.GetFilename();
324 ScratchFile tail_profile_file;
325 GenerateBootProfile(tail_dex_files,
326 tail_profile_file.GetFile(),
327 /*method_frequency=*/ 5u,
328 /*type_frequency=*/ 4u);
329 const std::string& tail_profile_filename = tail_profile_file.GetFilename();
330
331 // Compile the "head", i.e. the primary boot image.
332 std::vector<std::string> extra_args;
333 extra_args.push_back("--profile-file=" + head_profile_filename);
334 extra_args.push_back(android::base::StringPrintf("--base=0x%08x", kBaseAddress));
335 bool head_ok = CompileBootImage(extra_args, filename_prefix, head_dex_files, &error_msg);
336 ASSERT_TRUE(head_ok) << error_msg;
337
338 // Compile the "mid", i.e. the first extension.
339 std::string mid_bcp_string = android::base::Join(mid_bcp, ':');
340 extra_args.clear();
341 extra_args.push_back("--profile-file=" + mid_profile_filename);
342 AddRuntimeArg(extra_args, "-Xbootclasspath:" + mid_bcp_string);
343 AddRuntimeArg(extra_args, "-Xbootclasspath-locations:" + mid_bcp_string);
344 extra_args.push_back("--boot-image=" + base_location);
345 bool mid_ok = CompileBootImage(extra_args, filename_prefix, mid_dex_files, &error_msg);
346 ASSERT_TRUE(mid_ok) << error_msg;
347
348 // Try to compile the "tail" without specifying the "mid" extension. This shall fail.
349 extra_args.clear();
350 extra_args.push_back("--profile-file=" + tail_profile_filename);
351 std::string full_bcp_string = android::base::Join(full_bcp, ':');
352 AddRuntimeArg(extra_args, "-Xbootclasspath:" + full_bcp_string);
353 AddRuntimeArg(extra_args, "-Xbootclasspath-locations:" + full_bcp_string);
354 extra_args.push_back("--boot-image=" + base_location);
355 bool tail_ok = CompileBootImage(extra_args, filename_prefix, tail_dex_files, &error_msg);
356 ASSERT_FALSE(tail_ok) << error_msg;
357
358 // Now compile the tail against both "head" and "mid".
359 CHECK(StartsWith(extra_args.back(), "--boot-image="));
360 extra_args.back() = "--boot-image=" + base_location + ':' + mid_location;
361 tail_ok = CompileBootImage(extra_args, filename_prefix, tail_dex_files, &error_msg);
362 ASSERT_TRUE(tail_ok) << error_msg;
363
364 // Prepare directory for the single-image test that squashes the "mid" and "tail".
365 std::string single_dir = scratch_dir + "single";
366 mkdir_result = mkdir(single_dir.c_str(), 0700);
367 ASSERT_EQ(0, mkdir_result);
368 single_dir += '/';
369 std::string single_image_dir = single_dir + GetInstructionSetString(kRuntimeISA);
370 mkdir_result = mkdir(single_image_dir.c_str(), 0700);
371 ASSERT_EQ(0, mkdir_result);
372 std::string single_filename_prefix = single_image_dir + "/boot";
373
374 // The dex files for the single-image are everything not in the "head".
375 ArrayRef<const std::string> single_dex_files = full_bcp.SubArray(/*pos=*/ head_dex_files.size());
376
377 // Create a smaller profile for the single-image test that squashes the "mid" and "tail".
378 ScratchFile single_profile_file;
379 GenerateBootProfile(single_dex_files,
380 single_profile_file.GetFile(),
381 /*method_frequency=*/ 5u,
382 /*type_frequency=*/ 4u);
383 const std::string& single_profile_filename = single_profile_file.GetFilename();
384
385 // Prepare the single image name and location.
386 CHECK_GE(single_dex_files.size(), 2u);
387 std::string single_base_location = single_dir + base_name;
388 std::vector<std::string> expanded_single = gc::space::ImageSpace::ExpandMultiImageLocations(
389 single_dex_files.SubArray(/*pos=*/ 0u, /*length=*/ 1u),
390 single_base_location,
391 /*boot_image_extension=*/ true);
392 CHECK_EQ(1u, expanded_single.size());
393 std::string single_location = expanded_single[0];
394 size_t single_slash_pos = single_location.rfind('/');
395 ASSERT_NE(std::string::npos, single_slash_pos);
396 std::string single_name = single_location.substr(single_slash_pos + 1u);
397 CHECK_EQ(single_name, mid_name);
398
399 // Compile the single-image against the primary boot image.
400 extra_args.clear();
401 extra_args.push_back("--profile-file=" + single_profile_filename);
402 AddRuntimeArg(extra_args, "-Xbootclasspath:" + full_bcp_string);
403 AddRuntimeArg(extra_args, "-Xbootclasspath-locations:" + full_bcp_string);
404 extra_args.push_back("--boot-image=" + base_location);
405 extra_args.push_back("--single-image");
406 extra_args.push_back("--avoid-storing-invocation"); // For comparison below.
407 error_msg.clear();
408 bool single_ok =
409 CompileBootImage(extra_args, single_filename_prefix, single_dex_files, &error_msg);
410 ASSERT_TRUE(single_ok) << error_msg;
411
412 reservation = MemMap::Invalid(); // Free the reserved memory for loading images.
413
414 // Try to load the boot image with different image locations.
415 std::vector<std::string> boot_class_path = libcore_dex_files;
416 std::vector<std::unique_ptr<gc::space::ImageSpace>> boot_image_spaces;
417 bool relocate = false;
418 MemMap extra_reservation;
419 auto load = [&](const std::string& image_location) {
420 boot_image_spaces.clear();
421 extra_reservation = MemMap::Invalid();
422 ScopedObjectAccess soa(Thread::Current());
423 return gc::space::ImageSpace::LoadBootImage(/*boot_class_path=*/ boot_class_path,
424 /*boot_class_path_locations=*/ libcore_dex_files,
425 /*boot_class_path_fds=*/ std::vector<int>(),
426 /*boot_class_path_image_fds=*/ std::vector<int>(),
427 /*boot_class_path_vdex_fds=*/ std::vector<int>(),
428 /*boot_class_path_oat_fds=*/ std::vector<int>(),
429 android::base::Split(image_location, ":"),
430 kRuntimeISA,
431 relocate,
432 /*executable=*/ true,
433 /*extra_reservation_size=*/ 0u,
434 /*allow_in_memory_compilation=*/ true,
435 &boot_image_spaces,
436 &extra_reservation);
437 };
438 auto silent_load = [&](const std::string& image_location) {
439 ScopedLogSeverity quiet(LogSeverity::FATAL);
440 return load(image_location);
441 };
442
443 for (bool r : { false, true }) {
444 relocate = r;
445
446 // Load primary image with full path.
447 bool load_ok = load(base_location);
448 ASSERT_TRUE(load_ok) << error_msg;
449 ASSERT_FALSE(extra_reservation.IsValid());
450 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
451
452 // Fail to load primary image with just the name.
453 load_ok = silent_load(base_name);
454 ASSERT_FALSE(load_ok);
455
456 // Fail to load primary image with a search path.
457 load_ok = silent_load("*");
458 ASSERT_FALSE(load_ok);
459 load_ok = silent_load(scratch_dir + "*");
460 ASSERT_FALSE(load_ok);
461
462 // Load the primary and first extension with full path.
463 load_ok = load(base_location + ':' + mid_location);
464 ASSERT_TRUE(load_ok) << error_msg;
465 ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
466
467 // Load the primary with full path and fail to load first extension without full path.
468 load_ok = load(base_location + ':' + mid_name);
469 ASSERT_TRUE(load_ok) << error_msg; // Primary image loaded successfully.
470 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size()); // But only the primary image.
471
472 // Load all the libcore images with full paths.
473 load_ok = load(base_location + ':' + mid_location + ':' + tail_location);
474 ASSERT_TRUE(load_ok) << error_msg;
475 ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
476
477 // Load the primary and first extension with full paths, fail to load second extension by name.
478 load_ok = load(base_location + ':' + mid_location + ':' + tail_name);
479 ASSERT_TRUE(load_ok) << error_msg;
480 ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
481
482 // Load the primary with full path and fail to load first extension without full path,
483 // fail to load second extension because it depends on the first.
484 load_ok = load(base_location + ':' + mid_name + ':' + tail_location);
485 ASSERT_TRUE(load_ok) << error_msg; // Primary image loaded successfully.
486 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size()); // But only the primary image.
487
488 // Load the primary with full path and extensions with a specified search path.
489 load_ok = load(base_location + ':' + scratch_dir + '*');
490 ASSERT_TRUE(load_ok) << error_msg;
491 ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
492
493 // Load the primary with full path and fail to find extensions in BCP path.
494 load_ok = load(base_location + ":*");
495 ASSERT_TRUE(load_ok) << error_msg;
496 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
497 }
498
499 // Now copy the libcore dex files to the `scratch_dir` and retry loading the boot image
500 // with BCP in the scratch_dir so that the images can be found based on BCP paths.
501 CopyDexFiles(scratch_dir, &boot_class_path);
502
503 for (bool r : { false, true }) {
504 relocate = r;
505
506 // Loading the primary image with just the name now succeeds.
507 bool load_ok = load(base_name);
508 ASSERT_TRUE(load_ok) << error_msg;
509 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
510
511 // Loading the primary image with a search path still fails.
512 load_ok = silent_load("*");
513 ASSERT_FALSE(load_ok);
514 load_ok = silent_load(scratch_dir + "*");
515 ASSERT_FALSE(load_ok);
516
517 // Load the primary and first extension without paths.
518 load_ok = load(base_name + ':' + mid_name);
519 ASSERT_TRUE(load_ok) << error_msg;
520 ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
521
522 // Load the primary without path and first extension with path.
523 load_ok = load(base_name + ':' + mid_location);
524 ASSERT_TRUE(load_ok) << error_msg;
525 ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
526
527 // Load the primary with full path and the first extension without full path.
528 load_ok = load(base_location + ':' + mid_name);
529 ASSERT_TRUE(load_ok) << error_msg; // Loaded successfully.
530 ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size()); // Including the extension.
531
532 // Load all the libcore images without paths.
533 load_ok = load(base_name + ':' + mid_name + ':' + tail_name);
534 ASSERT_TRUE(load_ok) << error_msg;
535 ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
536
537 // Load the primary and first extension with full paths and second extension by name.
538 load_ok = load(base_location + ':' + mid_location + ':' + tail_name);
539 ASSERT_TRUE(load_ok) << error_msg;
540 ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
541
542 // Load the primary with full path, first extension without path,
543 // and second extension with full path.
544 load_ok = load(base_location + ':' + mid_name + ':' + tail_location);
545 ASSERT_TRUE(load_ok) << error_msg; // Loaded successfully.
546 ASSERT_EQ(full_bcp.size(), boot_image_spaces.size()); // Including both extensions.
547
548 // Load the primary with full path and find both extensions in BCP path.
549 load_ok = load(base_location + ":*");
550 ASSERT_TRUE(load_ok) << error_msg;
551 ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
552
553 // Fail to load any images with invalid image locations (named component after search paths).
554 load_ok = silent_load(base_location + ":*:" + tail_location);
555 ASSERT_FALSE(load_ok);
556 load_ok = silent_load(base_location + ':' + scratch_dir + "*:" + tail_location);
557 ASSERT_FALSE(load_ok);
558
559 // Load the primary and single-image extension with full path.
560 load_ok = load(base_location + ':' + single_location);
561 ASSERT_TRUE(load_ok) << error_msg;
562 ASSERT_EQ(head_dex_files.size() + 1u, boot_image_spaces.size());
563
564 // Load the primary with full path and single-image extension with a specified search path.
565 load_ok = load(base_location + ':' + single_dir + '*');
566 ASSERT_TRUE(load_ok) << error_msg;
567 ASSERT_EQ(head_dex_files.size() + 1u, boot_image_spaces.size());
568 }
569
570 // Recompile the single-image extension using file descriptors and compare contents.
571 std::vector<std::string> expanded_single_filename_prefix =
572 gc::space::ImageSpace::ExpandMultiImageLocations(
573 single_dex_files.SubArray(/*pos=*/ 0u, /*length=*/ 1u),
574 single_filename_prefix,
575 /*boot_image_extension=*/ true);
576 CHECK_EQ(1u, expanded_single_filename_prefix.size());
577 std::string single_ext_prefix = expanded_single_filename_prefix[0];
578 std::string single_ext_prefix2 = single_ext_prefix + "2";
579 error_msg.clear();
580 single_ok = CompileBootImage(extra_args,
581 single_filename_prefix,
582 single_dex_files,
583 &error_msg,
584 /*use_fd_prefix=*/ single_ext_prefix2);
585 ASSERT_TRUE(single_ok) << error_msg;
586 EXPECT_TRUE(CompareFiles(single_ext_prefix + ".art", single_ext_prefix2 + ".art"));
587 EXPECT_TRUE(CompareFiles(single_ext_prefix + ".vdex", single_ext_prefix2 + ".vdex"));
588 EXPECT_TRUE(CompareFiles(single_ext_prefix + ".oat", single_ext_prefix2 + ".oat"));
589
590 // Test parsing profile specification and creating the boot image extension on-the-fly.
591 // We must set --android-root in the image compiler options.
592 AddAndroidRootToImageCompilerOptions();
593 for (bool r : { false, true }) {
594 relocate = r;
595
596 // Load primary boot image with a profile name.
597 bool load_ok = silent_load(base_location + "!" + single_profile_filename);
598 ASSERT_TRUE(load_ok);
599
600 // Try and fail to load with invalid spec, two profile name separators.
601 load_ok = silent_load(base_location + ":" + single_location + "!!arbitrary-profile-name");
602 ASSERT_FALSE(load_ok);
603
604 // Try and fail to load with invalid spec, missing profile name.
605 load_ok = silent_load(base_location + ":" + single_location + "!");
606 ASSERT_FALSE(load_ok);
607
608 // Try and fail to load with invalid spec, missing component name.
609 load_ok = silent_load(base_location + ":!" + single_profile_filename);
610 ASSERT_FALSE(load_ok);
611
612 // Load primary boot image, specifying invalid extension component and profile name.
613 load_ok = load(base_location + ":/non-existent/" + single_name + "!non-existent-profile-name");
614 ASSERT_TRUE(load_ok) << error_msg;
615 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
616
617 // Load primary boot image and the single extension, specifying invalid profile name.
618 // (Load extension from file.)
619 load_ok = load(base_location + ":" + single_location + "!non-existent-profile-name");
620 ASSERT_TRUE(load_ok) << error_msg;
621 ASSERT_EQ(head_dex_files.size() + 1u, boot_image_spaces.size());
622 ASSERT_EQ(single_dex_files.size(),
623 boot_image_spaces.back()->GetImageHeader().GetComponentCount());
624
625 // Load primary boot image and fail to load the single extension, specifying
626 // invalid extension component name but a valid profile file.
627 // (Running dex2oat to compile extension is disabled.)
628 ASSERT_FALSE(Runtime::Current()->IsImageDex2OatEnabled());
629 load_ok = load(base_location + ":/non-existent/" + single_name + "!" + single_profile_filename);
630 ASSERT_TRUE(load_ok) << error_msg;
631 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
632
633 EnableImageDex2Oat();
634
635 // Load primary boot image and the single extension, specifying invalid extension
636 // component name but a valid profile file. (Compile extension by running dex2oat.)
637 load_ok = load(base_location + ":/non-existent/" + single_name + "!" + single_profile_filename);
638 ASSERT_TRUE(load_ok) << error_msg;
639 ASSERT_EQ(head_dex_files.size() + 1u, boot_image_spaces.size());
640 ASSERT_EQ(single_dex_files.size(),
641 boot_image_spaces.back()->GetImageHeader().GetComponentCount());
642
643 // Load primary boot image and two extensions, specifying invalid extension component
644 // names but valid profile files. (Compile extensions by running dex2oat.)
645 load_ok = load(base_location + ":/non-existent/" + mid_name + "!" + mid_profile_filename
646 + ":/non-existent/" + tail_name + "!" + tail_profile_filename);
647 ASSERT_TRUE(load_ok) << error_msg;
648 ASSERT_EQ(head_dex_files.size() + 2u, boot_image_spaces.size());
649 ASSERT_EQ(mid_dex_files.size(),
650 boot_image_spaces[head_dex_files.size()]->GetImageHeader().GetComponentCount());
651 ASSERT_EQ(tail_dex_files.size(),
652 boot_image_spaces[head_dex_files.size() + 1u]->GetImageHeader().GetComponentCount());
653
654 // Load primary boot image and fail to load extensions, specifying invalid component
655 // names but valid profile file only for the second one. As we fail to load the first
656 // extension, the second extension has a missing dependency and cannot be compiled.
657 load_ok = load(base_location + ":/non-existent/" + mid_name
658 + ":/non-existent/" + tail_name + "!" + tail_profile_filename);
659 ASSERT_TRUE(load_ok) << error_msg;
660 ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
661
662 DisableImageDex2Oat();
663 }
664 }
665
666 } // namespace art
667