[Courgette] Refactor: Add and use Instruction*Receptor classes; call ParseFile() in 2 passes.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 
 #if COURGETTE_HISTOGRAM_TARGETS
 #include <iostream>
 #endif
 
 namespace courgette {
 
@@ skipping 208 matching lines @@
   target->set_image_base(image_base());
 
   if (!ParseAbs32Relocs())
     return false;
 
   ParseRel32RelocsFromSections();
 
   PrecomputeLabels(target);
   RemoveUnusedRel32Locations(target);
 
-  if (!ParseFile(target))
+  if (!target->GenerateInstructions(
+          base::Bind(&DisassemblerWin32::ParseFile, base::Unretained(this)))) {
     return false;
+  }
 
   target->DefaultAssignIndexes();
-
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool DisassemblerWin32::ParseRelocs(std::vector<RVA>* relocs) {
   relocs->clear();
 
   size_t relocs_size = base_relocation_table_.size_;
   if (relocs_size == 0)
@@ skipping 126 matching lines @@
   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());
 }
 
-CheckBool DisassemblerWin32::ParseFile(AssemblyProgram* 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(), program);
+      //   ParseNonSectionFileRegion(file_offset, pe_info().length(), receptor);
       break;
     }
     if (file_offset < section->file_offset_of_raw_data) {
       FileOffset section_start_offset = section->file_offset_of_raw_data;
       if (!ParseNonSectionFileRegion(file_offset, section_start_offset,
-                                     program)) {
+                                     receptor)) {
         return false;
       }
 
       file_offset = section_start_offset;
     }
     FileOffset end = file_offset + section->size_of_raw_data;
-    if (!ParseFileRegion(section, file_offset, end, program))
+    if (!ParseFileRegion(section, file_offset, end, program, receptor))
       return false;
     file_offset = end;
   }
 
 #if COURGETTE_HISTOGRAM_TARGETS
   HistogramTargets("abs32 relocs", abs32_target_rvas_);
   HistogramTargets("rel32 relocs", rel32_target_rvas_);
 #endif
 
   return true;
