1 files changed, 14 insertions, 15 deletions

diff --git a/include/llvm/Support/MemoryObject.h b/include/llvm/Support/MemoryObject.h
index f8f29be5a7..8368965b9c 100644
--- a/include/llvm/Support/MemoryObject.h
+++ b/include/llvm/Support/MemoryObject.h
@@ -19,21 +19,21 @@ namespace llvm {
 ///   file, or on a remote machine.
 class MemoryObject {
 public:
-  /// Constructor     - Override as necessary.
-  MemoryObject() {
+  /// Destructor      - Override as necessary.
+  ~MemoryObject() {
   }
   
   /// getBase         - Returns the lowest valid address in the region.
   ///
   /// @result         - The lowest valid address.
-  virtual uint64_t getBase() const = 0;
+  virtual uintptr_t getBase() const = 0;
   
   /// getExtent       - Returns the size of the region in bytes.  (The region is
   ///                   contiguous, so the highest valid address of the region 
   ///                   is getBase() + getExtent() - 1).
   ///
   /// @result         - The size of the region.
-  virtual uint64_t getExtent() const = 0;
+  virtual uintptr_t getExtent() const = 0;
   
   /// readByte        - Tries to read a single byte from the region.
   ///
@@ -41,7 +41,7 @@ public:
   /// @param ptr      - A pointer to a byte to be filled in.  Must be non-NULL.
   /// @result         - 0 if successful; -1 if not.  Failure may be due to a
   ///                   bounds violation or an implementation-specific error.
-  virtual int readByte(uint64_t address, uint8_t* ptr) const = 0;
+  virtual int readByte(uintptr_t address, uint8_t* ptr) const = 0;
   
   /// readByte        - Tries to read a contiguous range of bytes from the
   ///                   region, up to the end of the region.
@@ -53,25 +53,24 @@ public:
   /// @param size     - The maximum number of bytes to copy.
   /// @param buf      - A pointer to a buffer to be filled in.  Must be non-NULL
   ///                   and large enough to hold size bytes.
-  /// @result         - The number of bytes copied if successful; (uint64_t)-1
+  /// @result         - The number of bytes copied if successful; (uintptr_t)-1
   ///                   if not.
   ///                   Failure may be due to a bounds violation or an
   ///                   implementation-specific error.
-  virtual uint64_t readBytes(uint64_t address,
-                             uint64_t size,
-                             uint8_t* buf) const {
-    uint64_t current = address;
-    uint64_t limit = getBase() + getExtent();
-    uint64_t ret = 0;
+  virtual uintptr_t readBytes(uintptr_t address,
+                              uintptr_t size,
+                              uint8_t* buf) const {
+    uintptr_t current = address;
+    uintptr_t limit = getBase() + getExtent();
     
     while(current - address < size && current < limit) {
       if(readByte(current, &buf[(current - address)]))
-        return (uint64_t)-1;
+        return (uintptr_t)-1;
       
-      ret++;
+      current++;
     }
     
-    return ret;
+    return current - address;
   }
 };