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

courgette/disassembler_elf_32_x86.cc

 // Copyright (c) 2012 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_x86.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 
 namespace courgette {
 
 CheckBool DisassemblerElf32X86::TypedRVAX86::ComputeRelativeTarget(
     const uint8_t* op_pointer) {
   set_relative_target(Read32LittleEndian(op_pointer) + 4);
   return true;
 }
 
 CheckBool DisassemblerElf32X86::TypedRVAX86::EmitInstruction(
-    AssemblyProgram* program,
-    Label* label) {
-  return program->EmitRel32(label);
+    Label* label,
+    InstructionReceptor* receptor) {
+  return receptor->EmitRel32(label);
 }
 
 uint16_t DisassemblerElf32X86::TypedRVAX86::op_size() const {
   return 4;
 }
 
 DisassemblerElf32X86::DisassemblerElf32X86(const uint8_t* start, size_t length)
     : DisassemblerElf32(start, length) {}
 
 // Convert an ELF relocation struction into an RVA.
@@ skipping 28 matching lines @@
     case R_386_GOTPC:
     case R_386_TLS_TPOFF:
       return false;
   }
 
   return false;
 }
 
 CheckBool DisassemblerElf32X86::ParseRelocationSection(
     const Elf32_Shdr* section_header,
-    AssemblyProgram* program) {
+    InstructionReceptor* receptor) const {
   // We can reproduce the R_386_RELATIVE entries in one of the relocation table
   // based on other information in the patch, given these conditions:
   //
   // All R_386_RELATIVE entries are:
   //   1) In the same relocation table
   //   2) Are consecutive
   //   3) Are sorted in memory address order
   //
   // Happily, this is normally the case, but it's not required by spec, so we
   // check, and just don't do it if we don't match up.
@@ skipping 26 matching lines @@
     if (section_relocs_iter->r_info != R_386_RELATIVE ||
         section_relocs_iter->r_offset != *reloc_iter) {
       match = false;
     }
     ++section_relocs_iter;
     ++reloc_iter;
   }
 
   if (match) {
     // Skip over relocation tables.
-    if (!program->EmitElfRelocationInstruction())
+    if (!receptor->EmitElfRelocation())
       return false;
     file_offset += sizeof(Elf32_Rel) * abs32_locations_.size();
   }
 
-  return ParseSimpleRegion(file_offset, section_end, program);
+  return ParseSimpleRegion(file_offset, section_end, receptor);
 }
 
 CheckBool DisassemblerElf32X86::ParseRel32RelocsFromSection(
     const Elf32_Shdr* section_header) {
   FileOffset start_file_offset = section_header->sh_offset;
   FileOffset end_file_offset = start_file_offset + section_header->sh_size;
 
   const uint8_t* start_pointer = FileOffsetToPointer(start_file_offset);
   const uint8_t* end_pointer = FileOffsetToPointer(end_file_offset);
 
@@ skipping 55 matching lines @@
         continue;
       }
     }
     p += 1;
   }
 
   return true;
 }
 
 }  // namespace courgette