[Courgette] Refactor: Unify Disassembler::Disassemble() and instantiate AssemblyProgram there.

courgette/assembly_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_ASSEMBLY_PROGRAM_H_
 #define COURGETTE_ASSEMBLY_PROGRAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "courgette/courgette.h"
 #include "courgette/image_utils.h"
+#include "courgette/instruction_utils.h"
 #include "courgette/label_manager.h"
 #include "courgette/memory_allocator.h"
 
 namespace courgette {
 
 class EncodedProgram;
 
 // Opcodes of simple assembly language
 enum OP {
   ORIGIN,         // ORIGIN <rva> - set current address for assembly.
@@ skipping 19 matching lines @@
   explicit Instruction(OP op) : op_(op), info_(0) {}
   Instruction(OP op, unsigned int info) : op_(op), info_(info) {}
 
   uint32_t op_ : 4;     // A few bits to store the OP code.
   uint32_t info_ : 28;  // Remaining bits in first word available to subclass.
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
-// An interface to receive emitted instructions parsed from an executable.
-class InstructionReceptor {
- public:
-  InstructionReceptor() = default;
-  virtual ~InstructionReceptor() = default;
-
-  // Generates an entire base relocation table.
-  virtual CheckBool EmitPeRelocs() = 0;
-
-  // Generates an ELF style relocation table for X86.
-  virtual CheckBool EmitElfRelocation() = 0;
-
-  // Generates an ELF style relocation table for ARM.
-  virtual CheckBool EmitElfARMRelocation() = 0;
-
-  // Following instruction will be assembled at address 'rva'.
-  virtual CheckBool EmitOrigin(RVA rva) = 0;
-
-  // Generates a single byte of data or machine instruction.
-  virtual CheckBool EmitSingleByte(uint8_t byte) = 0;
-
-  // Generates multiple bytes of data or machine instructions.
-  virtual CheckBool EmitMultipleBytes(const uint8_t* bytes, size_t len) = 0;
-
-  // Generates a 4-byte relative reference to address of 'label'.
-  virtual CheckBool EmitRel32(Label* label) = 0;
-
-  // Generates a 4-byte relative reference to address of 'label' for ARM.
-  virtual CheckBool EmitRel32ARM(uint16_t op,
-                                 Label* label,
-                                 const uint8_t* arm_op,
-                                 uint16_t op_size) = 0;
-
-  // Generates a 4-byte absolute reference to address of 'label'.
-  virtual CheckBool EmitAbs32(Label* label) = 0;
-
-  // Generates an 8-byte absolute reference to address of 'label'.
-  virtual CheckBool EmitAbs64(Label* label) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(InstructionReceptor);
-};
-
 // An AssemblyProgram is the result of disassembling an executable file.
 //
 // * The disassembler creates labels in the AssemblyProgram and emits
 //   'Instructions'.
 // * The disassembler then calls DefaultAssignIndexes to assign
 //   addresses to positions in the address tables.
 // * [Optional step]
 // * At this point the AssemblyProgram can be converted into an
 //   EncodedProgram and serialized to an output stream.
 // * Later, the EncodedProgram can be deserialized and assembled into
 //   the original file.
 //
 // The optional step is to modify the AssemblyProgram.  One form of modification
 // is to assign indexes in such a way as to make the EncodedProgram for this
 // AssemblyProgram look more like the EncodedProgram for some other
 // AssemblyProgram.  The modification process should call UnassignIndexes, do
 // its own assignment, and then call AssignRemainingIndexes to ensure all
 // indexes are assigned.
 
 class AssemblyProgram {
  public:
   using LabelHandler = base::Callback<void(Label*)>;
   using LabelHandlerMap = std::map<OP, LabelHandler>;
 
-  // A callback for GenerateInstructions() to emit instructions. The first
-  // argument (AssemblyProgram*) is provided for Label-related feature access.
-  // The second argument (InstructionReceptor*) is a receptor for instructions.
-  // The callback (which gets called in 2 passes) should return true on success,
-  // and false otherwise.
-  using InstructionGenerator =
-      base::Callback<CheckBool(AssemblyProgram*, InstructionReceptor*)>;
-
   AssemblyProgram(ExecutableType kind, uint64_t image_base);
   ~AssemblyProgram();
 
   ExecutableType kind() const { return kind_; }
 
   // Traverses RVAs in |abs32_visitor| and |rel32_visitor| to precompute Labels.
   void PrecomputeLabels(RvaVisitor* abs32_visitor, RvaVisitor* rel32_visitor);
 
   // Removes underused Labels. Thresholds used (0 = no trimming) is
   // architecture-dependent.
@@ skipping 93 matching lines @@
 
 // Converts |program| into encoded form, returning it as |*output|.
 // Returns C_OK if succeeded, otherwise returns an error status and sets
 // |*output| to null.
 Status Encode(const AssemblyProgram& program,
               std::unique_ptr<EncodedProgram>* output);
 
 }  // namespace courgette
 
 #endif  // COURGETTE_ASSEMBLY_PROGRAM_H_