courgette/encoded_program.h

   1 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COURGETTE_ENCODED_PROGRAM_H_
   6 #define COURGETTE_ENCODED_PROGRAM_H_
   7
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "courgette/image_info.h"
  12
  13 namespace courgette {
  14
  15 class SinkStream;
  16 class SinkStreamSet;
  17 class SourceStreamSet;
  18
  19 // An EncodedProgram is a set of tables that contain a simple 'binary assembly
  20 // language' that can be assembled to produce a sequence of bytes, for example,
  21 // a Windows 32-bit executable.
  22 //
  23 class EncodedProgram {
  24  public:
  25   EncodedProgram();
  26   ~EncodedProgram();
  27
  28   // Generating an EncodedProgram:
  29   //
  30   // (1) The image base can be specified at any time.
  31   void set_image_base(uint64 base) { image_base_ = base; }
  32
  33   // (2) Address tables and indexes defined first.
  34   void DefineRel32Label(int index, RVA address);
  35   void DefineAbs32Label(int index, RVA address);
  36   void EndLabels();
  37
  38   // (3) Add instructions in the order needed to generate bytes of file.
  39   void AddOrigin(RVA rva);
  40   void AddCopy(int count, const void* bytes);
  41   void AddRel32(int label_index);
  42   void AddAbs32(int label_index);
  43   void AddMakeRelocs();
  44
  45   // (3) Serialize binary assembly language tables to a set of streams.
  46   void WriteTo(SinkStreamSet *streams);
  47
  48   // Using an EncodedProgram to generate a byte stream:
  49   //
  50   // (4) Deserializes a fresh EncodedProgram from a set of streams.
  51   bool ReadFrom(SourceStreamSet *streams);
  52
  53   // (5) Assembles the 'binary assembly language' into final file.
  54   bool AssembleTo(SinkStream *buffer);
  55
  56  private:
  57   // Binary assembly language operations.
  58   enum OP {
  59     ORIGIN,    // ORIGIN <rva> - set address for subsequent assembly.
  60     COPY,      // COPY <count> <bytes> - copy bytes to output.
  61     COPY1,     // COPY1 <byte> - same as COPY 1 <byte>.
  62     REL32,     // REL32 <index> - emit rel32 encoded reference to address at
  63                // address table offset <index>
  64     ABS32,     // ABS32 <index> - emit abs32 encoded reference to address at
  65                // address table offset <index>
  66     MAKE_BASE_RELOCATION_TABLE,  // Emit base relocation table blocks.
  67     OP_LAST
  68   };
  69
  70   void DebuggingSummary();
  71   void GenerateBaseRelocations(SinkStream *buffer);
  72   void DefineLabelCommon(std::vector<RVA>*, int, RVA);
  73   void FinishLabelsCommon(std::vector<RVA>* addresses);
  74
  75   // Binary assembly language tables.
  76   uint64 image_base_;
  77   std::vector<RVA> rel32_rva_;
  78   std::vector<RVA> abs32_rva_;
  79   std::vector<OP> ops_;
  80   std::vector<RVA> origins_;
  81   std::vector<int> copy_counts_;
  82   std::vector<uint8> copy_bytes_;
  83   std::vector<uint32> rel32_ix_;
  84   std::vector<uint32> abs32_ix_;
  85
  86   // Table of the addresses containing abs32 relocations; computed during
  87   // assembly, used to generate base relocation table.
  88   std::vector<uint32> abs32_relocs_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(EncodedProgram);
  91 };
  92
  93 }  // namespace courgette
  94 #endif  // COURGETTE_ENCODED_PROGRAM_H_