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

courgette/disassembler_win32_x86.cc

 // Copyright (c) 2011 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_x86.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 90 matching lines @@
 
 std::string DisassemblerWin32X86::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* DisassemblerWin32X86::CreateAbs32TargetRvaVisitor() {
+  return new RvaVisitor_Abs32(abs32_locations_, *this);
+}
+
+RvaVisitor* DisassemblerWin32X86::CreateRel32TargetRvaVisitor() {
+  return new RvaVisitor_Rel32(rel32_locations_, *this);
+}
+
+void DisassemblerWin32X86::RemoveUnusedRel32Locations(

[Will Harris, 2016/05/04 18:02:26]

hmm I wonder if a future refactor could introduce DisassemblerWin32 to sit
between DisassemblerWin32X86/DisassemblerWin32X64 and Disassembler since parts
of this code is now looking very similar between the two.

[huangs, 2016/05/04 19:33:59]

Yup!  That's planned in go/courgette-ideas-2016 under "Deduping x86 and x64
Parsing Code".  

+    AssemblyProgram* program) {
+  auto cond = [this, program](RVA rva) -> bool {
+    RVA target_rva = rva + 4 + Read32LittleEndian(RVAToPointer(rva));

[Will Harris, 2016/05/04 18:02:26]

can you explain this +4?

[huangs, 2016/05/04 19:33:59]

Added comment. Also updating rel32_finder_win32_x86.cc for consistency.

+    return program->FindRel32Label(target_rva) == nullptr;
+  };
+  rel32_locations_.erase(
+      std::remove_if(rel32_locations_.begin(), rel32_locations_.end(), cond),
+      rel32_locations_.end());
+}
+
 CheckBool DisassemblerWin32X86::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 161 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->EmitAbs32(program->FindOrMakeAbs32Label(target_rva)))
+      Label* label = program->FindAbs32Label(target_rva);
+      DCHECK(label);
+      if (!program->EmitAbs32(label))
         return false;
       p += 4;
       continue;
     }
 
     while (rel32_pos != rel32_locations_.end() && *rel32_pos < current_rva)
       ++rel32_pos;
 
     if (rel32_pos != rel32_locations_.end() && *rel32_pos == current_rva) {
       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