[Courgette] Clean up Disassembler; fix ELF Memory leaks.

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>
 
 // 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 {
 
-typedef uint32_t RVA;
+// 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.
+// - RVA (Relative Virtual Address): VA relative to base address, and is the
+//   preferred address for pointers in an image.
+// In Courgette we are mostly interested in FILE Offsets and RVAs.
+
+using RVA = uint32_t;
 const RVA kUnassignedRVA = 0xFFFFFFFFU;
+const RVA kNoRVA = 0xFFFFFFFFU;
+
+using FileOffset = size_t;
+const FileOffset kNoFileOffset = UINTPTR_MAX;
+
+// An interface for {RVA, File Offset, pointer to image data} translation.
+class AddressTranslator {
+ public:
+  // Returns the RVA corresponding to |file_offset|, or kNoRVA if nonexistent.
+  virtual RVA FileOffsetToRVA(FileOffset file_offset) const = 0;
+
+  // Returns the file offset corresponding to |rva|, or kFileNoOffset if
+  // nonexistent.
+  virtual FileOffset RVAToFileOffset(RVA rva) const = 0;
+
+  // Returns the pointer to the image data for |file_offset|. Assumes that
+  // 0 <= |file_offset| <= image size. We allow |file_offset| == image size to
+  // enable "end" bound for iteration.
+  virtual const uint8_t* FileOffsetToPointer(FileOffset file_offset) const = 0;
+
+  // Returns the pointer to the image data for |rva|, or null if |rva| is
+  // invalid.
+  virtual const uint8_t* RVAToPointer(RVA rva) const = 0;
+};
 
 // A Label is a symbolic reference to an address.  Unlike a conventional
 // assembly language, we always know the address.  The address will later be
 // stored in a table and the Label will be replaced with the index into the
 // table.
 // TODO(huangs): Make this a struct, and remove "_" from member names.
 class Label {
  public:
   enum : int { kNoIndex = -1 };
   explicit Label(RVA rva) : rva_(rva) {}
@@ skipping 32 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_