[Courgette] Refactor LabelManager.

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>
 
+#include <iterator>
+#include <vector>
+
 // COURGETTE_HISTOGRAM_TARGETS prints out a histogram of how frequently
 // different target addresses are referenced. Purely for debugging.
 #define COURGETTE_HISTOGRAM_TARGETS 0
 
 namespace courgette {
 
 // There are several ways to reason about addresses in an image:
 // - File Offset: Position relative to start of image.
 // - VA (Virtual Address): Virtual memory address of a loaded image. This is
 //   subject to relocation by the OS.
@@ skipping 62 matching lines @@
   bool operator==(const Label& other) const {
     return rva_ == other.rva_ && index_ == other.index_ &&
            count_ == other.count_;
   }
 
   RVA rva_ = kUnassignedRVA;  // Address referred to by the label.
   int index_ = kNoIndex;  // Index of address in address table.
   int32_t count_ = 0;
 };
 
+// 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:
+  // 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()) {}
+
+  // 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.

[huangs, 2016/04/04 14:30:58]

We'll reuse it in adjustment_method_unittest.cc -- otherwise this could have
just been in label_manager_unittests.cc.

+class TrivialRvaVisitor : public VectorRvaVisitor<RVA> {
+ public:
+  explicit TrivialRvaVisitor(const std::vector<RVA>& rvas)
+      : VectorRvaVisitor<RVA>(rvas) {}
+
+  // 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);
 }
 
 inline uint32_t ReadU32(const uint8_t* address, size_t offset) {
   return *reinterpret_cast<const uint32_t*>(address + offset);
 }
 
 inline uint64_t ReadU64(const uint8_t* address, size_t offset) {
   return *reinterpret_cast<const uint64_t*>(address + offset);
 }
 
 inline uint16_t Read16LittleEndian(const void* address) {
   return *reinterpret_cast<const uint16_t*>(address);
 }
 
 inline uint32_t Read32LittleEndian(const void* address) {
   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_