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

courgette/image_utils.h

 // Copyright 2015 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_IMAGE_UTILS_H_
 #define COURGETTE_IMAGE_UTILS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 83 matching lines @@
 };
 
 // An interface for sequential visit of RVAs.
 // Use case: Translating from RVA locations to RVA targets is platform-specific,
 // and works differently for abs32 vs. rel32. A function that sequentually
 // visits RVA targets only requires an RvaVisitor. The caller can provide an
 // implementation that stores a fixed list of RVA locations, and translates each
 // to the matching RVA target on demand without extra storage.
 class RvaVisitor {
  public:
+  virtual ~RvaVisitor() { }
+
   // Returns the number of remaining RVAs to visit.
   virtual size_t Remaining() const = 0;
 
   // Returns the current RVA.
   virtual RVA Get() const = 0;
 
   // Advances to the next RVA.
   virtual void Next() = 0;
 };
 
 // RvaVisitor whose data are backed by std::vector<T>. Translating from T to RVA
 // is should be implemented in Get().
 template <typename T>
 class VectorRvaVisitor : public RvaVisitor {
  public:
   // Assumes |v| does not change for the lifetime of this instance.
   explicit VectorRvaVisitor(const std::vector<T>& v)
-      : it_(v.begin()), end_(v.end()) {}
+      : it_(v.begin()), end_(v.end()) { }
+  ~VectorRvaVisitor() override { }
 
   // RvaVisitor interfaces.
   size_t Remaining() const override { return std::distance(it_, end_); }
   virtual RVA Get() const override = 0;
   void Next() override { ++it_; }
 
  protected:
   typename std::vector<T>::const_iterator it_;
   typename std::vector<T>::const_iterator end_;
 };
 
 // RvaVisitor that simply stores a list of RVAs for traversal. For testing.
 class TrivialRvaVisitor : public VectorRvaVisitor<RVA> {
  public:
   explicit TrivialRvaVisitor(const std::vector<RVA>& rvas)
-      : VectorRvaVisitor<RVA>(rvas) {}
+      : VectorRvaVisitor<RVA>(rvas) { }
+  ~TrivialRvaVisitor() override { }
 
   // VectorRvaVisitor<RVA> interfaces.
   RVA Get() const override { return *it_; }
 };
 
 // These helper functions avoid the need for casts in the main code.
 inline uint16_t ReadU16(const uint8_t* address, size_t offset) {
   return *reinterpret_cast<const uint16_t*>(address + offset);
 }
 
@@ skipping 13 matching lines @@
   return *reinterpret_cast<const uint32_t*>(address);
 }
 
 inline uint64_t Read64LittleEndian(const void* address) {
   return *reinterpret_cast<const uint64_t*>(address);
 }
 
 }  // namespace courgette
 
 #endif  // COURGETTE_IMAGE_UTILS_H_