/* * 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 "dexopt_test.h" #include <gtest/gtest.h> #include <procinfo/process_map.h> #include <string> #include <vector> #include "android-base/stringprintf.h" #include "android-base/strings.h" #include "arch/instruction_set.h" #include "base/file_utils.h" #include "base/mem_map.h" #include "common_runtime_test.h" #include "compiler_callbacks.h" #include "dex/art_dex_file_loader.h" #include "dex/dex_file_loader.h" #include "dex2oat_environment_test.h" #include "gc/space/image_space.h" #include "hidden_api.h" #include "oat/oat.h" #include "oat/oat_file_assistant.h" #include "profile/profile_compilation_info.h" namespace art HIDDEN { void DexoptTest::SetUp() { ReserveImageSpace(); Dex2oatEnvironmentTest::SetUp(); } void DexoptTest::PreRuntimeCreate() { std::string error_msg; UnreserveImageSpace(); } void DexoptTest::PostRuntimeCreate() { ReserveImageSpace(); } bool DexoptTest::Dex2Oat(const std::vector<std::string>& args, std::string* error_msg) { std::vector<std::string> argv; if (!CommonRuntimeTest::StartDex2OatCommandLine(&argv, error_msg)) { return false; } Runtime* runtime = Runtime::Current(); if (runtime->GetHiddenApiEnforcementPolicy() == hiddenapi::EnforcementPolicy::kEnabled) { argv.push_back("--runtime-arg"); argv.push_back("-Xhidden-api-policy:enabled"); } if (!kIsTargetBuild) { argv.push_back("--host"); } argv.insert(argv.end(), args.begin(), args.end()); std::string command_line(android::base::Join(argv, ' ')); return Exec(argv, error_msg); } std::string DexoptTest::GenerateAlternateImage(const std::string& scratch_dir) { std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames(); std::vector<std::string> libcore_dex_locations = GetLibCoreDexLocations(); std::string image_dir = scratch_dir + GetInstructionSetString(kRuntimeISA); int mkdir_result = mkdir(image_dir.c_str(), 0700); CHECK_EQ(0, mkdir_result) << image_dir.c_str(); std::vector<std::string> extra_args{ "--compiler-filter=verify", android::base::StringPrintf("--base=0x%08x", ART_BASE_ADDRESS), }; std::string filename_prefix = image_dir + "/boot-interpreter"; ArrayRef<const std::string> dex_files(libcore_dex_files); ArrayRef<const std::string> dex_locations(libcore_dex_locations); std::string error_msg; bool ok = CompileBootImage(extra_args, filename_prefix, dex_files, dex_locations, &error_msg); EXPECT_TRUE(ok) << error_msg; return scratch_dir + "boot-interpreter.art"; } void DexoptTest::GenerateOatForTest(const std::string& dex_location, const std::string& oat_location, CompilerFilter::Filter filter, bool with_alternate_image, const char* compilation_reason, const std::vector<std::string>& extra_args) { std::vector<std::string> args; args.push_back("--dex-file=" + dex_location); args.push_back("--oat-file=" + oat_location); args.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(filter)); args.push_back("--runtime-arg"); // Use -Xnorelocate regardless of the relocate argument. // We control relocation by redirecting the dalvik cache when needed // rather than use this flag. args.push_back("-Xnorelocate"); ScratchFile profile_file; if (CompilerFilter::DependsOnProfile(filter)) { // Create a profile with some basic content so that dex2oat // doesn't get an empty profile and changes the filter to verify. std::string error_msg; std::vector<std::unique_ptr<const DexFile>> dex_files; ArtDexFileLoader dex_file_loader(dex_location); ASSERT_TRUE(dex_file_loader.Open( /*verify=*/false, /*verify_checksum=*/false, &error_msg, &dex_files)); EXPECT_GE(dex_files.size(), 1U); std::unique_ptr<const DexFile>& dex_file = dex_files[0]; ProfileCompilationInfo info; info.AddClass(*dex_file, dex::TypeIndex(0)); ASSERT_TRUE(info.Save(profile_file.GetFd())); ASSERT_EQ(0, profile_file.GetFile()->Flush()); // Set the argument args.push_back("--profile-file=" + profile_file.GetFilename()); } std::string image_location = GetImageLocation(); std::optional<ScratchDir> scratch; if (with_alternate_image) { scratch.emplace(); // Create the scratch directory for the generated boot image. std::string alternate_image_location = GenerateAlternateImage(scratch->GetPath()); args.push_back("--boot-image=" + alternate_image_location); } if (compilation_reason != nullptr) { args.push_back("--compilation-reason=" + std::string(compilation_reason)); } args.insert(args.end(), extra_args.begin(), extra_args.end()); std::string error_msg; ASSERT_TRUE(Dex2Oat(args, &error_msg)) << error_msg; // Verify the odex file was generated as expected. std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, oat_location, oat_location, /*executable=*/false, /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file.get() != nullptr) << error_msg; EXPECT_EQ(filter, odex_file->GetCompilerFilter()); if (CompilerFilter::DependsOnImageChecksum(filter)) { std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(/*spec=*/""); OatFileAssistant oat_file_assistant(dex_location.c_str(), kRuntimeISA, context.get(), /*load_executable=*/false); bool match = oat_file_assistant.ValidateBootClassPathChecksums(*odex_file); ASSERT_EQ(!with_alternate_image, match) << error_msg; } } void DexoptTest::GenerateOdexForTest(const std::string& dex_location, const std::string& odex_location, CompilerFilter::Filter filter, const char* compilation_reason, const std::vector<std::string>& extra_args) { GenerateOatForTest(dex_location, odex_location, filter, /*with_alternate_image=*/false, compilation_reason, extra_args); } void DexoptTest::GenerateOatForTest(const char* dex_location, CompilerFilter::Filter filter, bool with_alternate_image) { std::string oat_location; std::string error_msg; ASSERT_TRUE(OatFileAssistant::DexLocationToOatFilename( dex_location, kRuntimeISA, &oat_location, &error_msg)) << error_msg; GenerateOatForTest(dex_location, oat_location, filter, with_alternate_image); } void DexoptTest::GenerateOatForTest(const char* dex_location, CompilerFilter::Filter filter) { GenerateOatForTest(dex_location, filter, /*with_alternate_image=*/false); } void DexoptTest::ReserveImageSpace() { MemMap::Init(); // Ensure a chunk of memory is reserved for the image space. uint64_t reservation_start = ART_BASE_ADDRESS; uint64_t reservation_end = ART_BASE_ADDRESS + 384 * MB; std::vector<android::procinfo::MapInfo> maps; ASSERT_TRUE(android::procinfo::ReadProcessMaps(getpid(), &maps)); for (const android::procinfo::MapInfo& map_info : maps) { ReserveImageSpaceChunk(reservation_start, std::min(map_info.start, reservation_end)); reservation_start = std::max(reservation_start, map_info.end); if (reservation_start >= reservation_end) { break; } } ReserveImageSpaceChunk(reservation_start, reservation_end); } void DexoptTest::ReserveImageSpaceChunk(uintptr_t start, uintptr_t end) { if (start < end) { std::string error_msg; image_reservation_.push_back(MemMap::MapAnonymous("image reservation", reinterpret_cast<uint8_t*>(start), end - start, PROT_NONE, /*low_4gb=*/false, /*reuse=*/false, /*reservation=*/nullptr, &error_msg)); ASSERT_TRUE(image_reservation_.back().IsValid()) << error_msg; LOG(INFO) << "Reserved space for image " << reinterpret_cast<void*>(image_reservation_.back().Begin()) << "-" << reinterpret_cast<void*>(image_reservation_.back().End()); } } void DexoptTest::UnreserveImageSpace() { image_reservation_.clear(); } } // namespace art