You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
393 lines
16 KiB
393 lines
16 KiB
/*
|
|
* Copyright (C) 2011 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.
|
|
*/
|
|
|
|
#ifndef ART_DEX2OAT_LINKER_IMAGE_TEST_H_
|
|
#define ART_DEX2OAT_LINKER_IMAGE_TEST_H_
|
|
|
|
#include "image.h"
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include "android-base/stringprintf.h"
|
|
#include "android-base/strings.h"
|
|
|
|
#include "art_method-inl.h"
|
|
#include "base/file_utils.h"
|
|
#include "base/hash_set.h"
|
|
#include "base/stl_util.h"
|
|
#include "base/unix_file/fd_file.h"
|
|
#include "base/utils.h"
|
|
#include "class_linker-inl.h"
|
|
#include "common_compiler_driver_test.h"
|
|
#include "compiler_callbacks.h"
|
|
#include "debug/method_debug_info.h"
|
|
#include "dex/quick_compiler_callbacks.h"
|
|
#include "dex/signature-inl.h"
|
|
#include "driver/compiler_driver.h"
|
|
#include "driver/compiler_options.h"
|
|
#include "gc/space/image_space.h"
|
|
#include "image_writer.h"
|
|
#include "linker/elf_writer.h"
|
|
#include "linker/elf_writer_quick.h"
|
|
#include "linker/multi_oat_relative_patcher.h"
|
|
#include "lock_word.h"
|
|
#include "mirror/object-inl.h"
|
|
#include "oat.h"
|
|
#include "oat_writer.h"
|
|
#include "scoped_thread_state_change-inl.h"
|
|
#include "signal_catcher.h"
|
|
#include "stream/buffered_output_stream.h"
|
|
#include "stream/file_output_stream.h"
|
|
|
|
namespace art {
|
|
namespace linker {
|
|
|
|
static const uintptr_t kRequestedImageBase = ART_BASE_ADDRESS;
|
|
|
|
struct CompilationHelper {
|
|
std::vector<std::string> dex_file_locations;
|
|
std::vector<ScratchFile> image_locations;
|
|
std::vector<std::unique_ptr<const DexFile>> extra_dex_files;
|
|
std::vector<ScratchFile> image_files;
|
|
std::vector<ScratchFile> oat_files;
|
|
std::vector<ScratchFile> vdex_files;
|
|
std::string image_dir;
|
|
|
|
std::vector<size_t> GetImageObjectSectionSizes();
|
|
|
|
~CompilationHelper();
|
|
};
|
|
|
|
class ImageTest : public CommonCompilerDriverTest {
|
|
protected:
|
|
void SetUp() override {
|
|
ReserveImageSpace();
|
|
CommonCompilerTest::SetUp();
|
|
}
|
|
|
|
void Compile(ImageHeader::StorageMode storage_mode,
|
|
uint32_t max_image_block_size,
|
|
/*out*/ CompilationHelper& out_helper,
|
|
const std::string& extra_dex = "",
|
|
const std::initializer_list<std::string>& image_classes = {},
|
|
const std::initializer_list<std::string>& image_classes_failing_aot_clinit = {});
|
|
|
|
void SetUpRuntimeOptions(RuntimeOptions* options) override {
|
|
CommonCompilerTest::SetUpRuntimeOptions(options);
|
|
QuickCompilerCallbacks* new_callbacks =
|
|
new QuickCompilerCallbacks(CompilerCallbacks::CallbackMode::kCompileBootImage);
|
|
new_callbacks->SetVerificationResults(verification_results_.get());
|
|
callbacks_.reset(new_callbacks);
|
|
options->push_back(std::make_pair("compilercallbacks", callbacks_.get()));
|
|
}
|
|
|
|
std::unique_ptr<HashSet<std::string>> GetImageClasses() override {
|
|
return std::make_unique<HashSet<std::string>>(image_classes_);
|
|
}
|
|
|
|
ArtMethod* FindCopiedMethod(ArtMethod* origin, ObjPtr<mirror::Class> klass)
|
|
REQUIRES_SHARED(Locks::mutator_lock_) {
|
|
PointerSize pointer_size = class_linker_->GetImagePointerSize();
|
|
for (ArtMethod& m : klass->GetCopiedMethods(pointer_size)) {
|
|
if (strcmp(origin->GetName(), m.GetName()) == 0 &&
|
|
origin->GetSignature() == m.GetSignature()) {
|
|
return &m;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
private:
|
|
void DoCompile(ImageHeader::StorageMode storage_mode, /*out*/ CompilationHelper& out_helper);
|
|
|
|
HashSet<std::string> image_classes_;
|
|
};
|
|
|
|
inline CompilationHelper::~CompilationHelper() {
|
|
for (ScratchFile& image_file : image_files) {
|
|
image_file.Unlink();
|
|
}
|
|
for (ScratchFile& oat_file : oat_files) {
|
|
oat_file.Unlink();
|
|
}
|
|
for (ScratchFile& vdex_file : vdex_files) {
|
|
vdex_file.Unlink();
|
|
}
|
|
const int rmdir_result = rmdir(image_dir.c_str());
|
|
CHECK_EQ(0, rmdir_result);
|
|
}
|
|
|
|
inline std::vector<size_t> CompilationHelper::GetImageObjectSectionSizes() {
|
|
std::vector<size_t> ret;
|
|
for (ScratchFile& image_file : image_files) {
|
|
std::unique_ptr<File> file(OS::OpenFileForReading(image_file.GetFilename().c_str()));
|
|
CHECK(file.get() != nullptr);
|
|
ImageHeader image_header;
|
|
CHECK_EQ(file->ReadFully(&image_header, sizeof(image_header)), true);
|
|
CHECK(image_header.IsValid());
|
|
ret.push_back(image_header.GetObjectsSection().Size());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
inline void ImageTest::DoCompile(ImageHeader::StorageMode storage_mode,
|
|
/*out*/ CompilationHelper& out_helper) {
|
|
CompilerDriver* driver = compiler_driver_.get();
|
|
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
|
|
std::vector<const DexFile*> class_path = class_linker->GetBootClassPath();
|
|
|
|
for (const std::unique_ptr<const DexFile>& dex_file : out_helper.extra_dex_files) {
|
|
{
|
|
ScopedObjectAccess soa(Thread::Current());
|
|
// Inject in boot class path so that the compiler driver can see it.
|
|
class_linker->AppendToBootClassPath(soa.Self(), dex_file.get());
|
|
}
|
|
class_path.push_back(dex_file.get());
|
|
}
|
|
|
|
// Enable write for dex2dex.
|
|
for (const DexFile* dex_file : class_path) {
|
|
out_helper.dex_file_locations.push_back(dex_file->GetLocation());
|
|
if (dex_file->IsReadOnly()) {
|
|
dex_file->EnableWrite();
|
|
}
|
|
}
|
|
{
|
|
// Create a generic tmp file, to be the base of the .art and .oat temporary files.
|
|
ScratchFile location;
|
|
std::vector<std::string> image_locations =
|
|
gc::space::ImageSpace::ExpandMultiImageLocations(
|
|
ArrayRef<const std::string>(out_helper.dex_file_locations),
|
|
location.GetFilename() + ".art");
|
|
for (size_t i = 0u; i != class_path.size(); ++i) {
|
|
out_helper.image_locations.push_back(ScratchFile(image_locations[i]));
|
|
}
|
|
}
|
|
std::vector<std::string> image_filenames;
|
|
for (ScratchFile& file : out_helper.image_locations) {
|
|
std::string image_filename(GetSystemImageFilename(file.GetFilename().c_str(), kRuntimeISA));
|
|
image_filenames.push_back(image_filename);
|
|
size_t pos = image_filename.rfind('/');
|
|
CHECK_NE(pos, std::string::npos) << image_filename;
|
|
if (out_helper.image_dir.empty()) {
|
|
out_helper.image_dir = image_filename.substr(0, pos);
|
|
int mkdir_result = mkdir(out_helper.image_dir.c_str(), 0700);
|
|
CHECK_EQ(0, mkdir_result) << out_helper.image_dir;
|
|
}
|
|
out_helper.image_files.push_back(ScratchFile(OS::CreateEmptyFile(image_filename.c_str())));
|
|
}
|
|
|
|
std::vector<std::string> oat_filenames;
|
|
std::vector<std::string> vdex_filenames;
|
|
for (const std::string& image_filename : image_filenames) {
|
|
std::string oat_filename = ReplaceFileExtension(image_filename, "oat");
|
|
out_helper.oat_files.push_back(ScratchFile(OS::CreateEmptyFile(oat_filename.c_str())));
|
|
oat_filenames.push_back(oat_filename);
|
|
std::string vdex_filename = ReplaceFileExtension(image_filename, "vdex");
|
|
out_helper.vdex_files.push_back(ScratchFile(OS::CreateEmptyFile(vdex_filename.c_str())));
|
|
vdex_filenames.push_back(vdex_filename);
|
|
}
|
|
|
|
HashMap<const DexFile*, size_t> dex_file_to_oat_index_map;
|
|
size_t image_idx = 0;
|
|
for (const DexFile* dex_file : class_path) {
|
|
dex_file_to_oat_index_map.insert(std::make_pair(dex_file, image_idx));
|
|
++image_idx;
|
|
}
|
|
std::unique_ptr<ImageWriter> writer(new ImageWriter(*compiler_options_,
|
|
kRequestedImageBase,
|
|
storage_mode,
|
|
oat_filenames,
|
|
dex_file_to_oat_index_map,
|
|
/*class_loader=*/ nullptr,
|
|
/*dirty_image_objects=*/ nullptr));
|
|
{
|
|
{
|
|
jobject class_loader = nullptr;
|
|
TimingLogger timings("ImageTest::WriteRead", false, false);
|
|
CompileAll(class_loader, class_path, &timings);
|
|
|
|
TimingLogger::ScopedTiming t("WriteElf", &timings);
|
|
SafeMap<std::string, std::string> key_value_store;
|
|
key_value_store.Put(OatHeader::kBootClassPathKey,
|
|
android::base::Join(out_helper.dex_file_locations, ':'));
|
|
|
|
std::vector<std::unique_ptr<ElfWriter>> elf_writers;
|
|
std::vector<std::unique_ptr<OatWriter>> oat_writers;
|
|
for (ScratchFile& oat_file : out_helper.oat_files) {
|
|
elf_writers.emplace_back(CreateElfWriterQuick(*compiler_options_, oat_file.GetFile()));
|
|
elf_writers.back()->Start();
|
|
oat_writers.emplace_back(new OatWriter(*compiler_options_,
|
|
&timings,
|
|
/*profile_compilation_info*/nullptr,
|
|
CompactDexLevel::kCompactDexLevelNone));
|
|
}
|
|
|
|
std::vector<OutputStream*> rodata;
|
|
std::vector<MemMap> opened_dex_files_maps;
|
|
std::vector<std::unique_ptr<const DexFile>> opened_dex_files;
|
|
// Now that we have finalized key_value_store_, start writing the oat file.
|
|
for (size_t i = 0, size = oat_writers.size(); i != size; ++i) {
|
|
const DexFile* dex_file = class_path[i];
|
|
rodata.push_back(elf_writers[i]->StartRoData());
|
|
ArrayRef<const uint8_t> raw_dex_file(
|
|
reinterpret_cast<const uint8_t*>(&dex_file->GetHeader()),
|
|
dex_file->GetHeader().file_size_);
|
|
oat_writers[i]->AddRawDexFileSource(raw_dex_file,
|
|
dex_file->GetLocation().c_str(),
|
|
dex_file->GetLocationChecksum());
|
|
|
|
std::vector<MemMap> cur_opened_dex_files_maps;
|
|
std::vector<std::unique_ptr<const DexFile>> cur_opened_dex_files;
|
|
bool dex_files_ok = oat_writers[i]->WriteAndOpenDexFiles(
|
|
out_helper.vdex_files[i].GetFile(),
|
|
/* verify */ false, // Dex files may be dex-to-dex-ed, don't verify.
|
|
/* update_input_vdex */ false,
|
|
/* copy_dex_files */ CopyOption::kOnlyIfCompressed,
|
|
&cur_opened_dex_files_maps,
|
|
&cur_opened_dex_files);
|
|
ASSERT_TRUE(dex_files_ok);
|
|
|
|
if (!cur_opened_dex_files_maps.empty()) {
|
|
for (MemMap& cur_map : cur_opened_dex_files_maps) {
|
|
opened_dex_files_maps.push_back(std::move(cur_map));
|
|
}
|
|
for (std::unique_ptr<const DexFile>& cur_dex_file : cur_opened_dex_files) {
|
|
// dex_file_oat_index_map_.emplace(dex_file.get(), i);
|
|
opened_dex_files.push_back(std::move(cur_dex_file));
|
|
}
|
|
} else {
|
|
ASSERT_TRUE(cur_opened_dex_files.empty());
|
|
}
|
|
}
|
|
bool image_space_ok = writer->PrepareImageAddressSpace(&timings);
|
|
ASSERT_TRUE(image_space_ok);
|
|
|
|
DCHECK_EQ(out_helper.vdex_files.size(), out_helper.oat_files.size());
|
|
for (size_t i = 0, size = out_helper.oat_files.size(); i != size; ++i) {
|
|
MultiOatRelativePatcher patcher(compiler_options_->GetInstructionSet(),
|
|
compiler_options_->GetInstructionSetFeatures(),
|
|
driver->GetCompiledMethodStorage());
|
|
OatWriter* const oat_writer = oat_writers[i].get();
|
|
ElfWriter* const elf_writer = elf_writers[i].get();
|
|
std::vector<const DexFile*> cur_dex_files(1u, class_path[i]);
|
|
bool start_rodata_ok = oat_writer->StartRoData(cur_dex_files,
|
|
rodata[i],
|
|
(i == 0u) ? &key_value_store : nullptr);
|
|
ASSERT_TRUE(start_rodata_ok);
|
|
oat_writer->Initialize(driver, writer.get(), cur_dex_files);
|
|
|
|
oat_writer->FinishVdexFile(out_helper.vdex_files[i].GetFile(), /*verifier_deps=*/ nullptr);
|
|
|
|
oat_writer->PrepareLayout(&patcher);
|
|
elf_writer->PrepareDynamicSection(oat_writer->GetOatHeader().GetExecutableOffset(),
|
|
oat_writer->GetCodeSize(),
|
|
oat_writer->GetDataBimgRelRoSize(),
|
|
oat_writer->GetBssSize(),
|
|
oat_writer->GetBssMethodsOffset(),
|
|
oat_writer->GetBssRootsOffset(),
|
|
oat_writer->GetVdexSize());
|
|
|
|
writer->UpdateOatFileLayout(i,
|
|
elf_writer->GetLoadedSize(),
|
|
oat_writer->GetOatDataOffset(),
|
|
oat_writer->GetOatSize());
|
|
|
|
bool rodata_ok = oat_writer->WriteRodata(rodata[i]);
|
|
ASSERT_TRUE(rodata_ok);
|
|
elf_writer->EndRoData(rodata[i]);
|
|
|
|
OutputStream* text = elf_writer->StartText();
|
|
bool text_ok = oat_writer->WriteCode(text);
|
|
ASSERT_TRUE(text_ok);
|
|
elf_writer->EndText(text);
|
|
|
|
if (oat_writer->GetDataBimgRelRoSize() != 0u) {
|
|
OutputStream* data_bimg_rel_ro = elf_writer->StartDataBimgRelRo();
|
|
bool data_bimg_rel_ro_ok = oat_writer->WriteDataBimgRelRo(data_bimg_rel_ro);
|
|
ASSERT_TRUE(data_bimg_rel_ro_ok);
|
|
elf_writer->EndDataBimgRelRo(data_bimg_rel_ro);
|
|
}
|
|
|
|
bool header_ok = oat_writer->WriteHeader(elf_writer->GetStream());
|
|
ASSERT_TRUE(header_ok);
|
|
|
|
writer->UpdateOatFileHeader(i, oat_writer->GetOatHeader());
|
|
|
|
elf_writer->WriteDynamicSection();
|
|
elf_writer->WriteDebugInfo(oat_writer->GetDebugInfo());
|
|
|
|
bool success = elf_writer->End();
|
|
ASSERT_TRUE(success);
|
|
}
|
|
}
|
|
|
|
bool success_image = writer->Write(File::kInvalidFd,
|
|
image_filenames,
|
|
image_filenames.size());
|
|
ASSERT_TRUE(success_image);
|
|
}
|
|
}
|
|
|
|
inline void ImageTest::Compile(
|
|
ImageHeader::StorageMode storage_mode,
|
|
uint32_t max_image_block_size,
|
|
CompilationHelper& helper,
|
|
const std::string& extra_dex,
|
|
const std::initializer_list<std::string>& image_classes,
|
|
const std::initializer_list<std::string>& image_classes_failing_aot_clinit) {
|
|
for (const std::string& image_class : image_classes_failing_aot_clinit) {
|
|
ASSERT_TRUE(ContainsElement(image_classes, image_class));
|
|
}
|
|
for (const std::string& image_class : image_classes) {
|
|
image_classes_.insert(image_class);
|
|
}
|
|
number_of_threads_ = kIsTargetBuild ? 2U : 16U;
|
|
CreateCompilerDriver();
|
|
// Set inline filter values.
|
|
compiler_options_->SetInlineMaxCodeUnits(CompilerOptions::kDefaultInlineMaxCodeUnits);
|
|
compiler_options_->SetMaxImageBlockSize(max_image_block_size);
|
|
image_classes_.clear();
|
|
if (!extra_dex.empty()) {
|
|
helper.extra_dex_files = OpenTestDexFiles(extra_dex.c_str());
|
|
}
|
|
DoCompile(storage_mode, helper);
|
|
if (image_classes.begin() != image_classes.end()) {
|
|
// Make sure the class got initialized.
|
|
ScopedObjectAccess soa(Thread::Current());
|
|
ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
|
|
for (const std::string& image_class : image_classes) {
|
|
ObjPtr<mirror::Class> klass =
|
|
class_linker->FindSystemClass(Thread::Current(), image_class.c_str());
|
|
EXPECT_TRUE(klass != nullptr);
|
|
EXPECT_TRUE(klass->IsResolved());
|
|
if (ContainsElement(image_classes_failing_aot_clinit, image_class)) {
|
|
EXPECT_FALSE(klass->IsInitialized());
|
|
} else {
|
|
EXPECT_TRUE(klass->IsInitialized());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace linker
|
|
} // namespace art
|
|
|
|
#endif // ART_DEX2OAT_LINKER_IMAGE_TEST_H_
|