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

courgette/disassembler_elf_32.h

 // Copyright 2013 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_DISASSEMBLER_ELF_32_H_
 #define COURGETTE_DISASSEMBLER_ELF_32_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "courgette/disassembler.h"
 #include "courgette/image_utils.h"
+#include "courgette/instruction_utils.h"
 #include "courgette/memory_allocator.h"
 #include "courgette/types_elf.h"
 
 namespace courgette {
 
 class AssemblyProgram;
-class InstructionReceptor;
 
 // A Courgette disassembler for 32-bit ELF files. This is only a partial
 // implementation that admits subclasses for the architecture-specific parts of
 // 32-bit ELF file processing. Specifically:
 // - RelToRVA() processes entries in ELF relocation table.
 // - ParseRelocationSection() verifies the organization of the ELF relocation
 //   table.
 // - ParseRel32RelocsFromSection() finds branch targets by looking for relative
 //   branch/call opcodes in the particular architecture's machine code.
 class DisassemblerElf32 : public Disassembler {
@@ skipping 64 matching lines @@
 
   ~DisassemblerElf32() override { }
 
   // Disassembler interfaces.
   RVA FileOffsetToRVA(FileOffset file_offset) const override;
   FileOffset RVAToFileOffset(RVA rva) const override;
   RVA PointerToTargetRVA(const uint8_t* p) const override;
   ExecutableType kind() const override = 0;
   uint64_t image_base() const override { return 0; }
   bool ParseHeader() override;
-  bool Disassemble(AssemblyProgram* program) override;
 
   virtual e_machine_values ElfEM() const = 0;
 
   CheckBool IsValidTargetRVA(RVA rva) const WARN_UNUSED_RESULT;
 
   // Converts an ELF relocation instruction into an RVA.
   virtual CheckBool RelToRVA(Elf32_Rel rel, RVA* result)
     const WARN_UNUSED_RESULT = 0;
 
   // Public for unittests only
@@ skipping 43 matching lines @@
   }
 
   // Misc address space helpers
 
   CheckBool RVAsToFileOffsets(const std::vector<RVA>& rvas,
                               std::vector<FileOffset>* file_offsets) const;
 
   CheckBool RVAsToFileOffsets(
       std::vector<std::unique_ptr<TypedRVA>>* typed_rvas) const;
 
-  // Parsing code for Disassemble().
+  // Helpers for ParseFile().
 
   virtual CheckBool ParseRelocationSection(const Elf32_Shdr* section_header,
                                            InstructionReceptor* receptor) const
       WARN_UNUSED_RESULT = 0;
 
   virtual CheckBool ParseRel32RelocsFromSection(const Elf32_Shdr* section)
       WARN_UNUSED_RESULT = 0;
 
   CheckBool ParseAbs32Relocs() WARN_UNUSED_RESULT;
 
   // Extracts all rel32 TypedRVAs. Does not sort the result.
   CheckBool ParseRel32RelocsFromSections() WARN_UNUSED_RESULT;
 
   // Disassembler interfaces.
+  bool ExtractAbs32Locations() override;
+  bool ExtractRel32Locations() override;
   RvaVisitor* CreateAbs32TargetRvaVisitor() override;
   RvaVisitor* CreateRel32TargetRvaVisitor() override;
   void RemoveUnusedRel32Locations(AssemblyProgram* program) override;
+  InstructionGenerator GetInstructionGenerator(
+      AssemblyProgram* program) override;
 
   CheckBool ParseFile(AssemblyProgram* target,
                       InstructionReceptor* receptor) const WARN_UNUSED_RESULT;
 
   CheckBool ParseProgbitsSection(
       const Elf32_Shdr* section_header,
       std::vector<FileOffset>::iterator* current_abs_offset,
       std::vector<FileOffset>::iterator end_abs_offset,
       std::vector<std::unique_ptr<TypedRVA>>::iterator* current_rel,
       std::vector<std::unique_ptr<TypedRVA>>::iterator end_rel,
@@ skipping 17 matching lines @@
   // An ordering of |section_header_table_|, sorted by file offset.
   std::vector<Elf32_Half> section_header_file_offset_order_;
 
   const Elf32_Phdr* program_header_table_;
   Elf32_Half program_header_table_size_;
 
   // Pointer to string table containing section names.
   const char* default_string_section_;
   size_t default_string_section_size_;
 
-  // Sorted abs32 and reel32 RVAs. These are mutable because ParseFile() needs
-  // to sort these by file offsets.
-  mutable std::vector<RVA> abs32_locations_;
+  // Sorted abs32 RVAs.
+  std::vector<RVA> abs32_locations_;
+  // Sorted rel32 RVAs. This is mutable because ParseFile() temporarily sorts
+  // these by file offsets.
   mutable std::vector<std::unique_ptr<TypedRVA>> rel32_locations_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisassemblerElf32);
 };
 
 }  // namespace courgette
 
 #endif  // COURGETTE_DISASSEMBLER_ELF_32_H_