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

courgette/disassembler_elf_32_arm.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_arm.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 82 matching lines @@
       uint32_t j1 = (arm_op & (1 << 13)) >> 13;
       bool bit12 = ((arm_op & (1 << 12)) >> 12) != 0;  // D
       bool bit14 = ((arm_op & (1 << 14)) >> 14) != 0;  // C
 
       uint32_t i2 = ~(j2 ^ S) & 1;
       uint32_t i1 = ~(j1 ^ S) & 1;
       bool toARM =  bit14 && !bit12;
 
       temp |= (S << 24) | (i1 << 23) | (i2 << 22);
 
-      if (temp & 0x01000000) // sign extension
+      if (temp & 0x01000000)  // sign extension
         temp |= 0xFE000000;
       uint32_t prefetch;
       if (toARM) {
         // Align PC on 4-byte boundary.
         uint32_t align4byte = (rva % 4) ? 2 : 4;
         prefetch = align4byte;
       } else {
         prefetch = 4;
       }
       temp += prefetch;
@@ skipping 178 matching lines @@
       CheckBool ret = Compress(type_, pval, rva(), &c_op_, &relative_target);
       set_relative_target(relative_target);
       return ret;
     }
    default:
      return false;
   }
 }
 
 CheckBool DisassemblerElf32ARM::TypedRVAARM::EmitInstruction(
-    AssemblyProgram* program,
-    Label* label) {
-  return program->EmitRel32ARM(c_op(), label, arm_op_, op_size());
+    Label* label,
+    InstructionReceptor* receptor) {
+  return receptor->EmitRel32ARM(c_op(), label, arm_op_, op_size());
 }
 
 DisassemblerElf32ARM::DisassemblerElf32ARM(const uint8_t* start, size_t length)
     : DisassemblerElf32(start, length) {}
 
 // Convert an ELF relocation struction into an RVA.
 CheckBool DisassemblerElf32ARM::RelToRVA(Elf32_Rel rel, RVA* result) const {
   // The rightmost byte of r_info is the type.
   elf32_rel_arm_type_values type =
       static_cast<elf32_rel_arm_type_values>(rel.r_info & 0xFF);
@@ skipping 10 matching lines @@
       *result = rel.r_offset;
       return true;
 
     default:
       return false;
   }
 }
 
 CheckBool DisassemblerElf32ARM::ParseRelocationSection(
     const Elf32_Shdr* section_header,
-    AssemblyProgram* program) {
+    InstructionReceptor* receptor) const {
   // This method compresses a contiguous stretch of R_ARM_RELATIVE entries in
   // the relocation table with a Courgette relocation table instruction.
   // It skips any entries at the beginning that appear in a section that
   // Courgette doesn't support, e.g. INIT.
   //
   // Specifically, the entries should be
   //   (1) In the same relocation table
   //   (2) Are consecutive
   //   (3) Are sorted in memory address order
   //
@@ skipping 19 matching lines @@
   if (abs32_locations_.size() > section_relocs_count)
     match = false;
 
   if (!abs32_locations_.empty()) {
     std::vector<RVA>::iterator reloc_iter = abs32_locations_.begin();
 
     for (uint32_t i = 0; i < section_relocs_count; ++i) {
       if (section_relocs_iter->r_offset == *reloc_iter)
         break;
 
-      if (!ParseSimpleRegion(file_offset,
-                             file_offset + sizeof(Elf32_Rel),
-                             program)) {
+      if (!ParseSimpleRegion(file_offset, file_offset + sizeof(Elf32_Rel),
+                             receptor)) {
         return false;
       }
 
       file_offset += sizeof(Elf32_Rel);
       ++section_relocs_iter;
     }
 
     while (match && (reloc_iter != abs32_locations_.end())) {
       if (section_relocs_iter->r_info != R_ARM_RELATIVE ||
           section_relocs_iter->r_offset != *reloc_iter) {
         match = false;
       }
 
       ++section_relocs_iter;
       ++reloc_iter;
       file_offset += sizeof(Elf32_Rel);
     }
 
     if (match) {
       // Skip over relocation tables
-      if (!program->EmitElfARMRelocationInstruction())
+      if (!receptor->EmitElfARMRelocation())
         return false;
     }
   }
 
-  return ParseSimpleRegion(file_offset, section_end, program);
+  return ParseSimpleRegion(file_offset, section_end, receptor);
 }
 
 // TODO(huangs): Detect and avoid overlap with abs32 addresses.
 CheckBool DisassemblerElf32ARM::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 106 matching lines @@
       // Move 2 bytes at a time, but track 32-bit boundaries
       p += 2;
       on_32bit = ((on_32bit + 1) % 2) != 0;
     }
   }
 
   return true;
 }
 
 }  // namespace courgette