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

courgette/assembly_program.h

 // 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.
 
 #ifndef COURGETTE_ASSEMBLY_PROGRAM_H_
 #define COURGETTE_ASSEMBLY_PROGRAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 105 matching lines @@
                          Label* label,
                          const uint8_t* arm_op,
                          uint16_t op_size) WARN_UNUSED_RESULT;
 
   // Generates 4-byte absolute reference to address of 'label'.
   CheckBool EmitAbs32(Label* label) WARN_UNUSED_RESULT;
 
   // Generates 8-byte absolute reference to address of 'label'.
   CheckBool EmitAbs64(Label* label) WARN_UNUSED_RESULT;
 
-  // Looks up a label or creates a new one.  Might return NULL.
-  Label* FindOrMakeAbs32Label(RVA rva);
+  // Traverses RVAs in |abs32_visitor| and |rel32_visitor| to precompute Labels.
+  void PrecomputeLabels(RvaVisitor* abs32_visitor, RvaVisitor* rel32_visitor);
 
-  // Looks up a label or creates a new one.  Might return NULL.
-  Label* FindOrMakeRel32Label(RVA rva);
+  // Removes underused Labels. Thresholds used (0 = no trimming) is
+  // architecture-dependent.
+  void TrimLabels();
 
+  void UnassignIndexes();
   void DefaultAssignIndexes();
-  void UnassignIndexes();
   void AssignRemainingIndexes();
 
+  // Looks up abs32 label. Returns null if none found.
+  Label* FindAbs32Label(RVA rva);
+
+  // Looks up rel32 label. Returns null if none found.
+  Label* FindRel32Label(RVA rva);
+
   std::unique_ptr<EncodedProgram> Encode() const;
 
   // Accessor for instruction list.
   const InstructionVector& instructions() const {
     return instructions_;
   }
 
   // Returns the label if the instruction contains an absolute 32-bit address,
   // otherwise returns NULL.
   Label* InstructionAbs32Label(const Instruction* instruction) const;
 
   // Returns the label if the instruction contains an absolute 64-bit address,
   // otherwise returns NULL.
   Label* InstructionAbs64Label(const Instruction* instruction) const;
 
   // Returns the label if the instruction contains a rel32 offset,
   // otherwise returns NULL.
   Label* InstructionRel32Label(const Instruction* instruction) const;
 
-  // Removes underused Labels. Thresholds used (may be 0, i.e., no trimming) is
-  // dependent on architecture. Returns true on success, and false otherwise.
-  CheckBool TrimLabels();
-
  private:
   using ScopedInstruction =
       std::unique_ptr<Instruction, UncheckedDeleter<Instruction>>;
 
   ExecutableType kind_;
 
   CheckBool Emit(ScopedInstruction instruction) WARN_UNUSED_RESULT;
   CheckBool EmitShared(Instruction* instruction) WARN_UNUSED_RESULT;
 
   static const int kLabelLowerLimit;
 
   // Looks up a label or creates a new one.  Might return NULL.
   Label* FindLabel(RVA rva, RVAToLabel* labels);
 
   // Helper methods for the public versions.
   static void UnassignIndexes(RVAToLabel* labels);
   static void DefaultAssignIndexes(RVAToLabel* labels);
   static void AssignRemainingIndexes(RVAToLabel* labels);
 
   // Sharing instructions that emit a single byte saves a lot of space.
   Instruction* GetByteInstruction(uint8_t byte);
   std::unique_ptr<Instruction* [], base::FreeDeleter> byte_instruction_cache_;
 
   uint64_t image_base_;  // Desired or mandated base address of image.
 
   InstructionVector instructions_;  // All the instructions in program.
 
-  // These are lookup maps to find the label associated with a given address.
-  // We have separate label spaces for addresses referenced by rel32 labels and
-  // abs32 labels.  This is somewhat arbitrary.
-  RVAToLabel rel32_labels_;
-  RVAToLabel abs32_labels_;
+  // Storage and lookup of Labels associated with target addresses. We use
+  // separate abs32 and rel32 labels.
+  LabelManager abs32_label_manager_;
+  LabelManager rel32_label_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(AssemblyProgram);
 };
 
 // Converts |program| into encoded form, returning it as |*output|.
 // Returns C_OK if succeeded, otherwise returns an error status and sets
 // |*output| to null.
 Status Encode(const AssemblyProgram& program,
               std::unique_ptr<EncodedProgram>* output);
 
 }  // namespace courgette
 
 #endif  // COURGETTE_ASSEMBLY_PROGRAM_H_