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

courgette/disassembler_elf_32.cc

 // 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.
 
 #include "courgette/disassembler_elf_32.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 145 matching lines @@
     if (default_string_section_[default_string_section_size_ - 1] != '\0')
       return Bad("String section does not terminate");
   }
 
   if (!UpdateLength())
     return Bad("Out of bounds section or segment");
 
   return Good();
 }
 
-bool DisassemblerElf32::Disassemble(AssemblyProgram* program) {
-  if (!ok())
-    return false;
-
-  if (!ParseAbs32Relocs())
-    return false;
-
-  if (!ParseRel32RelocsFromSections())  // Does not sort rel32 locations.
-    return false;
-
-  PrecomputeLabels(program);
-  RemoveUnusedRel32Locations(program);
-
-  if (!program->GenerateInstructions(
-          base::Bind(&DisassemblerElf32::ParseFile, base::Unretained(this)))) {
-    return false;
-  }
-
-  program->DefaultAssignIndexes();
-  return true;
-}
-
 CheckBool DisassemblerElf32::IsValidTargetRVA(RVA rva) const {
   if (rva == kUnassignedRVA)
     return false;
 
   // |rva| is valid if it's contained in any program segment.
   for (Elf32_Half segment_id = 0; segment_id < ProgramSegmentHeaderCount();
        ++segment_id) {
     const Elf32_Phdr* segment_header = ProgramSegmentHeader(segment_id);
 
     if (segment_header->p_type != PT_LOAD)
@@ skipping 111 matching lines @@
     std::vector<std::unique_ptr<TypedRVA>>* typed_rvas) const {
   for (auto& typed_rva : *typed_rvas) {
     FileOffset file_offset = RVAToFileOffset(typed_rva->rva());
     if (file_offset == kNoFileOffset)
       return false;
     typed_rva->set_file_offset(file_offset);
   }
   return true;
 }
 
-CheckBool DisassemblerElf32::ParseAbs32Relocs() {
+bool DisassemblerElf32::ExtractAbs32Locations() {
   abs32_locations_.clear();
 
   // Loop through sections for relocation sections
   for (Elf32_Half section_id = 0; section_id < SectionHeaderCount();
        ++section_id) {
     const Elf32_Shdr* section_header = SectionHeader(section_id);
 
     if (section_header->sh_type == SHT_REL) {
       const Elf32_Rel* relocs_table =
           reinterpret_cast<const Elf32_Rel*>(SectionBody(section_id));
@@ skipping 13 matching lines @@
           abs32_locations_.push_back(rva);
       }
     }
   }
 
   std::sort(abs32_locations_.begin(), abs32_locations_.end());
   DCHECK(abs32_locations_.empty() || abs32_locations_.back() != kUnassignedRVA);
   return true;
 }
 
-CheckBool DisassemblerElf32::ParseRel32RelocsFromSections() {
+bool DisassemblerElf32::ExtractRel32Locations() {
   rel32_locations_.clear();
   bool found_rel32 = false;
 
   // Loop through sections for relocation sections
   for (Elf32_Half section_id = 0; section_id < SectionHeaderCount();
        ++section_id) {
     const Elf32_Shdr* section_header = SectionHeader(section_id);
 
     // Some debug sections can have sh_type=SHT_PROGBITS but sh_addr=0.
     if (section_header->sh_type != SHT_PROGBITS || section_header->sh_addr == 0)
@@ skipping 40 matching lines @@
     } else {
       // Else squeeze nullptr to end to compactify.
       if (tail_it != head_it)
         (*tail_it).swap(*head_it);
       ++tail_it;
     }
   }
   rel32_locations_.resize(std::distance(rel32_locations_.begin(), tail_it));
 }
 
+InstructionGenerator DisassemblerElf32::GetInstructionGenerator(
+    AssemblyProgram* program) {
+  return base::Bind(&DisassemblerElf32::ParseFile, base::Unretained(this),
+                    program);
+}
+
 CheckBool DisassemblerElf32::ParseFile(AssemblyProgram* program,
                                        InstructionReceptor* receptor) const {
   // Walk all the bytes in the file, whether or not in a section.
   FileOffset file_offset = 0;
 
   // File parsing follows file offset order, and we visit abs32 and rel32
   // locations in lockstep. Therefore we need to extract and sort file offsets
   // of all abs32 and rel32 locations. For abs32, we copy the offsets to a new
   // array.
   std::vector<FileOffset> abs_offsets;
@@ skipping 202 matching lines @@
         case SHT_PROGBITS:
           return true;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace courgette