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().

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77225 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Support/MemoryObject.h b/include/llvm/Support/MemoryObject.h
index f8f29be5a7b354a3be55dbf058bfd60adf967c71..8368965b9c9d129624359e924e370a68e1c65b68 100644 (file)
--- 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;
   }
 };