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

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 <utility>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 
 namespace courgette {
 
 namespace {
 
 // Sorts |section_headers| by file offset and stores the resulting permutation
 // of section ids in |order|.
@@ skipping 151 matching lines @@
 
   if (!ParseAbs32Relocs())
     return false;
 
   if (!ParseRel32RelocsFromSections())  // Does not sort rel32 locations.
     return false;
 
   PrecomputeLabels(target);
   RemoveUnusedRel32Locations(target);
 
-  if (!ParseFile(target))
+  if (!target->GenerateInstructions(
+          base::Bind(&DisassemblerElf32::ParseFile, base::Unretained(this)))) {
     return false;
+  }
 
   // Finally sort rel32 locations.
   std::sort(rel32_locations_.begin(),
             rel32_locations_.end(),
             TypedRVA::IsLessThanByRVA);
   DCHECK(rel32_locations_.empty() ||
          rel32_locations_.back()->rva() != kUnassignedRVA);
 
   target->DefaultAssignIndexes();
   return true;
@@ skipping 100 matching lines @@
     if (string_pos >= default_string_section_size_)
       return false;
     // Safe because string section must terminate with null.
     *name = default_string_section_ + string_pos;
   }
   return true;
 }
 
 CheckBool DisassemblerElf32::RVAsToFileOffsets(
     const std::vector<RVA>& rvas,
-    std::vector<FileOffset>* file_offsets) {
+    std::vector<FileOffset>* file_offsets) const {
   file_offsets->clear();
   file_offsets->reserve(rvas.size());
   for (RVA rva : rvas) {
     FileOffset file_offset = RVAToFileOffset(rva);
     if (file_offset == kNoFileOffset)
       return false;
     file_offsets->push_back(file_offset);
   }
   return true;
 }
 
 CheckBool DisassemblerElf32::RVAsToFileOffsets(
-    std::vector<std::unique_ptr<TypedRVA>>* typed_rvas) {
+    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;
 }
 
 RvaVisitor* DisassemblerElf32::CreateAbs32TargetRvaVisitor() {
@@ skipping 15 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));
 }
 
