Write ELF image to Oat file.

Change-Id: I0bd5de3b68296d384b31f1900c7c670737f6e22b
diff --git a/src/oat.cc b/src/oat.cc
index d8d01df..b3333c2 100644
--- a/src/oat.cc
+++ b/src/oat.cc
@@ -29,6 +29,7 @@
 
 OatHeader::OatHeader(InstructionSet instruction_set,
                      const std::vector<const DexFile*>* dex_files,
+                     uint32_t elf_image_count,
                      uint32_t image_file_location_checksum,
                      const std::string& image_file_location) {
   memcpy(magic_, kOatMagic, sizeof(kOatMagic));
@@ -42,6 +43,9 @@
   dex_file_count_ = dex_files->size();
   UpdateChecksum(&dex_file_count_, sizeof(dex_file_count_));
 
+  elf_image_count_ = elf_image_count;
+  UpdateChecksum(&elf_image_count_, sizeof(elf_image_count_));
+
   image_file_location_checksum_ = image_file_location_checksum;
   UpdateChecksum(&image_file_location_checksum_, sizeof(image_file_location_checksum_));
 
@@ -49,6 +53,7 @@
   UpdateChecksum(&image_file_location_size_, sizeof(image_file_location_size_));
   UpdateChecksum(image_file_location.data(), image_file_location_size_);
 
+  elf_image_table_offset_ = 0;
   executable_offset_ = 0;
 }
 
@@ -72,6 +77,16 @@
   return dex_file_count_;
 }
 
+uint32_t OatHeader::GetElfImageCount() const {
+  DCHECK(IsValid());
+  return elf_image_count_;
+}
+
+uint32_t OatHeader::GetElfImageTableOffset() const {
+  DCHECK(IsValid());
+  return elf_image_table_offset_;
+}
+
 uint32_t OatHeader::GetChecksum() const {
   CHECK(IsValid());
   return adler32_checksum_;
@@ -116,6 +131,12 @@
                      GetImageFileLocationSize());
 }
 
