summaryrefslogtreecommitdiff
path: root/compiler
diff options
context:
space:
mode:
Diffstat (limited to 'compiler')
-rw-r--r--compiler/Android.mk8
-rw-r--r--compiler/common_compiler_test.cc32
-rw-r--r--compiler/common_compiler_test.h2
-rw-r--r--compiler/image_test.cc38
-rw-r--r--compiler/image_writer.cc71
-rw-r--r--compiler/image_writer.h10
6 files changed, 36 insertions, 125 deletions
diff --git a/compiler/Android.mk b/compiler/Android.mk
index bdd9a84433..348eabdde5 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -258,9 +258,9 @@ define build-libart-compiler
ifeq ($$(art_ndebug_or_debug),ndebug)
LOCAL_MODULE := libart-compiler
ifeq ($$(art_static_or_shared), static)
- LOCAL_STATIC_LIBRARIES += libart liblz4
+ LOCAL_STATIC_LIBRARIES += libart
else
- LOCAL_SHARED_LIBRARIES += libart liblz4
+ LOCAL_SHARED_LIBRARIES += libart
endif
ifeq ($$(art_target_or_host),target)
LOCAL_FDO_SUPPORT := true
@@ -268,9 +268,9 @@ define build-libart-compiler
else # debug
LOCAL_MODULE := libartd-compiler
ifeq ($$(art_static_or_shared), static)
- LOCAL_STATIC_LIBRARIES += libartd liblz4
+ LOCAL_STATIC_LIBRARIES += libartd
else
- LOCAL_SHARED_LIBRARIES += libartd liblz4
+ LOCAL_SHARED_LIBRARIES += libartd
endif
endif
diff --git a/compiler/common_compiler_test.cc b/compiler/common_compiler_test.cc
index 3901e25949..e6cc50cc5e 100644
--- a/compiler/common_compiler_test.cc
+++ b/compiler/common_compiler_test.cc
@@ -189,33 +189,21 @@ void CommonCompilerTest::SetUp() {
}
timer_.reset(new CumulativeLogger("Compilation times"));
- CreateCompilerDriver(compiler_kind_, instruction_set);
+ compiler_driver_.reset(new CompilerDriver(compiler_options_.get(),
+ verification_results_.get(),
+ method_inliner_map_.get(),
+ compiler_kind_, instruction_set,
+ instruction_set_features_.get(),
+ true,
+ GetImageClasses(),
+ GetCompiledClasses(),
+ GetCompiledMethods(),
+ 2, true, true, "", false, timer_.get(), -1, ""));
}
// We typically don't generate an image in unit tests, disable this optimization by default.
compiler_driver_->SetSupportBootImageFixup(false);
}
-void CommonCompilerTest::CreateCompilerDriver(Compiler::Kind kind, InstructionSet isa) {
- compiler_driver_.reset(new CompilerDriver(compiler_options_.get(),
- verification_results_.get(),
- method_inliner_map_.get(),
- kind,
- isa,
- instruction_set_features_.get(),
- true,
- GetImageClasses(),
- GetCompiledClasses(),
- GetCompiledMethods(),
- 2,
- true,
- true,
- "",
- false,
- timer_.get(),
- -1,
- ""));
-}
-
void CommonCompilerTest::SetUpRuntimeOptions(RuntimeOptions* options) {
CommonRuntimeTest::SetUpRuntimeOptions(options);
diff --git a/compiler/common_compiler_test.h b/compiler/common_compiler_test.h
index b491946dc3..1b57b7d1d2 100644
--- a/compiler/common_compiler_test.h
+++ b/compiler/common_compiler_test.h
@@ -90,8 +90,6 @@ class CommonCompilerTest : public CommonRuntimeTest {
const char* method_name, const char* signature)
SHARED_REQUIRES(Locks::mutator_lock_);
- void CreateCompilerDriver(Compiler::Kind kind, InstructionSet isa);
-
void ReserveImageSpace();
void UnreserveImageSpace();
diff --git a/compiler/image_test.cc b/compiler/image_test.cc
index b596ba66a5..cda6240bd4 100644
--- a/compiler/image_test.cc
+++ b/compiler/image_test.cc
@@ -43,17 +43,10 @@ class ImageTest : public CommonCompilerTest {
ReserveImageSpace();
CommonCompilerTest::SetUp();
}
- void TestWriteRead(ImageHeader::StorageMode storage_mode);
};
-void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) {
- // TODO: Test does not currently work with optimizing.
- CreateCompilerDriver(Compiler::kQuick, kRuntimeISA);
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- // Enable write for dex2dex.
- for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
- dex_file->EnableWrite();
- }
+TEST_F(ImageTest, WriteRead) {
+ TEST_DISABLED_FOR_NON_PIC_COMPILING_WITH_OPTIMIZING();
// Create a generic location tmp file, to be the base of the .art and .oat temporary files.
ScratchFile location;
ScratchFile image_location(location, ".art");
@@ -75,14 +68,17 @@ void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) {
std::unique_ptr<ImageWriter> writer(new ImageWriter(*compiler_driver_,
requested_image_base,
/*compile_pic*/false,
- /*compile_app_image*/false,
- storage_mode));
+ /*compile_app_image*/false));
// TODO: compile_pic should be a test argument.
{
{
jobject class_loader = nullptr;
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
TimingLogger timings("ImageTest::WriteRead", false, false);
TimingLogger::ScopedTiming t("CompileAll", &timings);
+ for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
+ dex_file->EnableWrite();
+ }
compiler_driver_->SetDexFilesForOatFile(class_linker->GetBootClassPath());
compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
@@ -213,13 +209,7 @@ void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) {
gc::space::ImageSpace* image_space = heap->GetBootImageSpace();
ASSERT_TRUE(image_space != nullptr);
- if (storage_mode == ImageHeader::kStorageModeUncompressed) {
- // Uncompressed, image should be smaller than file.
- ASSERT_LE(image_space->Size(), image_file_size);
- } else {
- // Compressed, file should be smaller than image.
- ASSERT_LE(image_file_size, image_space->Size());
- }
+ ASSERT_LE(image_space->Size(), image_file_size);
image_space->VerifyImageAllocations();
uint8_t* image_begin = image_space->Begin();
@@ -247,14 +237,6 @@ void ImageTest::TestWriteRead(ImageHeader::StorageMode storage_mode) {
CHECK_EQ(0, rmdir_result);
}
-TEST_F(ImageTest, WriteReadUncompressed) {
- TestWriteRead(ImageHeader::kStorageModeUncompressed);
-}
-
-TEST_F(ImageTest, WriteReadLZ4) {
- TestWriteRead(ImageHeader::kStorageModeLZ4);
-}
-
TEST_F(ImageTest, ImageHeaderIsValid) {
uint32_t image_begin = ART_BASE_ADDRESS;
uint32_t image_size_ = 16 * KB;
@@ -275,9 +257,7 @@ TEST_F(ImageTest, ImageHeaderIsValid) {
oat_data_end,
oat_file_end,
sizeof(void*),
- /*compile_pic*/false,
- ImageHeader::kDefaultStorageMode,
- /*data_size*/0u);
+ /*compile_pic*/false);
ASSERT_TRUE(image_header.IsValid());
char* magic = const_cast<char*>(image_header.GetMagic());
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index f9f0eb8154..bf1fcdd5f5 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -17,7 +17,6 @@
#include "image_writer.h"
#include <sys/stat.h>
-#include <lz4.h>
#include <memory>
#include <numeric>
@@ -226,72 +225,27 @@ bool ImageWriter::Write(int image_fd,
return EXIT_FAILURE;
}
- std::unique_ptr<char[]> compressed_data;
- // Image data size excludes the bitmap and the header.
- ImageHeader* const image_header = reinterpret_cast<ImageHeader*>(image_->Begin());
- const size_t image_data_size = image_header->GetImageSize() - sizeof(ImageHeader);
- char* image_data = reinterpret_cast<char*>(image_->Begin()) + sizeof(ImageHeader);
- size_t data_size;
- const char* image_data_to_write;
-
- CHECK_EQ(image_header->storage_mode_, image_storage_mode_);
- switch (image_storage_mode_) {
- case ImageHeader::kStorageModeLZ4: {
- size_t compressed_max_size = LZ4_compressBound(image_data_size);
- compressed_data.reset(new char[compressed_max_size]);
- data_size = LZ4_compress(
- reinterpret_cast<char*>(image_->Begin()) + sizeof(ImageHeader),
- &compressed_data[0],
- image_data_size);
- image_data_to_write = &compressed_data[0];
- VLOG(compiler) << "Compressed from " << image_data_size << " to " << data_size;
- break;
- }
- case ImageHeader::kStorageModeUncompressed: {
- data_size = image_data_size;
- image_data_to_write = image_data;
- break;
- }
- default: {
- LOG(FATAL) << "Unsupported";
- UNREACHABLE();
- }
- }
-
- // Write header first, as uncompressed.
- image_header->data_size_ = data_size;
- if (!image_file->WriteFully(image_->Begin(), sizeof(ImageHeader))) {
- PLOG(ERROR) << "Failed to write image file header " << image_filename;
- image_file->Erase();
- return false;
- }
-
// Write out the image + fields + methods.
- const bool is_compressed = compressed_data != nullptr;
- if (!image_file->WriteFully(image_data_to_write, data_size)) {
- PLOG(ERROR) << "Failed to write image file data " << image_filename;
+ ImageHeader* const image_header = reinterpret_cast<ImageHeader*>(image_->Begin());
+ const auto write_count = image_header->GetImageSize();
+ if (!image_file->WriteFully(image_->Begin(), write_count)) {
+ PLOG(ERROR) << "Failed to write image file " << image_filename;
image_file->Erase();
return false;
}
- // Write out the image bitmap at the page aligned start of the image end, also uncompressed for
- // convenience.
+ // Write out the image bitmap at the page aligned start of the image end.
const ImageSection& bitmap_section = image_header->GetImageSection(
ImageHeader::kSectionImageBitmap);
- // Align up since data size may be unaligned if the image is compressed.
- size_t bitmap_position_in_file = RoundUp(sizeof(ImageHeader) + data_size, kPageSize);
- if (!is_compressed) {
- CHECK_EQ(bitmap_position_in_file, bitmap_section.Offset());
- }
+ CHECK_ALIGNED(bitmap_section.Offset(), kPageSize);
if (!image_file->Write(reinterpret_cast<char*>(image_bitmap_->Begin()),
- bitmap_section.Size(),
- bitmap_position_in_file)) {
+ bitmap_section.Size(), bitmap_section.Offset())) {
PLOG(ERROR) << "Failed to write image file " << image_filename;
image_file->Erase();
return false;
}
- CHECK_EQ(bitmap_position_in_file + bitmap_section.Size(),
- static_cast<size_t>(image_file->GetLength()));
+
+ CHECK_EQ(bitmap_section.End(), static_cast<size_t>(image_file->GetLength()));
if (image_file->FlushCloseOrErase() != 0) {
PLOG(ERROR) << "Failed to flush and close image file " << image_filename;
return false;
@@ -1293,8 +1247,7 @@ void ImageWriter::CreateHeader(size_t oat_loaded_size, size_t oat_data_offset) {
}
CHECK_EQ(AlignUp(image_begin_ + image_end, kPageSize), oat_file_begin) <<
"Oat file should be right after the image.";
- // Create the header, leave 0 for data size since we will fill this in as we are writing the
- // image.
+ // Create the header.
new (image_->Begin()) ImageHeader(PointerToLowMemUInt32(image_begin_),
image_end,
sections,
@@ -1305,9 +1258,7 @@ void ImageWriter::CreateHeader(size_t oat_loaded_size, size_t oat_data_offset) {
PointerToLowMemUInt32(oat_data_end),
PointerToLowMemUInt32(oat_file_end),
target_ptr_size_,
- compile_pic_,
- image_storage_mode_,
- /*data_size*/0u);
+ compile_pic_);
}
ArtMethod* ImageWriter::GetImageMethodAddress(ArtMethod* method) {
diff --git a/compiler/image_writer.h b/compiler/image_writer.h
index c20d83639a..386838fde0 100644
--- a/compiler/image_writer.h
+++ b/compiler/image_writer.h
@@ -30,7 +30,6 @@
#include "base/macros.h"
#include "driver/compiler_driver.h"
#include "gc/space/space.h"
-#include "image.h"
#include "length_prefixed_array.h"
#include "lock_word.h"
#include "mem_map.h"
@@ -55,8 +54,7 @@ class ImageWriter FINAL {
ImageWriter(const CompilerDriver& compiler_driver,
uintptr_t image_begin,
bool compile_pic,
- bool compile_app_image,
- ImageHeader::StorageMode image_storage_mode)
+ bool compile_app_image)
: compiler_driver_(compiler_driver),
image_begin_(reinterpret_cast<uint8_t*>(image_begin)),
image_end_(0),
@@ -75,8 +73,7 @@ class ImageWriter FINAL {
image_method_array_(ImageHeader::kImageMethodsCount),
dirty_methods_(0u),
clean_methods_(0u),
- class_table_bytes_(0u),
- image_storage_mode_(image_storage_mode) {
+ class_table_bytes_(0u) {
CHECK_NE(image_begin, 0U);
std::fill_n(image_methods_, arraysize(image_methods_), nullptr);
std::fill_n(oat_address_offsets_, arraysize(oat_address_offsets_), 0);
@@ -463,9 +460,6 @@ class ImageWriter FINAL {
// Number of image class table bytes.
size_t class_table_bytes_;
- // Which mode the image is stored as, see image.h
- const ImageHeader::StorageMode image_storage_mode_;
-
friend class ContainsBootClassLoaderNonImageClassVisitor;
friend class FixupClassVisitor;
friend class FixupRootVisitor;
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-21 20:54:52 +0000