[Courgette] Using LabelManager to reduce Courgette-apply peak RAM by 25%.

courgette/disassembler_elf_32.h

 // 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.
 
 #ifndef COURGETTE_DISASSEMBLER_ELF_32_H_
 #define COURGETTE_DISASSEMBLER_ELF_32_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
+#include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "courgette/disassembler.h"
 #include "courgette/image_utils.h"
 #include "courgette/memory_allocator.h"
 #include "courgette/types_elf.h"
 
 namespace courgette {
 
@@ skipping 22 matching lines @@
     FileOffset file_offset() const { return file_offset_; }
 
     void set_relative_target(RVA relative_target) {
       relative_target_ = relative_target;
     }
     void set_file_offset(FileOffset file_offset) { file_offset_ = file_offset; }
 
     // Computes the relative jump's offset from the op in p.
     virtual CheckBool ComputeRelativeTarget(const uint8_t* op_pointer) = 0;
 
-    // Emits the courgette instruction corresponding to the RVA type.
+    // Emits the assembly instruction corresponding to |label|.
     virtual CheckBool EmitInstruction(AssemblyProgram* program,
-                                      RVA target_rva) = 0;
+                                      Label* label) = 0;
 
     // Returns the size of the instruction containing the RVA.
     virtual uint16_t op_size() const = 0;
 
     // Comparator for sorting, which assumes uniqueness of RVAs.
     static bool IsLessThanByRVA(const std::unique_ptr<TypedRVA>& a,
                                 const std::unique_ptr<TypedRVA>& b) {
       return a->rva() < b->rva();
     }
 
     // Comparator for sorting, which assumes uniqueness of file offsets.
     static bool IsLessThanByFileOffset(const std::unique_ptr<TypedRVA>& a,
                                        const std::unique_ptr<TypedRVA>& b) {
       return a->file_offset() < b->file_offset();
     }
 
   private:
     const RVA rva_;
     RVA relative_target_ = kNoRVA;
     FileOffset file_offset_ = kNoFileOffset;
   };
 
+  // Visitor/adaptor to translate RVA to target RVA. This is the ELF
+  // counterpart to RvaVisitor_Rel32 that uses TypedRVA.
+  class Elf32RvaVisitor_Rel32 :
+  public VectorRvaVisitor<std::unique_ptr<TypedRVA>> {
+   public:
+    Elf32RvaVisitor_Rel32(
+        const std::vector<std::unique_ptr<TypedRVA>>& rva_locations);
+    ~Elf32RvaVisitor_Rel32() override { }
+
+    // VectorRvaVisitor<TypedRVA*> interfaces.
+    RVA Get() const override;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Elf32RvaVisitor_Rel32);
+  };
+
  public:
   DisassemblerElf32(const void* start, size_t length);
 
   ~DisassemblerElf32() override { }
 
   // Disassembler interfaces.
   RVA FileOffsetToRVA(FileOffset file_offset) const override;
   FileOffset RVAToFileOffset(RVA rva) const override;
   RVA PointerToTargetRVA(const uint8_t* p) const override;
   virtual ExecutableType kind() const override = 0;
   bool ParseHeader() override;
   bool Disassemble(AssemblyProgram* target) override;
 
   virtual e_machine_values ElfEM() const = 0;
 
+  CheckBool IsValidTargetRVA(RVA rva) const WARN_UNUSED_RESULT;
+
+  // Converts an ELF relocation instruction into an RVA.
+  virtual CheckBool RelToRVA(Elf32_Rel rel, RVA* result)
+    const WARN_UNUSED_RESULT = 0;
+
   // Public for unittests only
   std::vector<RVA>& Abs32Locations() { return abs32_locations_; }
   std::vector<std::unique_ptr<TypedRVA>>& Rel32Locations() {
     return rel32_locations_;
   }
 
  protected:
   bool UpdateLength();
 
   // Misc Section Helpers
@@ skipping 21 matching lines @@
     return program_header_table_size_;
   }
 
   const Elf32_Phdr* ProgramSegmentHeader(Elf32_Half id) const {
     assert(id >= 0 && id < ProgramSegmentHeaderCount());
     return program_header_table_ + id;
   }
 
   // Misc address space helpers
 
-  CheckBool IsValidTargetRVA(RVA rva) const WARN_UNUSED_RESULT;
-
-  // Converts an ELF relocation instruction into an RVA.
-  virtual CheckBool RelToRVA(Elf32_Rel rel, RVA* result)
-    const WARN_UNUSED_RESULT = 0;
-
   CheckBool RVAsToFileOffsets(const std::vector<RVA>& rvas,
                               std::vector<FileOffset>* file_offsets);
 
   CheckBool RVAsToFileOffsets(
       std::vector<std::unique_ptr<TypedRVA>>* typed_rvas);
 
   // Parsing code for Disassemble().
 
   virtual CheckBool ParseRelocationSection(const Elf32_Shdr* section_header,
                                            AssemblyProgram* program)
       WARN_UNUSED_RESULT = 0;
 
   virtual CheckBool ParseRel32RelocsFromSection(const Elf32_Shdr* section)
       WARN_UNUSED_RESULT = 0;
 
+  // Disassembler interfaces.
+  RvaVisitor* CreateAbs32TargetRvaVisitor() override;
+  RvaVisitor* CreateRel32TargetRvaVisitor() override;
+  void RemoveUnusedRel32Locations(AssemblyProgram* program) override;
+
   CheckBool ParseFile(AssemblyProgram* target) WARN_UNUSED_RESULT;
 
   CheckBool 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) WARN_UNUSED_RESULT;
 
@@ skipping 27 matching lines @@
 
   std::vector<RVA> abs32_locations_;
   std::vector<std::unique_ptr<TypedRVA>> rel32_locations_;
 
   DISALLOW_COPY_AND_ASSIGN(DisassemblerElf32);
 };
 
 }  // namespace courgette
 
 #endif  // COURGETTE_DISASSEMBLER_ELF_32_H_