X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FMemoryObject.h;h=e0c8749da34602def7e96631f37c1d53d1cb2f67;hb=a800215d54608bbe2d6adc918765c300217d97cb;hp=8368965b9c9d129624359e924e370a68e1c65b68;hpb=e91ea06dff293e7fe001329efebcdb33a6d105da;p=oota-llvm.git

diff --git a/include/llvm/Support/MemoryObject.h b/include/llvm/Support/MemoryObject.h
index 8368965b9c9..e0c8749da34 100644
--- a/include/llvm/Support/MemoryObject.h
+++ b/include/llvm/Support/MemoryObject.h
@@ -7,74 +7,62 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MEMORYOBJECT_H
-#define MEMORYOBJECT_H
+#ifndef LLVM_SUPPORT_MEMORYOBJECT_H
+#define LLVM_SUPPORT_MEMORYOBJECT_H
 
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 
-/// MemoryObject - Abstract base class for contiguous addressable memory.
-///   Necessary for cases in which the memory is in another process, in a
-///   file, or on a remote machine.
+/// Interface to data which might be streamed. Streamability has 2 important
+/// implications/restrictions. First, the data might not yet exist in memory
+/// when the request is made. This just means that readByte/readBytes might have
+/// to block or do some work to get it. More significantly, the exact size of
+/// the object might not be known until it has all been fetched. This means that
+/// to return the right result, getExtent must also wait for all the data to
+/// arrive; therefore it should not be called on objects which are actually
+/// streamed (this would defeat the purpose of streaming). Instead,
+/// isValidAddress can be used to test addresses without knowing the exact size
+/// of the stream. Finally, getPointer can be used instead of readBytes to avoid
+/// extra copying.
 class MemoryObject {
 public:
-  /// Destructor      - Override as necessary.
-  ~MemoryObject() {
-  }
-  
-  /// getBase         - Returns the lowest valid address in the region.
-  ///
-  /// @result         - The lowest valid address.
-  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).
+  virtual ~MemoryObject();
+
+  /// Returns the size of the region in bytes.  (The region is contiguous, so
+  /// the highest valid address of the region is getExtent() - 1).
   ///
   /// @result         - The size of the region.
-  virtual uintptr_t getExtent() const = 0;
-  
-  /// readByte        - Tries to read a single byte from the region.
-  ///
-  /// @param address  - The address of the byte, in the same space as getBase().
-  /// @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(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.
-  ///                   You should override this function if there is a quicker
-  ///                   way than going back and forth with individual bytes.
+  virtual uint64_t getExtent() const = 0;
+
+  /// Tries to read a contiguous range of bytes from the region, up to the end
+  /// of the region.
   ///
-  /// @param address  - The address of the first byte, in the same space as 
-  ///                   getBase().
-  /// @param size     - The maximum number of bytes to copy.
-  /// @param buf      - A pointer to a buffer to be filled in.  Must be non-NULL
+  /// @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; (uintptr_t)-1
-  ///                   if not.
-  ///                   Failure may be due to a bounds violation or an
-  ///                   implementation-specific error.
-  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 (uintptr_t)-1;
-      
-      current++;
-    }
-    
-    return current - address;
-  }
+  /// @param Size     - The number of bytes to copy.
+  /// @param Address  - The address of the first byte, in the same space as
+  ///                   getBase().
+  /// @result         - The number of bytes read.
+  virtual uint64_t readBytes(uint8_t *Buf, uint64_t Size,
+                             uint64_t Address) const = 0;
+
+  /// Ensures that the requested data is in memory, and returns a pointer to it.
+  /// More efficient than using readBytes if the data is already in memory. May
+  /// block until (address - base + size) bytes have been read
+  /// @param address - address of the byte, in the same space as getBase()
+  /// @param size    - amount of data that must be available on return
+  /// @result        - valid pointer to the requested data
+  virtual const uint8_t *getPointer(uint64_t address, uint64_t size) const = 0;
+
+  /// Returns true if the address is within the object (i.e. between base and
+  /// base + extent - 1 inclusive). May block until (address - base) bytes have
+  /// been read
+  /// @param address - address of the byte, in the same space as getBase()
+  /// @result        - true if the address may be read with readByte()
+  virtual bool isValidAddress(uint64_t address) const = 0;
 };
 
 }
 
 #endif
-