@@ skipping 49 matching lines @@
       ++rel32_iter;
     }
   }
   VLOG(1) << "common " << common;
 #endif
 }
 
 CheckBool DisassemblerWin32::ParseNonSectionFileRegion(
     FileOffset start_file_offset,
     FileOffset end_file_offset,
-    AssemblyProgram* program) {
+    InstructionReceptor* receptor) const {
   if (incomplete_disassembly_)
     return true;
 
   if (end_file_offset > start_file_offset) {
-    if (!program->EmitBytesInstruction(FileOffsetToPointer(start_file_offset),
-                                       end_file_offset - start_file_offset)) {
+    if (!receptor->EmitMultipleBytes(FileOffsetToPointer(start_file_offset),
+                                     end_file_offset - start_file_offset)) {
       return false;
     }
   }
 
   return true;
 }
 
-CheckBool DisassemblerWin32::ParseFileRegion(const Section* section,
-                                             FileOffset start_file_offset,
-                                             FileOffset end_file_offset,
-                                             AssemblyProgram* program) {
+CheckBool DisassemblerWin32::ParseFileRegion(
+    const Section* section,
+    FileOffset start_file_offset,
+    FileOffset end_file_offset,
+    AssemblyProgram* program,
+    InstructionReceptor* receptor) const {
   RVA relocs_start_rva = base_relocation_table().address_;
 
   const uint8_t* start_pointer = FileOffsetToPointer(start_file_offset);
   const uint8_t* end_pointer = FileOffsetToPointer(end_file_offset);
 
   RVA start_rva = FileOffsetToRVA(start_file_offset);
   RVA end_rva = start_rva + section->virtual_size;
   const int kVAWidth = AbsVAWidth();
 
   // Quick way to convert from Pointer to RVA within a single Section is to
   // subtract 'pointer_to_rva'.
   const uint8_t* const adjust_pointer_to_rva = start_pointer - start_rva;
 
-  std::vector<RVA>::iterator rel32_pos = rel32_locations_.begin();
-  std::vector<RVA>::iterator abs32_pos = abs32_locations_.begin();
+  std::vector<RVA>::const_iterator rel32_pos = rel32_locations_.begin();
+  std::vector<RVA>::const_iterator abs32_pos = abs32_locations_.begin();
 
-  if (!program->EmitOriginInstruction(start_rva))
+  if (!receptor->EmitOrigin(start_rva))
     return false;
 
   const uint8_t* p = start_pointer;
 
   while (p < end_pointer) {
     RVA current_rva = static_cast<RVA>(p - adjust_pointer_to_rva);
 
     // The base relocation table is usually in the .relocs section, but it could
     // actually be anywhere.  Make sure we skip it because we will regenerate it
     // during assembly.
     if (current_rva == relocs_start_rva) {
-      if (!program->EmitPeRelocsInstruction())
+      if (!receptor->EmitPeRelocs())
         return false;
       uint32_t relocs_size = base_relocation_table().size_;
       if (relocs_size) {
         p += relocs_size;
         continue;
       }
     }
 
     while (abs32_pos != abs32_locations_.end() && *abs32_pos < current_rva)
       ++abs32_pos;
 
     if (abs32_pos != abs32_locations_.end() && *abs32_pos == current_rva) {
       RVA target_rva = PointerToTargetRVA(p);
       DCHECK_NE(kNoRVA, target_rva);
       // TODO(sra): target could be Label+offset.  It is not clear how to guess
       // which it might be.  We assume offset==0.
       Label* label = program->FindAbs32Label(target_rva);
       DCHECK(label);
-      if (!EmitAbs(label, program))
+      if (!EmitAbs(label, receptor))
         return false;
       p += kVAWidth;
       continue;
     }
 
     while (rel32_pos != rel32_locations_.end() && *rel32_pos < current_rva)
       ++rel32_pos;
 
     if (rel32_pos != rel32_locations_.end() && *rel32_pos == current_rva) {
       // + 4 since offset is relative to start of next instruction.
       RVA target_rva = current_rva + 4 + Read32LittleEndian(p);
       Label* label = program->FindRel32Label(target_rva);
       DCHECK(label);
-      if (!program->EmitRel32(label))
+      if (!receptor->EmitRel32(label))
         return false;
       p += 4;
       continue;
     }
 
     if (incomplete_disassembly_) {
       if ((abs32_pos == abs32_locations_.end() || end_rva <= *abs32_pos) &&
           (rel32_pos == rel32_locations_.end() || end_rva <= *rel32_pos) &&
           (end_rva <= relocs_start_rva || current_rva >= relocs_start_rva)) {
         // No more relocs in this section, don't bother encoding bytes.
         break;
       }
     }
 
-    if (!program->EmitByteInstruction(*p))
+    if (!receptor->EmitSingleByte(*p))
       return false;
     p += 1;
   }
 
   return true;
 }
 
 #if COURGETTE_HISTOGRAM_TARGETS
 // Histogram is printed to std::cout.  It is purely for debugging the algorithm
 // and is only enabled manually in 'exploration' builds.  I don't want to add
 // command-line configuration for this feature because this code has to be
 // small, which means compiled-out.
 void DisassemblerWin32::HistogramTargets(const char* kind,
-                                         const std::map<RVA, int>& map) {
+                                         const std::map<RVA, int>& map) const {
   int total = 0;
   std::map<int, std::vector<RVA>> h;
   for (std::map<RVA, int>::const_iterator p = map.begin(); p != map.end();
        ++p) {
     h[p->second].push_back(p->first);
     total += p->second;
   }
 
   std::cout << total << " " << kind << " to " << map.size() << " unique targets"
             << std::endl;
@@ skipping 76 matching lines @@
     directory->size_ = static_cast<uint32_t>(size);
     return true;
   } else {
     directory->address_ = 0;
     directory->size_ = 0;
     return true;
   }
 }
 
 }  // namespace courgette