[Courgette] Clean up EnsembleProgram.

courgette/encoded_program.h

 // 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.
 
 #ifndef COURGETTE_ENCODED_PROGRAM_H_
 #define COURGETTE_ENCODED_PROGRAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "courgette/disassembler.h"
-#include "courgette/label_manager.h"
+#include "courgette/courgette.h"
+#include "courgette/image_utils.h"
 #include "courgette/memory_allocator.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;
 const int kStreamRel32Addresses = 6;
 const int kStreamCopyCounts = 7;
 const int kStreamOriginAddresses = kStreamMisc;
 
 const int kStreamLimit = 9;
 
+class LabelManager;
 class SinkStream;
 class SinkStreamSet;
 class SourceStreamSet;
 
-// An EncodedProgram is a set of tables that contain a simple 'binary assembly
-// language' that can be assembled to produce a sequence of bytes, for example,
-// a Windows 32-bit executable.
-//
+// EncodedProgram encodes Courgette's simple "binary assembly language", which
+// can be assembled to produce a sequence of bytes (e.g., a Windows 32-bit
+// executable).
 class EncodedProgram {
  public:
   EncodedProgram();
   ~EncodedProgram();
 
   // Generating an EncodedProgram:
   //
   // (1) The image base can be specified at any time.
   void set_image_base(uint64_t base) { image_base_ = base; }
 
@@ skipping 25 matching lines @@
   bool ReadFrom(SourceStreamSet* streams);
 
   // (5) Assembles the 'binary assembly language' into final file.
   CheckBool AssembleTo(SinkStream* buffer) WARN_UNUSED_RESULT;
 
  private:
   // Binary assembly language operations.
   // These are part of the patch format. Reusing an existing value will
   // break backwards compatibility.
   enum OP {
-    ORIGIN = 0,    // ORIGIN <rva> - set address for subsequent assembly.
-    COPY = 1,      // COPY <count> <bytes> - copy bytes to output.
-    COPY1 = 2,     // COPY1 <byte> - same as COPY 1 <byte>.
-    REL32 = 3,     // REL32 <index> - emit rel32 encoded reference to address at
-                   // address table offset <index>
-    ABS32 = 4,     // ABS32 <index> - emit abs32 encoded reference to address at
-                   // address table offset <index>
-    MAKE_PE_RELOCATION_TABLE = 5,  // Emit PE base relocation table blocks.
-    MAKE_ELF_RELOCATION_TABLE = 6, // Emit Elf relocation table for X86
-    MAKE_ELF_ARM_RELOCATION_TABLE = 7, // Emit Elf relocation table for ARM
-    MAKE_PE64_RELOCATION_TABLE = 8, // Emit PE64 base relocation table blocks.
-    ABS64 = 9,     // ABS64 <index> - emit abs64 encoded reference to address at
-                   // address table offset <index>
+    ORIGIN = 0,  // ORIGIN <rva> - set address for subsequent assembly.
+    COPY = 1,    // COPY <count> <bytes> - copy bytes to output.
+    COPY1 = 2,   // COPY1 <byte> - same as COPY 1 <byte>.
+    REL32 = 3,   // REL32 <index> - emit rel32 encoded reference to address at
+                 // address table offset <index>
+    ABS32 = 4,   // ABS32 <index> - emit abs32 encoded reference to address at
+                 // address table offset <index>
+    MAKE_PE_RELOCATION_TABLE = 5,       // Emit PE base relocation table blocks.
+    MAKE_ELF_RELOCATION_TABLE = 6,      // Emit Elf relocation table for X86
+    MAKE_ELF_ARM_RELOCATION_TABLE = 7,  // Emit Elf relocation table for ARM
+    MAKE_PE64_RELOCATION_TABLE = 8,  // Emit PE64 base relocation table blocks.
+    ABS64 = 9,  // ABS64 <index> - emit abs64 encoded reference to address at
+                // address table offset <index>
     // ARM reserves 0x1000-LAST_ARM, bits 13-16 define the opcode
     // subset, and 1-12 are the compressed ARM op.
-    REL32ARM8   = 0x1000,
-    REL32ARM11  = 0x2000,
-    REL32ARM24  = 0x3000,
-    REL32ARM25  = 0x4000,
-    REL32ARM21  = 0x5000,
-    LAST_ARM    = 0x5FFF,
+    REL32ARM8 = 0x1000,
+    REL32ARM11 = 0x2000,
+    REL32ARM24 = 0x3000,
+    REL32ARM25 = 0x4000,
+    REL32ARM21 = 0x5000,
+    LAST_ARM = 0x5FFF,
   };
 
   typedef NoThrowBuffer<RVA> RvaVector;
   typedef NoThrowBuffer<size_t> SizeTVector;
   typedef NoThrowBuffer<uint32_t> UInt32Vector;
   typedef NoThrowBuffer<uint8_t> UInt8Vector;
   typedef NoThrowBuffer<OP> OPVector;
 
   void DebuggingSummary();
 
   // Helper for ImportLabels().
   static CheckBool WriteRvasToList(const LabelManager& label_manager,
                                    RvaVector* rvas);
 
   // Helper for ImportLabels().
   static void FillUnassignedRvaSlots(RvaVector* rvas);
 
   CheckBool GeneratePeRelocations(SinkStream* buffer,
                                   uint8_t type) WARN_UNUSED_RESULT;
   CheckBool GenerateElfRelocations(Elf32_Word pending_elf_relocation_table,
-                                   SinkStream *buffer) WARN_UNUSED_RESULT;
+                                   SinkStream* buffer) WARN_UNUSED_RESULT;
 
   // Decodes and evaluates courgette ops for ARM rel32 addresses.
-  CheckBool EvaluateRel32ARM(OP op, size_t& ix_rel32_ix, RVA& current_rva,
+  CheckBool EvaluateRel32ARM(OP op,
+                             size_t* ix_rel32_ix,
+                             RVA* current_rva,
                              SinkStream* output);
 
   // Binary assembly language tables.
   uint64_t image_base_ = 0;
   RvaVector rel32_rva_;
   RvaVector abs32_rva_;
   OPVector ops_;
   RvaVector origins_;
   SizeTVector copy_counts_;
   UInt8Vector copy_bytes_;
   UInt32Vector rel32_ix_;
   UInt32Vector abs32_ix_;
 
   // Table of the addresses containing abs32 relocations; computed during
   // assembly, used to generate base relocation table.
   UInt32Vector abs32_relocs_;
 
   DISALLOW_COPY_AND_ASSIGN(EncodedProgram);
 };
 
 // Deserializes program from a stream set to |*output|. Returns C_OK if
 // successful, otherwise assigns |*output| to null and returns an error status.
 Status ReadEncodedProgram(SourceStreamSet* source,
                           std::unique_ptr<EncodedProgram>* output);
 
 }  // namespace courgette
 
 #endif  // COURGETTE_ENCODED_PROGRAM_H_