-CheckBool DisassemblerElf32::ParseFile(AssemblyProgram* 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;
 
   std::vector<FileOffset> abs_offsets;
 
   // 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.
   if (!RVAsToFileOffsets(abs32_locations_, &abs_offsets))
     return false;
@@ skipping 13 matching lines @@
   std::vector<std::unique_ptr<TypedRVA>>::iterator end_rel =
       rel32_locations_.end();
 
   // Visit section headers ordered by file offset.
   for (Elf32_Half section_id : section_header_file_offset_order_) {
     const Elf32_Shdr* section_header = SectionHeader(section_id);
 
     if (section_header->sh_type == SHT_NOBITS)
       continue;
 
-    if (!ParseSimpleRegion(file_offset, section_header->sh_offset, program))
+    if (!ParseSimpleRegion(file_offset, section_header->sh_offset, receptor))
       return false;
 
     file_offset = section_header->sh_offset;
 
     switch (section_header->sh_type) {
       case SHT_REL:
-        if (!ParseRelocationSection(section_header, program))
+        if (!ParseRelocationSection(section_header, receptor))
           return false;
         file_offset = section_header->sh_offset + section_header->sh_size;
         break;
       case SHT_PROGBITS:
-        if (!ParseProgbitsSection(section_header,
-                                  &current_abs_offset,
-                                  end_abs_offset,
-                                  &current_rel,
-                                  end_rel,
-                                  program)) {
+        if (!ParseProgbitsSection(section_header, &current_abs_offset,
+                                  end_abs_offset, &current_rel, end_rel,
+                                  program, receptor)) {
           return false;
         }
         file_offset = section_header->sh_offset + section_header->sh_size;
         break;
       case SHT_INIT_ARRAY:
         // Fall through
       case SHT_FINI_ARRAY:
         while (current_abs_offset != end_abs_offset &&
                *current_abs_offset >= section_header->sh_offset &&
                *current_abs_offset <
@@ skipping 10 matching lines @@
             *current_abs_offset <
                 section_header->sh_offset + section_header->sh_size) {
           VLOG(1) << "Relocation address in unrecognized ELF section: "
                   << section_header->sh_type;
         }
         break;
     }
   }
 
   // Rest of the file past the last section
-  if (!ParseSimpleRegion(file_offset, length(), program))
+  if (!ParseSimpleRegion(file_offset, length(), receptor))
     return false;
 
   // Make certain we consume all of the relocations as expected
   return (current_abs_offset == end_abs_offset);
 }
 
 CheckBool DisassemblerElf32::ParseProgbitsSection(
     const Elf32_Shdr* section_header,
     std::vector<FileOffset>::iterator* current_abs_offset,
     std::vector<FileOffset>::iterator end_abs_offset,
     std::vector<std::unique_ptr<TypedRVA>>::iterator* current_rel,
     std::vector<std::unique_ptr<TypedRVA>>::iterator end_rel,
-    AssemblyProgram* program) {
+    AssemblyProgram* program,
+    InstructionReceptor* receptor) const {
   // Walk all the bytes in the file, whether or not in a section.
   FileOffset file_offset = section_header->sh_offset;
   FileOffset section_end = section_header->sh_offset + section_header->sh_size;
 
   Elf32_Addr origin = section_header->sh_addr;
   FileOffset origin_offset = section_header->sh_offset;
-  if (!program->EmitOriginInstruction(origin))
+  if (!receptor->EmitOrigin(origin))
     return false;
 
   while (file_offset < section_end) {
     if (*current_abs_offset != end_abs_offset &&
         file_offset > **current_abs_offset)
       return false;
 
     while (*current_rel != end_rel &&
            file_offset > (**current_rel)->file_offset()) {
       ++(*current_rel);
     }
 
     FileOffset next_relocation = section_end;
 
     if (*current_abs_offset != end_abs_offset &&
         next_relocation > **current_abs_offset)
       next_relocation = **current_abs_offset;
 
     // Rel offsets are heuristically derived, and might (incorrectly) overlap
     // an Abs value, or the end of the section, so +3 to make sure there is
     // room for the full 4 byte value.
     if (*current_rel != end_rel &&
         next_relocation > ((**current_rel)->file_offset() + 3))
       next_relocation = (**current_rel)->file_offset();
 
     if (next_relocation > file_offset) {
-      if (!ParseSimpleRegion(file_offset, next_relocation, program))
+      if (!ParseSimpleRegion(file_offset, next_relocation, receptor))
         return false;
 
       file_offset = next_relocation;
       continue;
     }
 
     if (*current_abs_offset != end_abs_offset &&
         file_offset == **current_abs_offset) {
       RVA target_rva = PointerToTargetRVA(FileOffsetToPointer(file_offset));
       DCHECK_NE(kNoRVA, target_rva);
 
       Label* label = program->FindAbs32Label(target_rva);
       CHECK(label);
-      if (!program->EmitAbs32(label))
+      if (!receptor->EmitAbs32(label))
         return false;
       file_offset += sizeof(RVA);
       ++(*current_abs_offset);
       continue;
     }
 
     if (*current_rel != end_rel &&
         file_offset == (**current_rel)->file_offset()) {
       uint32_t relative_target = (**current_rel)->relative_target();
       CHECK_EQ(RVA(origin + (file_offset - origin_offset)),
                (**current_rel)->rva());
       // This cast is for 64 bit systems, and is only safe because we
       // are working on 32 bit executables.
       RVA target_rva = (RVA)(origin + (file_offset - origin_offset) +
                              relative_target);
 
       Label* label = program->FindRel32Label(target_rva);
       CHECK(label);
 
-      if (!(**current_rel)->EmitInstruction(program, label))
+      if (!(**current_rel)->EmitInstruction(label, receptor))
         return false;
       file_offset += (**current_rel)->op_size();
       ++(*current_rel);
       continue;
     }
   }
 
   // Rest of the section (if any)
-  return ParseSimpleRegion(file_offset, section_end, program);
+  return ParseSimpleRegion(file_offset, section_end, receptor);
 }
 
-CheckBool DisassemblerElf32::ParseSimpleRegion(FileOffset start_file_offset,
-                                               FileOffset end_file_offset,
-                                               AssemblyProgram* program) {
+CheckBool DisassemblerElf32::ParseSimpleRegion(
+    FileOffset start_file_offset,
+    FileOffset end_file_offset,
+    InstructionReceptor* receptor) const {
   // Callers don't guarantee start < end
   if (start_file_offset >= end_file_offset)
     return true;
 
   const size_t len = end_file_offset - start_file_offset;
 
-  if (!program->EmitBytesInstruction(FileOffsetToPointer(start_file_offset),
-                                     len)) {
+  if (!receptor->EmitMultipleBytes(FileOffsetToPointer(start_file_offset),
+                                   len)) {
     return false;
   }
 
   return true;
 }
 
 CheckBool DisassemblerElf32::ParseAbs32Relocs() {
   abs32_locations_.clear();
 
   // Loop through sections for relocation sections
@@ skipping 75 matching lines @@
     if (!ParseRel32RelocsFromSection(section_header))
       return false;
   }
   if (!found_rel32)
     VLOG(1) << "Warning: Found no rel32 addresses. Missing .text section?";
 
   return true;
 }
 
 }  // namespace courgette