Add Elf 32 Support to Courgette.

courgette/encoded_program.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/encoded_program.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "courgette/courgette.h"
 #include "courgette/streams.h"
+#include "courgette/types_elf.h"
 
 namespace courgette {
 
 // Stream indexes.
 const int kStreamMisc    = 0;
 const int kStreamOps     = 1;
 const int kStreamBytes   = 2;
 const int kStreamAbs32Indexes = 3;
 const int kStreamRel32Indexes = 4;
 const int kStreamAbs32Addresses = 5;
@@ skipping 205 matching lines @@
 }
 
 CheckBool EncodedProgram::AddAbs32(int label_index) {
   return ops_.push_back(ABS32) && abs32_ix_.push_back(label_index);
 }
 
 CheckBool EncodedProgram::AddRel32(int label_index) {
   return ops_.push_back(REL32) && rel32_ix_.push_back(label_index);
 }
 
-CheckBool EncodedProgram::AddMakeRelocs() {
-  return ops_.push_back(MAKE_BASE_RELOCATION_TABLE);
+CheckBool EncodedProgram::AddPeMakeRelocs() {
+  return ops_.push_back(MAKE_PE_RELOCATION_TABLE);
+}
+
+CheckBool EncodedProgram::AddElfMakeRelocs() {
+  return ops_.push_back(MAKE_ELF_RELOCATION_TABLE);
 }
 
 void EncodedProgram::DebuggingSummary() {
   VLOG(1) << "EncodedProgram Summary"
           << "\n  image base  " << image_base_
           << "\n  abs32 rvas  " << abs32_rva_.size()
           << "\n  rel32 rvas  " << rel32_rva_.size()
           << "\n  ops         " << ops_.size()
           << "\n  origins     " << origins_.size()
           << "\n  copy_counts " << copy_counts_.size()
@@ skipping 136 matching lines @@
   // For the most part, the assembly process walks the various tables.
   // ix_mumble is the index into the mumble table.
   size_t ix_origins = 0;
   size_t ix_copy_counts = 0;
   size_t ix_copy_bytes = 0;
   size_t ix_abs32_ix = 0;
   size_t ix_rel32_ix = 0;
 
   RVA current_rva = 0;
 
-  bool pending_base_relocation_table = false;
-  SinkStream bytes_following_base_relocation_table;
+  bool pending_pe_relocation_table = false;
+  bool pending_elf_relocation_table = false;
+  SinkStream bytes_following_relocation_table;
 
   SinkStream* output = final_buffer;
 
   for (size_t ix_ops = 0;  ix_ops < ops_.size();  ++ix_ops) {
     OP op = ops_[ix_ops];
 
     switch (op) {
       default:
         return false;
 
@@ skipping 57 matching lines @@
         RVA rva;
         if (!VectorAt(abs32_rva_, index, &rva))
           return false;
         uint32 abs32 = static_cast<uint32>(rva + image_base_);
         if (!abs32_relocs_.push_back(current_rva) || !output->Write(&abs32, 4))
           return false;
         current_rva += 4;
         break;
       }
 
-      case MAKE_BASE_RELOCATION_TABLE: {
+      case MAKE_PE_RELOCATION_TABLE: {
         // We can see the base relocation anywhere, but we only have the
         // information to generate it at the very end.  So we divert the bytes
         // we are generating to a temporary stream.
-        if (pending_base_relocation_table)  // Can't have two base relocation
+        if (pending_pe_relocation_table)  // Can't have two base relocation
                                             // tables.
           return false;
 
-        pending_base_relocation_table = true;
-        output = &bytes_following_base_relocation_table;
+        pending_pe_relocation_table = true;
+        output = &bytes_following_relocation_table;
         break;
         // There is a potential problem *if* the instruction stream contains
         // some REL32 relocations following the base relocation and in the same
         // section.  We don't know the size of the table, so 'current_rva' will
         // be wrong, causing REL32 offsets to be miscalculated.  This never
         // happens; the base relocation table is usually in a section of its
         // own, a data-only section, and following everything else in the
         // executable except some padding zero bytes.  We could fix this by
         // emitting an ORIGIN after the MAKE_BASE_RELOCATION_TABLE.
       }
+
+      case MAKE_ELF_RELOCATION_TABLE: {
+        // We can see the base relocation anywhere, but we only have the
+        // information to generate it at the very end.  So we divert the bytes
+        // we are generating to a temporary stream.
+        if (pending_elf_relocation_table)  // Can't have two relocation
+                                           // tables.
+          return false;
+
+        pending_elf_relocation_table = true;
+        output = &bytes_following_relocation_table;
+        break;
+      }
     }
   }
 
-  if (pending_base_relocation_table) {
-    if (!GenerateBaseRelocations(final_buffer) ||
-        !final_buffer->Append(&bytes_following_base_relocation_table))
+  if (pending_pe_relocation_table) {
+    if (!GeneratePeRelocations(final_buffer) ||
+        !final_buffer->Append(&bytes_following_relocation_table))
       return false;
   }
 
+  if (pending_elf_relocation_table) {
+    if (!GenerateElfRelocations(final_buffer) ||
+        !final_buffer->Append(&bytes_following_relocation_table))
+      return false;
+  }
+
   // Final verification check: did we consume all lists?
   if (ix_copy_counts != copy_counts_.size())
     return false;
   if (ix_copy_bytes != copy_bytes_.size())
     return false;
   if (ix_abs32_ix != abs32_ix_.size())
     return false;
   if (ix_rel32_ix != rel32_ix_.size())
     return false;
 
@@ skipping 30 matching lines @@
         Add(0);
       }
       ok = buffer->Write(&pod, pod.block_size);
       pod.block_size = 8;
     }
     return ok;
   }
   RelocBlockPOD pod;
 };
 
