From 34d4b9055407b2841a60c76220b92ea5ffafeed2 Mon Sep 17 00:00:00 2001
From: Sean Callanan <scallanan@apple.com>
Date: Mon, 27 Jul 2009 18:33:24 +0000
Subject: [PATCH] Many of Daniel's fixes.

I'm returning the number of bytes actually copied so that the client has some
warning when it reads past the end of the buffer.

I'm keeping the distinction between getByte() and getBytes() for now for
subclasses that use functions like ptrace() on Linux and only have a restricted
interface.  This makes their implementation easier, and subclasses can always
write a one-line implementation of readByte() that uses their custom
readBytes().

llvm-svn: 77225
---
 include/llvm/Support/MemoryObject.h | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/include/llvm/Support/MemoryObject.h b/include/llvm/Support/MemoryObject.h
index f8f29be5a7b..8368965b9c9 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;
   }
 };