blob: ede728281d06de341c2c1af1d07ccfc70879d5cb [file] [log] [blame]
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <fstream>
#include <regex>
#include <sstream>
#include <string>
#include <vector>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include "common_runtime_test.h"
#include "base/array_ref.h"
#include "base/file_utils.h"
#include "base/macros.h"
#include "base/mem_map.h"
#include "base/string_view_cpp20.h"
#include "base/unix_file/fd_file.h"
#include "base/utils.h"
#include "dex/art_dex_file_loader.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_loader.h"
#include "dex/method_reference.h"
#include "gc/space/image_space.h"
#include "profile/profile_compilation_info.h"
#include "runtime.h"
#include "scoped_thread_state_change-inl.h"
#include "thread-current-inl.h"
namespace art {
// A suitable address for loading the core images.
constexpr uint32_t kBaseAddress = ART_BASE_ADDRESS;
struct ImageSizes {
size_t art_size = 0;
size_t oat_size = 0;
size_t vdex_size = 0;
};
std::ostream& operator<<(std::ostream& os, const ImageSizes& sizes) {
os << "art=" << sizes.art_size << " oat=" << sizes.oat_size << " vdex=" << sizes.vdex_size;
return os;
}
class Dex2oatImageTest : public CommonRuntimeTest {
public:
void TearDown() override {}
protected:
void SetUpRuntimeOptions(RuntimeOptions* options) override {
// Disable implicit dex2oat invocations when loading image spaces.
options->emplace_back("-Xnoimage-dex2oat", nullptr);
}
// Visitors take method and type references
template <typename MethodVisitor, typename ClassVisitor>
void VisitLibcoreDexes(const MethodVisitor& method_visitor,
const ClassVisitor& class_visitor,
size_t method_frequency = 1,
size_t class_frequency = 1) {
std::vector<std::string> dexes = GetLibCoreDexFileNames();
VisitDexes(dexes, method_visitor, class_visitor, method_frequency, class_frequency);
}
// Visitors take method and type references
template <typename MethodVisitor, typename ClassVisitor>
void VisitDexes(const std::vector<std::string>& dexes,
const MethodVisitor& method_visitor,
const ClassVisitor& class_visitor,
size_t method_frequency = 1,
size_t class_frequency = 1) {
size_t method_counter = 0;
size_t class_counter = 0;
for (const std::string& dex : dexes) {
std::vector<std::unique_ptr<const DexFile>> dex_files;
std::string error_msg;
const ArtDexFileLoader dex_file_loader;
CHECK(dex_file_loader.Open(dex.c_str(),
dex,
/*verify*/ true,
/*verify_checksum*/ false,
&error_msg,
&dex_files))
<< error_msg;
for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) {
if (++method_counter % method_frequency == 0) {
method_visitor(MethodReference(dex_file.get(), i));
}
}
for (size_t i = 0; i < dex_file->NumTypeIds(); ++i) {
if (++class_counter % class_frequency == 0) {
class_visitor(TypeReference(dex_file.get(), dex::TypeIndex(i)));
}
}
}
}
}
static void WriteLine(File* file, std::string line) {
line += '\n';
EXPECT_TRUE(file->WriteFully(&line[0], line.length()));
}
void GenerateProfile(const std::vector<std::string>& dexes,
File* out_file,
size_t method_frequency,
size_t type_frequency) {
ProfileCompilationInfo profile;
VisitDexes(
dexes,
[&profile](MethodReference ref) {
uint32_t flags = ProfileCompilationInfo::MethodHotness::kFlagHot |
ProfileCompilationInfo::MethodHotness::kFlagStartup;
EXPECT_TRUE(profile.AddMethod(
ProfileMethodInfo(ref),
static_cast<ProfileCompilationInfo::MethodHotness::Flag>(flags)));
},
[&profile](TypeReference ref) {
std::set<dex::TypeIndex> classes;
classes.insert(ref.TypeIndex());
EXPECT_TRUE(profile.AddClassesForDex(ref.dex_file, classes.begin(), classes.end()));
},
method_frequency,
type_frequency);
profile.Save(out_file->Fd());
EXPECT_EQ(out_file->Flush(), 0);
}
void GenerateMethods(File* out_file, size_t frequency = 1) {
VisitLibcoreDexes([out_file](MethodReference ref) {
WriteLine(out_file, ref.PrettyMethod());
}, VoidFunctor(), frequency, frequency);
EXPECT_EQ(out_file->Flush(), 0);
}
void AddRuntimeArg(std::vector<std::string>& args, const std::string& arg) {
args.push_back("--runtime-arg");
args.push_back(arg);
}
ImageSizes CompileImageAndGetSizes(ArrayRef<const std::string> dex_files,
const std::vector<std::string>& extra_args) {
ImageSizes ret;
ScratchFile scratch;
std::string scratch_dir = scratch.GetFilename();
while (!scratch_dir.empty() && scratch_dir.back() != '/') {
scratch_dir.pop_back();
}
CHECK(!scratch_dir.empty()) << "No directory " << scratch.GetFilename();
std::vector<std::string> local_extra_args = extra_args;
local_extra_args.push_back(android::base::StringPrintf("--base=0x%08x", kBaseAddress));
std::string error_msg;
if (!CompileBootImage(local_extra_args, scratch.GetFilename(), dex_files, &error_msg)) {
LOG(ERROR) << "Failed to compile image " << scratch.GetFilename() << error_msg;
}
std::string art_file = scratch.GetFilename() + ".art";
std::string oat_file = scratch.GetFilename() + ".oat";
std::string vdex_file = scratch.GetFilename() + ".vdex";
int64_t art_size = OS::GetFileSizeBytes(art_file.c_str());
int64_t oat_size = OS::GetFileSizeBytes(oat_file.c_str());
int64_t vdex_size = OS::GetFileSizeBytes(vdex_file.c_str());
CHECK_GT(art_size, 0u) << art_file;
CHECK_GT(oat_size, 0u) << oat_file;
CHECK_GT(vdex_size, 0u) << vdex_file;
ret.art_size = art_size;
ret.oat_size = oat_size;
ret.vdex_size = vdex_size;
scratch.Close();
// Clear image files since we compile the image multiple times and don't want to leave any
// artifacts behind.
ClearDirectory(scratch_dir.c_str(), /*recursive=*/ false);
return ret;
}
bool CompileBootImage(const std::vector<std::string>& extra_args,
const std::string& image_file_name_prefix,
ArrayRef<const std::string> dex_files,
std::string* error_msg,
const std::string& use_fd_prefix = "") {
Runtime* const runtime = Runtime::Current();
std::vector<std::string> argv;
argv.push_back(runtime->GetCompilerExecutable());
AddRuntimeArg(argv, "-Xms64m");
AddRuntimeArg(argv, "-Xmx64m");
for (const std::string& dex_file : dex_files) {
argv.push_back("--dex-file=" + dex_file);
argv.push_back("--dex-location=" + dex_file);
}
if (runtime->IsJavaDebuggable()) {
argv.push_back("--debuggable");
}
runtime->AddCurrentRuntimeFeaturesAsDex2OatArguments(&argv);
AddRuntimeArg(argv, "-Xverify:softfail");
if (!kIsTargetBuild) {
argv.push_back("--host");
}
std::unique_ptr<File> art_file;
std::unique_ptr<File> vdex_file;
std::unique_ptr<File> oat_file;
if (!use_fd_prefix.empty()) {
art_file.reset(OS::CreateEmptyFile((use_fd_prefix + ".art").c_str()));
vdex_file.reset(OS::CreateEmptyFile((use_fd_prefix + ".vdex").c_str()));
oat_file.reset(OS::CreateEmptyFile((use_fd_prefix + ".oat").c_str()));
argv.push_back("--image-fd=" + std::to_string(art_file->Fd()));
argv.push_back("--output-vdex-fd=" + std::to_string(vdex_file->Fd()));
argv.push_back("--oat-fd=" + std::to_string(oat_file->Fd()));
argv.push_back("--oat-location=" + image_file_name_prefix + ".oat");
} else {
argv.push_back("--image=" + image_file_name_prefix + ".art");
argv.push_back("--oat-file=" + image_file_name_prefix + ".oat");
argv.push_back("--oat-location=" + image_file_name_prefix + ".oat");
}
std::vector<std::string> compiler_options = runtime->GetCompilerOptions();
argv.insert(argv.end(), compiler_options.begin(), compiler_options.end());
// We must set --android-root.
const char* android_root = getenv("ANDROID_ROOT");
CHECK(android_root != nullptr);
argv.push_back("--android-root=" + std::string(android_root));
argv.insert(argv.end(), extra_args.begin(), extra_args.end());
bool result = RunDex2Oat(argv, error_msg);
if (art_file != nullptr) {
CHECK_EQ(0, art_file->FlushClose());
}
if (vdex_file != nullptr) {
CHECK_EQ(0, vdex_file->FlushClose());
}
if (oat_file != nullptr) {
CHECK_EQ(0, oat_file->FlushClose());
}
return result;
}
bool RunDex2Oat(const std::vector<std::string>& args, std::string* error_msg) {
// We only want fatal logging for the error message.
auto post_fork_fn = []() { return setenv("ANDROID_LOG_TAGS", "*:f", 1) == 0; };
ForkAndExecResult res = ForkAndExec(args, post_fork_fn, error_msg);
if (res.stage != ForkAndExecResult::kFinished) {
*error_msg = strerror(errno);
return false;
}
return res.StandardSuccess();
}
MemMap ReserveCoreImageAddressSpace(/*out*/std::string* error_msg) {
constexpr size_t kReservationSize = 256 * MB; // This should be enough for the compiled images.
// Extend to both directions for maximum relocation difference.
static_assert(ART_BASE_ADDRESS_MIN_DELTA < 0);
static_assert(ART_BASE_ADDRESS_MAX_DELTA > 0);
static_assert(IsAligned<kPageSize>(ART_BASE_ADDRESS_MIN_DELTA));
static_assert(IsAligned<kPageSize>(ART_BASE_ADDRESS_MAX_DELTA));
constexpr size_t kExtra = ART_BASE_ADDRESS_MAX_DELTA - ART_BASE_ADDRESS_MIN_DELTA;
uint32_t min_relocated_address = kBaseAddress + ART_BASE_ADDRESS_MIN_DELTA;
return MemMap::MapAnonymous("Reservation",
reinterpret_cast<uint8_t*>(min_relocated_address),
kReservationSize + kExtra,
PROT_NONE,
/*low_4gb=*/ true,
/*reuse=*/ false,
/*reservation=*/ nullptr,
error_msg);
}
void CopyDexFiles(const std::string& dir, /*inout*/std::vector<std::string>* dex_files) {
CHECK(EndsWith(dir, "/"));
for (std::string& dex_file : *dex_files) {
size_t slash_pos = dex_file.rfind('/');
CHECK_NE(std::string::npos, slash_pos);
std::string new_location = dir + dex_file.substr(slash_pos + 1u);
std::ifstream src_stream(dex_file, std::ios::binary);
std::ofstream dst_stream(new_location, std::ios::binary);
dst_stream << src_stream.rdbuf();
dex_file = new_location;
}
}
bool CompareFiles(const std::string& filename1, const std::string& filename2) {
std::unique_ptr<File> file1(OS::OpenFileForReading(filename1.c_str()));
std::unique_ptr<File> file2(OS::OpenFileForReading(filename2.c_str()));
// Did we open the files?
if (file1 == nullptr || file2 == nullptr) {
return false;
}
// Are they non-empty and the same length?
if (file1->GetLength() <= 0 || file2->GetLength() != file1->GetLength()) {
return false;
}
return file1->Compare(file2.get()) == 0;
}
};
TEST_F(Dex2oatImageTest, TestModesAndFilters) {
// This test crashes on the gtest-heap-poisoning configuration
// (AddressSanitizer + CMS/RosAlloc + heap-poisoning); see b/111061592.
// Temporarily disable this test on this configuration to keep
// our automated build/testing green while we work on a fix.
TEST_DISABLED_FOR_MEMORY_TOOL_WITH_HEAP_POISONING_WITHOUT_READ_BARRIERS();
if (kIsTargetBuild) {
// This test is too slow for target builds.
return;
}
// Compile only a subset of the libcore dex files to make this test shorter.
std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames();
// The primary image must contain at least core-oj and core-libart to initialize the runtime
// and we also need the core-icu4j if we want to compile these with full profile.
ASSERT_NE(std::string::npos, libcore_dex_files[0].find("core-oj"));
ASSERT_NE(std::string::npos, libcore_dex_files[1].find("core-libart"));
ASSERT_NE(std::string::npos, libcore_dex_files[2].find("core-icu4j"));
ArrayRef<const std::string> dex_files =
ArrayRef<const std::string>(libcore_dex_files).SubArray(/*pos=*/ 0u, /*length=*/ 3u);
ImageSizes base_sizes = CompileImageAndGetSizes(dex_files, {});
ImageSizes everything_sizes;
ImageSizes filter_sizes;
std::cout << "Base compile sizes " << base_sizes << std::endl;
// Compile all methods and classes
{
ScratchFile profile_file;
GenerateProfile(GetLibCoreDexFileNames(),
profile_file.GetFile(),
/*method_frequency=*/ 1u,
/*type_frequency=*/ 1u);
everything_sizes = CompileImageAndGetSizes(
dex_files,
{"--profile-file=" + profile_file.GetFilename(),
"--compiler-filter=speed-profile"});
profile_file.Close();
std::cout << "All methods and classes sizes " << everything_sizes << std::endl;
// Putting all classes as image classes should increase art size
EXPECT_GE(everything_sizes.art_size, base_sizes.art_size);
// Sanity check that dex is the same size.
EXPECT_EQ(everything_sizes.vdex_size, base_sizes.vdex_size);
}
static size_t kMethodFrequency = 3;
static size_t kTypeFrequency = 4;
// Test compiling fewer methods and classes.
{
ScratchFile profile_file;
GenerateProfile(GetLibCoreDexFileNames(),
profile_file.GetFile(),
kMethodFrequency,
kTypeFrequency);
filter_sizes = CompileImageAndGetSizes(
dex_files,
{"--profile-file=" + profile_file.GetFilename(),
"--compiler-filter=speed-profile"});
profile_file.Close();
std::cout << "Fewer methods and classes sizes " << filter_sizes << std::endl;
EXPECT_LE(filter_sizes.art_size, everything_sizes.art_size);
EXPECT_LE(filter_sizes.oat_size, everything_sizes.oat_size);
EXPECT_LE(filter_sizes.vdex_size, everything_sizes.vdex_size);
}
// Test dirty image objects.
{
ScratchFile classes;
VisitLibcoreDexes(VoidFunctor(),
[&](TypeReference ref) {
WriteLine(classes.GetFile(), ref.dex_file->PrettyType(ref.TypeIndex()));
}, /*method_frequency=*/ 1u, /*class_frequency=*/ 1u);
ImageSizes image_classes_sizes = CompileImageAndGetSizes(
dex_files,
{"--dirty-image-objects=" + classes.GetFilename()});
classes.Close();
std::cout << "Dirty image object sizes " << image_classes_sizes << std::endl;
}
}
TEST_F(Dex2oatImageTest, TestExtension) {
std::string error_msg;
MemMap reservation = ReserveCoreImageAddressSpace(&error_msg);
ASSERT_TRUE(reservation.IsValid()) << error_msg;
ScratchFile scratch;
std::string scratch_dir = scratch.GetFilename() + "-d";
int mkdir_result = mkdir(scratch_dir.c_str(), 0700);
ASSERT_EQ(0, mkdir_result);
scratch_dir += '/';
std::string image_dir = scratch_dir + GetInstructionSetString(kRuntimeISA);
mkdir_result = mkdir(image_dir.c_str(), 0700);
ASSERT_EQ(0, mkdir_result);
std::string filename_prefix = image_dir + "/core";
// Copy the libcore dex files to a custom dir inside `scratch_dir` so that we do not
// accidentally load pre-compiled core images from their original directory based on BCP paths.
std::string jar_dir = scratch_dir + "jars";
mkdir_result = mkdir(jar_dir.c_str(), 0700);
ASSERT_EQ(0, mkdir_result);
jar_dir += '/';
std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames();
CopyDexFiles(jar_dir, &libcore_dex_files);
// Create a profile.
ScratchFile profile_file;
GenerateProfile(libcore_dex_files,
profile_file.GetFile(),
/*method_frequency=*/ 1u,
/*type_frequency=*/ 1u);
std::vector<std::string> extra_args;
extra_args.push_back("--profile-file=" + profile_file.GetFilename());
ArrayRef<const std::string> full_bcp(libcore_dex_files);
size_t total_dex_files = full_bcp.size();
ASSERT_GE(total_dex_files, 5u); // 3 for "head", 1 for "tail", at least one for "mid", see below.
// The primary image must contain at least core-oj and core-libart to initialize the runtime
// and we also need the core-icu4j if we want to compile these with full profile.
ASSERT_NE(std::string::npos, full_bcp[0].find("core-oj"));
ASSERT_NE(std::string::npos, full_bcp[1].find("core-libart"));
ASSERT_NE(std::string::npos, full_bcp[2].find("core-icu4j"));
ArrayRef<const std::string> head_dex_files = full_bcp.SubArray(/*pos=*/ 0u, /*length=*/ 3u);
// Middle part is everything else except for conscrypt.
ASSERT_NE(std::string::npos, full_bcp[full_bcp.size() - 1u].find("conscrypt"));
ArrayRef<const std::string> mid_bcp =
full_bcp.SubArray(/*pos=*/ 0u, /*length=*/ total_dex_files - 1u);
ArrayRef<const std::string> mid_dex_files = mid_bcp.SubArray(/*pos=*/ 3u);
// Tail is just the conscrypt.
ArrayRef<const std::string> tail_dex_files =
full_bcp.SubArray(/*pos=*/ total_dex_files - 1u, /*length=*/ 1u);
// Prepare the "head", "mid" and "tail" names and locations.
std::string base_name = "core.art";
std::string base_location = scratch_dir + base_name;
std::vector<std::string> expanded_mid = gc::space::ImageSpace::ExpandMultiImageLocations(
mid_dex_files.SubArray(/*pos=*/ 0u, /*length=*/ 1u),
base_location,
/*boot_image_extension=*/ true);
CHECK_EQ(1u, expanded_mid.size());
std::string mid_location = expanded_mid[0];
size_t mid_slash_pos = mid_location.rfind('/');
ASSERT_NE(std::string::npos, mid_slash_pos);
std::string mid_name = mid_location.substr(mid_slash_pos + 1u);
CHECK_EQ(1u, tail_dex_files.size());
std::vector<std::string> expanded_tail = gc::space::ImageSpace::ExpandMultiImageLocations(
tail_dex_files, base_location, /*boot_image_extension=*/ true);
CHECK_EQ(1u, expanded_tail.size());
std::string tail_location = expanded_tail[0];
size_t tail_slash_pos = tail_location.rfind('/');
ASSERT_NE(std::string::npos, tail_slash_pos);
std::string tail_name = tail_location.substr(tail_slash_pos + 1u);
// Compile the "head", i.e. the primary boot image.
extra_args.push_back(android::base::StringPrintf("--base=0x%08x", kBaseAddress));
bool head_ok = CompileBootImage(extra_args, filename_prefix, head_dex_files, &error_msg);
ASSERT_TRUE(head_ok) << error_msg;
extra_args.pop_back();
// Compile the "mid", i.e. the first extension.
std::string mid_bcp_string = android::base::Join(mid_bcp, ':');
AddRuntimeArg(extra_args, "-Xbootclasspath:" + mid_bcp_string);
AddRuntimeArg(extra_args, "-Xbootclasspath-locations:" + mid_bcp_string);
extra_args.push_back("--boot-image=" + base_location);
bool mid_ok = CompileBootImage(extra_args, filename_prefix, mid_dex_files, &error_msg);
ASSERT_TRUE(mid_ok) << error_msg;
extra_args.resize(extra_args.size() - 3u);
// Try to compile the "tail" without specifying the "mid" extension. This shall fail.
std::string full_bcp_string = android::base::Join(full_bcp, ':');
AddRuntimeArg(extra_args, "-Xbootclasspath:" + full_bcp_string);
AddRuntimeArg(extra_args, "-Xbootclasspath-locations:" + full_bcp_string);
extra_args.push_back("--boot-image=" + base_location);
bool tail_ok = CompileBootImage(extra_args, filename_prefix, tail_dex_files, &error_msg);
ASSERT_FALSE(tail_ok) << error_msg;
// Now compile the tail against both "head" and "mid".
CHECK(StartsWith(extra_args.back(), "--boot-image="));
extra_args.back() = "--boot-image=" + base_location + ':' + mid_location;
tail_ok = CompileBootImage(extra_args, filename_prefix, tail_dex_files, &error_msg);
ASSERT_TRUE(tail_ok) << error_msg;
// Prepare directory for the single-image test that squashes the "mid" and "tail".
std::string single_dir = scratch_dir + "single";
mkdir_result = mkdir(single_dir.c_str(), 0700);
ASSERT_EQ(0, mkdir_result);
single_dir += '/';
std::string single_image_dir = single_dir + GetInstructionSetString(kRuntimeISA);
mkdir_result = mkdir(single_image_dir.c_str(), 0700);
ASSERT_EQ(0, mkdir_result);
std::string single_filename_prefix = single_image_dir + "/core";
// Create a smaller profile for the single-image test that squashes the "mid" and "tail".
ScratchFile single_profile_file;
GenerateProfile(libcore_dex_files,
single_profile_file.GetFile(),
/*method_frequency=*/ 5u,
/*type_frequency=*/ 4u);
extra_args.clear();
extra_args.push_back("--profile-file=" + single_profile_file.GetFilename());
// The dex files for the single-image are everything not in the "head".
ArrayRef<const std::string> single_dex_files = full_bcp.SubArray(/*pos=*/ head_dex_files.size());
// Prepare the single image name and location.
CHECK_GE(single_dex_files.size(), 2u);
std::string single_base_location = single_dir + base_name;
std::vector<std::string> expanded_single = gc::space::ImageSpace::ExpandMultiImageLocations(
single_dex_files.SubArray(/*pos=*/ 0u, /*length=*/ 1u),
single_base_location,
/*boot_image_extension=*/ true);
CHECK_EQ(1u, expanded_single.size());
std::string single_location = expanded_single[0];
size_t single_slash_pos = single_location.rfind('/');
ASSERT_NE(std::string::npos, single_slash_pos);
std::string single_name = single_location.substr(single_slash_pos + 1u);
CHECK_EQ(single_name, mid_name);
// Compile the single-image against the primary boot image.
AddRuntimeArg(extra_args, "-Xbootclasspath:" + full_bcp_string);
AddRuntimeArg(extra_args, "-Xbootclasspath-locations:" + full_bcp_string);
extra_args.push_back("--boot-image=" + base_location);
extra_args.push_back("--single-image");
extra_args.push_back("--avoid-storing-invocation"); // For comparison below.
error_msg.clear();
bool single_ok =
CompileBootImage(extra_args, single_filename_prefix, single_dex_files, &error_msg);
ASSERT_TRUE(single_ok) << error_msg;
reservation = MemMap::Invalid(); // Free the reserved memory for loading images.
// Try to load the boot image with different image locations.
std::vector<std::string> boot_class_path = libcore_dex_files;
std::vector<std::unique_ptr<gc::space::ImageSpace>> boot_image_spaces;
bool relocate = false;
MemMap extra_reservation;
auto load = [&](const std::string& image_location) {
boot_image_spaces.clear();
extra_reservation = MemMap::Invalid();
ScopedObjectAccess soa(Thread::Current());
return gc::space::ImageSpace::LoadBootImage(/*boot_class_path=*/ boot_class_path,
/*boot_class_path_locations=*/ libcore_dex_files,
image_location,
kRuntimeISA,
gc::space::ImageSpaceLoadingOrder::kSystemFirst,
relocate,
/*executable=*/ true,
/*is_zygote=*/ false,
/*extra_reservation_size=*/ 0u,
&boot_image_spaces,
&extra_reservation);
};
auto silent_load = [&](const std::string& image_location) {
ScopedLogSeverity quiet(LogSeverity::FATAL);
return load(image_location);
};
for (bool r : { false, true }) {
relocate = r;
// Load primary image with full path.
bool load_ok = load(base_location);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_FALSE(extra_reservation.IsValid());
ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
// Fail to load primary image with just the name.
load_ok = silent_load(base_name);
ASSERT_FALSE(load_ok);
// Fail to load primary image with a search path.
load_ok = silent_load("*");
ASSERT_FALSE(load_ok);
load_ok = silent_load(scratch_dir + "*");
ASSERT_FALSE(load_ok);
// Load the primary and first extension with full path.
load_ok = load(base_location + ':' + mid_location);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
// Load the primary with full path and fail to load first extension without full path.
load_ok = load(base_location + ':' + mid_name);
ASSERT_TRUE(load_ok) << error_msg; // Primary image loaded successfully.
ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size()); // But only the primary image.
// Load all the libcore images with full paths.
load_ok = load(base_location + ':' + mid_location + ':' + tail_location);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
// Load the primary and first extension with full paths, fail to load second extension by name.
load_ok = load(base_location + ':' + mid_location + ':' + tail_name);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
// Load the primary with full path and fail to load first extension without full path,
// fail to load second extension because it depends on the first.
load_ok = load(base_location + ':' + mid_name + ':' + tail_location);
ASSERT_TRUE(load_ok) << error_msg; // Primary image loaded successfully.
ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size()); // But only the primary image.
// Load the primary with full path and extensions with a specified search path.
load_ok = load(base_location + ':' + scratch_dir + '*');
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
// Load the primary with full path and fail to find extensions in BCP path.
load_ok = load(base_location + ":*");
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(head_dex_files.size(), boot_image_spaces.size());
}
// Now copy the libcore dex files to the `scratch_dir` and retry loading the boot image
// with BCP in the scratch_dir so that the images can be found based on BCP paths.
CopyDexFiles(scratch_dir, &boot_class_path);
for (bool r : { false, true }) {
relocate = r;
// Loading the primary image with just the name now succeeds.
bool load_ok = load(base_name);
ASSERT_TRUE(load_ok) << error_msg;
// Loading the primary image with a search path still fails.
load_ok = silent_load("*");
ASSERT_FALSE(load_ok);
load_ok = silent_load(scratch_dir + "*");
ASSERT_FALSE(load_ok);
// Load the primary and first extension without paths.
load_ok = load(base_name + ':' + mid_name);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size());
// Load the primary with full path and the first extension without full path.
load_ok = load(base_location + ':' + mid_name);
ASSERT_TRUE(load_ok) << error_msg; // Loaded successfully.
ASSERT_EQ(mid_bcp.size(), boot_image_spaces.size()); // Including the extension.
// Load all the libcore images without paths.
load_ok = load(base_name + ':' + mid_name + ':' + tail_name);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
// Load the primary and first extension with full paths and second extension by name.
load_ok = load(base_location + ':' + mid_location + ':' + tail_name);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
// Load the primary with full path, first extension without path,
// and second extension with full path.
load_ok = load(base_location + ':' + mid_name + ':' + tail_location);
ASSERT_TRUE(load_ok) << error_msg; // Loaded successfully.
ASSERT_EQ(full_bcp.size(), boot_image_spaces.size()); // Including both extensions.
// Load the primary with full path and find both extensions in BCP path.
load_ok = load(base_location + ":*");
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(full_bcp.size(), boot_image_spaces.size());
// Fail to load any images with invalid image locations (named component after search paths).
load_ok = silent_load(base_location + ":*:" + tail_location);
ASSERT_FALSE(load_ok);
load_ok = silent_load(base_location + ':' + scratch_dir + "*:" + tail_location);
ASSERT_FALSE(load_ok);
// Load the primary and single-image extension with full path.
load_ok = load(base_location + ':' + single_location);
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(head_dex_files.size() + 1u, boot_image_spaces.size());
// Load the primary with full path and single-image extension with a specified search path.
load_ok = load(base_location + ':' + single_dir + '*');
ASSERT_TRUE(load_ok) << error_msg;
ASSERT_EQ(head_dex_files.size() + 1u, boot_image_spaces.size());
}
// Recompile the single-image extension using file descriptors and compare contents.
std::vector<std::string> expanded_single_filename_prefix =
gc::space::ImageSpace::ExpandMultiImageLocations(
single_dex_files.SubArray(/*pos=*/ 0u, /*length=*/ 1u),
single_filename_prefix,
/*boot_image_extension=*/ true);
CHECK_EQ(1u, expanded_single_filename_prefix.size());
std::string single_ext_prefix = expanded_single_filename_prefix[0];
std::string single_ext_prefix2 = single_ext_prefix + "2";
error_msg.clear();
single_ok = CompileBootImage(extra_args,
single_filename_prefix,
single_dex_files,
&error_msg,
/*use_fd_prefix=*/ single_ext_prefix2);
ASSERT_TRUE(single_ok) << error_msg;
EXPECT_TRUE(CompareFiles(single_ext_prefix + ".art", single_ext_prefix2 + ".art"));
EXPECT_TRUE(CompareFiles(single_ext_prefix + ".vdex", single_ext_prefix2 + ".vdex"));
EXPECT_TRUE(CompareFiles(single_ext_prefix + ".oat", single_ext_prefix2 + ".oat"));
ClearDirectory(scratch_dir.c_str());
int rmdir_result = rmdir(scratch_dir.c_str());
ASSERT_EQ(0, rmdir_result);
}
} // namespace art