Add Elf 32 Support to Courgette.

courgette/assembly_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/assembly_program.h"
 
 #include <memory.h>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 
 namespace courgette {
 
 // Opcodes of simple assembly language
 enum OP {
   ORIGIN,         // ORIGIN <rva> - set current address for assembly.
-  MAKERELOCS,     // Generates a base relocation table.
+  MAKEPERELOCS,   // Generates a base relocation table.
+  MAKEELFRELOCS,  // Generates a base relocation table.
   DEFBYTE,        // DEFBYTE <value> - emit a byte literal.
   REL32,          // REL32 <label> - emit a rel32 encoded reference to 'label'.
   ABS32,          // REL32 <label> - emit am abs32 encoded reference to 'label'.
   LAST_OP
 };
 
 // Base class for instructions.  Because we have so many instructions we want to
 // keep them as small as possible.  For this reason we avoid virtual functions.
 //
 class Instruction {
@@ skipping 15 matching lines @@
 
 // Sets the current address for the emitting instructions.
 class OriginInstruction : public Instruction {
  public:
   explicit OriginInstruction(RVA rva) : Instruction(ORIGIN, 0), rva_(rva) {}
   RVA origin_rva() const { return rva_; }
  private:
   RVA  rva_;
 };
 
-// Emits an entire base relocation table.
-class MakeRelocsInstruction : public Instruction {
+// Emits an entire PE base relocation table.
+class PeRelocsInstruction : public Instruction {
  public:
-  MakeRelocsInstruction() : Instruction(MAKERELOCS) {}
+  PeRelocsInstruction() : Instruction(MAKEPERELOCS) {}
+};
+
+// Emits an ELF relocation table.
+class ElfRelocsInstruction : public Instruction {
+ public:
+  ElfRelocsInstruction() : Instruction(MAKEELFRELOCS) {}
 };
 
 // Emits a single byte.
 class ByteInstruction : public Instruction {
  public:
   explicit ByteInstruction(uint8 value) : Instruction(DEFBYTE, value) {}
   uint8 byte_value() const { return info_; }
 };
 
 // A ABS32 to REL32 instruction emits a reference to a label's address.
@@ skipping 26 matching lines @@
       delete instruction;
   }
   if (byte_instruction_cache_.get()) {
     for (size_t i = 0;  i < 256;  ++i)
       delete byte_instruction_cache_[i];
   }
   DeleteContainedLabels(rel32_labels_);
   DeleteContainedLabels(abs32_labels_);
 }
 
-CheckBool AssemblyProgram::EmitMakeRelocsInstruction() {
-  return Emit(new(std::nothrow) MakeRelocsInstruction());
+CheckBool AssemblyProgram::EmitPeRelocsInstruction() {
+  return Emit(new(std::nothrow) PeRelocsInstruction());
+}
+
+CheckBool AssemblyProgram::EmitElfRelocationInstruction() {
+  return Emit(new(std::nothrow) ElfRelocsInstruction());
 }
 
 CheckBool AssemblyProgram::EmitOriginInstruction(RVA rva) {
   return Emit(new(std::nothrow) OriginInstruction(rva));
 }
 
 CheckBool AssemblyProgram::EmitByteInstruction(uint8 byte) {
   return Emit(GetByteInstruction(byte));
 }
 
@@ skipping 227 matching lines @@
         if (!encoded->AddRel32(label->index_))
           return NULL;
         break;
       }
       case ABS32: {
         Label* label = static_cast<InstructionWithLabel*>(instruction)->label();
         if (!encoded->AddAbs32(label->index_))
           return NULL;
         break;
       }
-      case MAKERELOCS: {
-        if (!encoded->AddMakeRelocs())
+      case MAKEPERELOCS: {
+        if (!encoded->AddPeMakeRelocs())
           return NULL;
         break;
       }
+      case MAKEELFRELOCS: {
+        if (!encoded->AddElfMakeRelocs())
+          return NULL;
+        break;
+      }
       default: {
         NOTREACHED() << "Unknown Insn OP kind";
       }
     }
   }
 
   return encoded.release();
 }
 
 Instruction* AssemblyProgram::GetByteInstruction(uint8 byte) {
@@ skipping 24 matching lines @@
   EncodedProgram *encoded = program->Encode();
   if (encoded) {
     *output = encoded;
     return C_OK;
   } else {
     return C_GENERAL_ERROR;
   }
 }
 
 }  // namespace courgette