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

courgette/disassembler_win32_x64.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_win32_x64.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 234 matching lines @@
   if (!ok())
     return false;
 
   target->set_image_base(image_base());
 
   if (!ParseAbs32Relocs())
     return false;
 
   ParseRel32RelocsFromSections();
 
+  PrecomputeLabels(target);
+  RemoveUnusedRel32Locations(target);
+
   if (!ParseFile(target))
     return false;
 
   target->DefaultAssignIndexes();
 
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 85 matching lines @@
 
 std::string DisassemblerWin32X64::SectionName(const Section* section) {
   if (section == nullptr)
     return "<none>";
   char name[9];
   memcpy(name, section->name, 8);
   name[8] = '\0';  // Ensure termination.
   return name;
 }
 
+RvaVisitor* DisassemblerWin32X64::CreateAbs32TargetRvaVisitor() {
+  return new RvaVisitor_Abs32(abs32_locations_, *this);
+}
+
+RvaVisitor* DisassemblerWin32X64::CreateRel32TargetRvaVisitor() {
+  return new RvaVisitor_Rel32(rel32_locations_, *this);
+}
+
+void DisassemblerWin32X64::RemoveUnusedRel32Locations(
+    AssemblyProgram* program) {
+  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 DisassemblerWin32X64::ParseFile(AssemblyProgram* program) {
   // 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);
       break;
@@ skipping 148 matching lines @@
       RVA rel32_rva = static_cast<RVA>(rel32 - adjust_pointer_to_rva);
 
       // Is there an abs32 reloc overlapping the candidate?
       while (abs32_pos != abs32_locations_.end() && *abs32_pos < rel32_rva - 3)
         ++abs32_pos;
       // Now: (*abs32_pos > rel32_rva - 4) i.e. the lowest addressed 4-byte
       // region that could overlap rel32_rva.
       if (abs32_pos != abs32_locations_.end()) {
         if (*abs32_pos < rel32_rva + 4) {
           // Beginning of abs32 reloc is before end of rel32 reloc so they
-          // overlap.  Skip four bytes past the abs32 reloc.
+          // overlap. Skip four bytes past the abs32 reloc.
           p += (*abs32_pos + 4) - current_rva;
           continue;
         }
       }
 
+      // + 4 since offset is relative to start of next instruction.
       RVA target_rva = rel32_rva + 4 + Read32LittleEndian(rel32);
       // To be valid, rel32 target must be within image, and within this
       // section.
       if (target_rva < size_of_image_ &&  // Subsumes rva != kUnassignedRVA.
           (is_rip_relative ||
            (start_rva <= target_rva && target_rva < end_rva))) {
         rel32_locations_.push_back(rel32_rva);
 #if COURGETTE_HISTOGRAM_TARGETS
         ++rel32_target_rvas_[target_rva];
 #endif
@@ skipping 63 matching lines @@
     }
 
     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.
-      if (!program->EmitAbs64(program->FindOrMakeAbs32Label(target_rva)))
+      Label* label = program->FindAbs32Label(target_rva);
+      DCHECK(label);
+      if (!program->EmitAbs64(label))
         return false;
       p += 8;
       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);
-      if (!program->EmitRel32(program->FindOrMakeRel32Label(target_rva)))
+      Label* label = program->FindRel32Label(target_rva);
+      DCHECK(label);
+      if (!program->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.
@@ skipping 111 matching lines @@
     directory->size_ = static_cast<uint32_t>(size);
     return true;
   } else {
     directory->address_ = 0;
     directory->size_ = 0;
     return true;
   }
 }
 
 }  // namespace courgette