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

courgette/disassembler_win32.cc

 // Copyright 2016 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_win32.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 203 matching lines @@
   // Pretend our in-memory copy is only as long as our detected length.
   ReduceLength(detected_length);
 
   if (!has_text_section()) {
     return Bad("Resource-only executables are not yet supported");
   }
 
   return Good();
 }
 
-bool DisassemblerWin32::Disassemble(AssemblyProgram* program) {
-  if (!ok())
-    return false;
-
-  if (!ParseAbs32Relocs())
-    return false;
-
-  ParseRel32RelocsFromSections();
-
-  PrecomputeLabels(program);
-  RemoveUnusedRel32Locations(program);
-
-  if (!program->GenerateInstructions(
-          base::Bind(&DisassemblerWin32::ParseFile, base::Unretained(this)))) {
-    return false;
-  }
-
-  program->DefaultAssignIndexes();
-  return true;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 bool DisassemblerWin32::ParseRelocs(std::vector<RVA>* relocs) {
   relocs->clear();
 
   size_t relocs_size = base_relocation_table_.size_;
   if (relocs_size == 0)
     return true;
 
   // The format of the base relocation table is a sequence of variable sized
@@ skipping 103 matching lines @@
   const uint8_t* optional_header = pe_header + 4 + kSizeOfCoffHeader;
   // Check we can read the magic.
   if (optional_header + 2 >= start + length)
     return false;
   if (magic != ReadU16(optional_header, 0))
     return false;
 
   return true;
 }
 
-bool DisassemblerWin32::ParseAbs32Relocs() {
+bool DisassemblerWin32::ExtractAbs32Locations() {
   abs32_locations_.clear();
   if (!ParseRelocs(&abs32_locations_))
     return false;
 
 #if COURGETTE_HISTOGRAM_TARGETS
   for (size_t i = 0; i < abs32_locations_.size(); ++i) {
     RVA rva = abs32_locations_[i];
     // The 4 bytes at the relocation are a reference to some address.
     ++abs32_target_rvas_[PointerToTargetRVA(RVAToPointer(rva))];
   }
 #endif
   return true;
 }
 
-void DisassemblerWin32::ParseRel32RelocsFromSections() {
+bool DisassemblerWin32::ExtractRel32Locations() {
   FileOffset file_offset = 0;
   while (file_offset < length()) {
     const Section* section = FindNextSection(file_offset);
     if (section == nullptr)
       break;
     if (file_offset < section->file_offset_of_raw_data)
       file_offset = section->file_offset_of_raw_data;
     ParseRel32RelocsFromSection(section);
     file_offset += section->size_of_raw_data;
   }
@@ skipping 16 matching lines @@
     } else if (rel32_iter->first < abs32_iter->first) {
       ++rel32_iter;
     } else {
       ++common;
       ++abs32_iter;
       ++rel32_iter;
     }
   }
   VLOG(1) << "common " << common;
 #endif
+  return true;
 }
 
 RvaVisitor* DisassemblerWin32::CreateAbs32TargetRvaVisitor() {
   return new RvaVisitor_Abs32(abs32_locations_, *this);
 }
 
 RvaVisitor* DisassemblerWin32::CreateRel32TargetRvaVisitor() {
   return new RvaVisitor_Rel32(rel32_locations_, *this);
 }
 
 void DisassemblerWin32::RemoveUnusedRel32Locations(
     AssemblyProgram* program) {
   auto cond = [this, program](RVA rva) -> bool {
     // + 4 since offset is relative to start of next instruction.
     RVA target_rva = rva + 4 + Read32LittleEndian(RVAToPointer(rva));
     return program->FindRel32Label(target_rva) == nullptr;
   };
   rel32_locations_.erase(
       std::remove_if(rel32_locations_.begin(), rel32_locations_.end(), cond),
       rel32_locations_.end());
 }
 
+InstructionGenerator DisassemblerWin32::GetInstructionGenerator(
+    AssemblyProgram* program) {
+  return base::Bind(&DisassemblerWin32::ParseFile, base::Unretained(this),
+                    program);
+}
+
 CheckBool DisassemblerWin32::ParseFile(AssemblyProgram* program,
                                        InstructionReceptor* receptor) const {
   // Walk all the bytes in the file, whether or not in a section.
   FileOffset file_offset = 0;
   while (file_offset < length()) {
     const Section* section = FindNextSection(file_offset);
     if (section == nullptr) {
       // No more sections. There should not be extra stuff following last
       // section.
       //   ParseNonSectionFileRegion(file_offset, pe_info().length(), receptor);
@@ skipping 225 matching lines @@
     directory->size_ = static_cast<uint32_t>(size);
     return true;
   } else {
     directory->address_ = 0;
     directory->size_ = 0;
     return true;
   }
 }
 
 }  // namespace courgette