+void OatHeader::SetElfImageTableOffset(uint32_t elf_image_table_offset) {
+  DCHECK(IsValid());
+  elf_image_table_offset_ = elf_image_table_offset;
+  UpdateChecksum(&elf_image_table_offset_, sizeof(elf_image_table_offset_));
+}
+
 void OatHeader::SetExecutableOffset(uint32_t executable_offset) {
   DCHECK_ALIGNED(executable_offset, kPageSize);
   CHECK_GT(executable_offset, sizeof(OatHeader));
diff --git a/src/oat.h b/src/oat.h
index 25a4373..a71a75b 100644
--- a/src/oat.h
+++ b/src/oat.h
@@ -30,6 +30,7 @@
   OatHeader();
   OatHeader(InstructionSet instruction_set,
             const std::vector<const DexFile*>* dex_files,
+            uint32_t elf_image_count,
             uint32_t image_file_location_checksum,
             const std::string& image_file_location);
 
@@ -38,8 +39,11 @@
   uint32_t GetChecksum() const;
   void UpdateChecksum(const void* data, size_t length);
   uint32_t GetDexFileCount() const;
+  uint32_t GetElfImageCount() const;
+  uint32_t GetElfImageTableOffset() const;
   uint32_t GetExecutableOffset() const;
   InstructionSet GetInstructionSet() const;
+  void SetElfImageTableOffset(uint32_t elf_image_offset);
   void SetExecutableOffset(uint32_t executable_offset);
   uint32_t GetImageFileLocationChecksum() const;
   uint32_t GetImageFileLocationSize() const;
@@ -56,6 +60,8 @@
 
   InstructionSet instruction_set_;
   uint32_t dex_file_count_;
+  uint32_t elf_image_count_;
+  uint32_t elf_image_table_offset_;
   uint32_t executable_offset_;
 
   uint32_t image_file_location_checksum_;
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 8e127de..df809d5 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -18,11 +18,14 @@
 
 #include "class_linker.h"
 #include "class_loader.h"
+#include "elf_image.h"
 #include "file.h"
 #include "os.h"
 #include "space.h"
 #include "stl_util.h"
 
+#include <zlib.h>
+
 namespace art {
 
 bool OatWriter::Create(File* file,
@@ -49,12 +52,15 @@
   image_file_location_checksum_ = image_file_location_checksum;
   image_file_location_ = image_file_location;
   dex_files_ = &dex_files;
+  elf_images_ = compiler_->GetElfImages();
   oat_header_ = NULL;
   executable_offset_padding_length_ = 0;
 
   size_t offset = InitOatHeader();
   offset = InitOatDexFiles(offset);
   offset = InitDexFiles(offset);
+  offset = InitOatElfImages(offset);
+  offset = InitElfImages(offset);
   offset = InitOatClasses(offset);
   offset = InitOatCode(offset);
   offset = InitOatCodeDexFiles(offset);
@@ -65,6 +71,7 @@
 OatWriter::~OatWriter() {
   delete oat_header_;
   STLDeleteElements(&oat_dex_files_);
+  STLDeleteElements(&oat_elf_images_);
   STLDeleteElements(&oat_classes_);
 }
 
@@ -72,6 +79,7 @@
   // create the OatHeader
   oat_header_ = new OatHeader(compiler_->GetInstructionSet(),
                               dex_files_,
+                              elf_images_.size(),
                               image_file_location_checksum_,
                               image_file_location_);
   size_t offset = sizeof(*oat_header_);
@@ -106,6 +114,29 @@
   return offset;
 }
 
+size_t OatWriter::InitOatElfImages(size_t offset) {
+  // Offset to ELF image table should be rounded up to 4-byte aligned, so that
+  // we can read the uint32_t directly.
+  offset = RoundUp(offset, 4);
+  oat_header_->SetElfImageTableOffset(offset);
+
+  for (size_t i = 0, n = elf_images_.size(); i < n; ++i) {
+    OatElfImage* oat_elf_image = new OatElfImage(elf_images_[i]);
+    oat_elf_images_.push_back(oat_elf_image);
+    offset += oat_elf_image->SizeOf();
+  }
+  return offset;
+}
+
+size_t OatWriter::InitElfImages(size_t offset) {
+  for (size_t i = 0; i < oat_elf_images_.size(); ++i) {
+    offset = RoundUp(offset, 4);
+    oat_elf_images_[i]->SetElfOffset(offset);
+    offset += oat_elf_images_[i]->GetElfSize();
+  }
+  return offset;
+}
+
 size_t OatWriter::InitOatClasses(size_t offset) {
   // create the OatClasses
   // calculate the offsets within OatDexFiles to OatClasses
@@ -424,6 +455,25 @@
       return false;
     }
   }
+  for (size_t i = 0; i != oat_elf_images_.size(); ++i) {
+    if (!oat_elf_images_[i]->Write(file)) {
+      PLOG(ERROR) << "Failed to write oat elf information to " << file->name();
+      return false;
+    }
+  }
+  for (size_t i = 0; i != oat_elf_images_.size(); ++i) {
+    uint32_t expected_offset = oat_elf_images_[i]->GetElfOffset();
+    off_t actual_offset = lseek(file->Fd(), expected_offset, SEEK_SET);
+    if (static_cast<uint32_t>(actual_offset) != expected_offset) {
+      PLOG(ERROR) << "Failed to seek to dex file section."
+                  << " Actual: " << actual_offset
+                  << " Expected: " << expected_offset;
+      return false;
+    }
+    if (!oat_elf_images_[i]->WriteElfImage(file)) {
+      return false;
+    }
+  }
   for (size_t i = 0; i != oat_classes_.size(); ++i) {
     if (!oat_classes_[i]->Write(file)) {
       PLOG(ERROR) << "Failed to write oat methods information to " << file->name();
@@ -772,4 +822,48 @@
   return true;
 }
 
+OatWriter::OatElfImage::OatElfImage(const ElfImage& image)
+    : elf_offset_(0), elf_size_(image.size()), elf_addr_(image.begin()) {
+}
+
+size_t OatWriter::OatElfImage::SizeOf() const {
+  return (sizeof(elf_offset_) + sizeof(elf_size_));
+}
+
+uint32_t OatWriter::OatElfImage::GetElfSize() const {
+  return elf_size_;
+}
+
+uint32_t OatWriter::OatElfImage::GetElfOffset() const {
+  DCHECK_NE(elf_offset_, 0U);
+  return elf_offset_;
+}
+
+void OatWriter::OatElfImage::SetElfOffset(uint32_t offset) {
+  DCHECK_NE(offset, 0U);
+  DCHECK((offset & 0x3LU) == 0);
+  elf_offset_ = offset;
+}
+
+bool OatWriter::OatElfImage::Write(File* file) const {
+  DCHECK_NE(elf_offset_, 0U);
+  if (!file->WriteFully(&elf_offset_, sizeof(elf_offset_))) {
+    PLOG(ERROR) << "Failed to write ELF offset to " << file->name();
+    return false;
+  }
+  if (!file->WriteFully(&elf_size_, sizeof(elf_size_))) {
+    PLOG(ERROR) << "Failed to write ELF size to " << file->name();
+    return false;
+  }
+  return true;
+}
+
+bool OatWriter::OatElfImage::WriteElfImage(File* file) const {
+  if (!file->WriteFully(elf_addr_, elf_size_)) {
+    PLOG(ERROR) << "Failed to write ELF image to " << file->name();
+    return false;
+  }
+  return true;
+}
+
 }  // namespace art
diff --git a/src/oat_writer.h b/src/oat_writer.h
index c3a8ff6..e0d257f 100644
--- a/src/oat_writer.h
+++ b/src/oat_writer.h
@@ -48,6 +48,16 @@
 // ...
 // OatClass[C]
 //
+// OatElfImage[0]    one OatElfImage for each ELF image
+// OatElfImage[1]    contains the size, checksum, and offset to the ELF image.
+// ...
+// OatElfImage[E]
+//
+// ELF[0]
+// ELF[1]
+// ...
+// ELF[E]
+//
 // padding           if necessary so that the following code will be page aligned
 //
 // CompiledMethod    one variable sized blob with the contents of each CompiledMethod
@@ -82,6 +92,8 @@
   size_t InitOatDexFiles(size_t offset);
   size_t InitDexFiles(size_t offset);
   size_t InitOatClasses(size_t offset);
+  size_t InitOatElfImages(size_t offset);
+  size_t InitElfImages(size_t offset);
   size_t InitOatCode(size_t offset);
   size_t InitOatCodeDexFiles(size_t offset);
   size_t InitOatCodeDexFile(size_t offset,
@@ -143,6 +155,25 @@
     DISALLOW_COPY_AND_ASSIGN(OatClass);
   };
 
+  class OatElfImage {
+   public:
+    explicit OatElfImage(const ElfImage& elf_image);
+    size_t SizeOf() const;
+    uint32_t GetElfSize() const;
+    uint32_t GetElfOffset() const;
+    void SetElfOffset(uint32_t offset);
+    bool Write(File* file) const;
+    bool WriteElfImage(File* file) const;
+
+   private:
+    // data to write
+    uint32_t elf_offset_;
+    const uint32_t elf_size_;
+
+    const byte* const elf_addr_;
+    DISALLOW_COPY_AND_ASSIGN(OatElfImage);
+  };
+
   const Compiler* compiler_;
 
   // TODO: remove the ClassLoader when the code storage moves out of Method
@@ -151,6 +182,8 @@
   // note OatFile does not take ownership of the DexFiles
   const std::vector<const DexFile*>* dex_files_;
 
+  std::vector<ElfImage> elf_images_;
+
   // dependency on the image
   uint32_t image_file_location_checksum_;
   std::string image_file_location_;
@@ -159,6 +192,7 @@
   OatHeader* oat_header_;
   std::vector<OatDexFile*> oat_dex_files_;
   std::vector<OatClass*> oat_classes_;
+  std::vector<OatElfImage*> oat_elf_images_;
   uint32_t executable_offset_padding_length_;
 
   template <class T> struct MapCompare {