-CheckBool EncodedProgram::GenerateBaseRelocations(SinkStream* buffer) {
+CheckBool EncodedProgram::GeneratePeRelocations(SinkStream* buffer) {
   std::sort(abs32_relocs_.begin(), abs32_relocs_.end());
 
   RelocBlock block;
 
   bool ok = true;
   for (size_t i = 0;  ok && i < abs32_relocs_.size();  ++i) {
     uint32 rva = abs32_relocs_[i];
     uint32 page_rva = rva & ~0xFFF;
     if (page_rva != block.pod.page_rva) {
       ok &= block.Flush(buffer);
       block.pod.page_rva = page_rva;
     }
     if (ok)
       block.Add(0x3000 | (rva & 0xFFF));
   }
   ok &= block.Flush(buffer);
   return ok;
 }
 
+CheckBool EncodedProgram::GenerateElfRelocations(SinkStream* buffer) {
+  std::sort(abs32_relocs_.begin(), abs32_relocs_.end());
+
+  Elf32_Rel relocation_block;
+
+  // We only handle this specific type of relocation, so far.
+  relocation_block.r_info = R_386_RELATIVE;
+
+  bool ok = true;
+  for (size_t i = 0;  ok && i < abs32_relocs_.size();  ++i) {
+    relocation_block.r_offset = abs32_relocs_[i];
+    ok = buffer->Write(&relocation_block, sizeof(Elf32_Rel));
+  }
+
+  return ok;
+}
 ////////////////////////////////////////////////////////////////////////////////
 
 Status WriteEncodedProgram(EncodedProgram* encoded, SinkStreamSet* sink) {
   if (!encoded->WriteTo(sink))
     return C_STREAM_ERROR;
   return C_OK;
 }
 
 Status ReadEncodedProgram(SourceStreamSet* streams, EncodedProgram** output) {
   EncodedProgram* encoded = new EncodedProgram();
@@ skipping 10 matching lines @@
   if (assembled)
     return C_OK;
   return C_ASSEMBLY_FAILED;
 }
 
 void DeleteEncodedProgram(EncodedProgram* encoded) {
   delete encoded;
 }
 
 }  // end namespace