//===-- DataBufferMemoryMap.h -----------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef liblldb_DataBufferMemoryMap_h_ #define liblldb_DataBufferMemoryMap_h_ #if defined(__cplusplus) #include "lldb/lldb-private.h" #include "lldb/Core/DataBuffer.h" #include "lldb/Core/Error.h" #include <string> namespace lldb_private { //---------------------------------------------------------------------- /// @class DataBufferMemoryMap DataBufferMemoryMap.h "lldb/Core/DataBufferMemoryMap.h" /// @brief A subclass of DataBuffer that memory maps data. /// /// This class memory maps data and stores any needed data for the /// memory mapping in its internal state. Memory map requests are not /// required to have any alignment or size constraints, this class will /// work around any host OS issues regarding such things. /// /// This class is designed to allow pages to be faulted in as needed and /// works well data from large files that won't be accessed all at once. //---------------------------------------------------------------------- class DataBufferMemoryMap : public DataBuffer { public: //------------------------------------------------------------------ /// Default Constructor //------------------------------------------------------------------ DataBufferMemoryMap (); //------------------------------------------------------------------ /// Destructor. /// /// Virtual destructor since this class inherits from a pure virtual /// base class #DataBuffer. //------------------------------------------------------------------ virtual ~DataBufferMemoryMap (); //------------------------------------------------------------------ /// Reverts this object to an empty state by unmapping any memory /// that is currently owned. //------------------------------------------------------------------ void Clear (); //------------------------------------------------------------------ /// @copydoc DataBuffer::GetBytes() //------------------------------------------------------------------ virtual uint8_t * GetBytes (); //------------------------------------------------------------------ /// @copydoc DataBuffer::GetBytes() const //------------------------------------------------------------------ virtual const uint8_t * GetBytes () const; //------------------------------------------------------------------ /// @copydoc DataBuffer::GetByteSize() const //------------------------------------------------------------------ virtual size_t GetByteSize () const; //------------------------------------------------------------------ /// Error get accessor. /// /// @return /// A const reference to Error object in case memory mapping /// fails. //------------------------------------------------------------------ const Error & GetError() const; //------------------------------------------------------------------ /// Memory map all or part of a file. /// /// Memory map \a length bytes from \a file starting \a offset /// bytes into the file. If \a length is set to \c SIZE_MAX, /// then map as many bytes as possible. /// /// @param[in] file /// The file specification from which to map data. /// /// @param[in] offset /// The offset in bytes from the beginning of the file where /// memory mapping should begin. /// /// @param[in] length /// The size in bytes that should be mapped starting \a offset /// bytes into the file. If \a length is \c SIZE_MAX, map /// as many bytes as possible. /// /// @return /// The number of bytes mapped starting from the \a offset. //------------------------------------------------------------------ size_t MemoryMapFromFileSpec (const FileSpec* file, off_t offset = 0, size_t length = SIZE_MAX, bool writeable = false); //------------------------------------------------------------------ /// Memory map all or part of a file. /// /// Memory map \a length bytes from an opened file descriptor \a fd /// starting \a offset bytes into the file. If \a length is set to /// \c SIZE_MAX, then map as many bytes as possible. /// /// @param[in] fd /// The posix file descriptor for an already opened file /// from which to map data. /// /// @param[in] offset /// The offset in bytes from the beginning of the file where /// memory mapping should begin. /// /// @param[in] length /// The size in bytes that should be mapped starting \a offset /// bytes into the file. If \a length is \c SIZE_MAX, map /// as many bytes as possible. /// /// @return /// The number of bytes mapped starting from the \a offset. //------------------------------------------------------------------ size_t MemoryMapFromFileDescriptor (int fd, off_t offset, size_t length, bool write, bool fd_is_file); protected: //------------------------------------------------------------------ // Classes that inherit from DataBufferMemoryMap can see and modify these //------------------------------------------------------------------ uint8_t * m_mmap_addr; ///< The actual pointer that was returned from \c mmap() size_t m_mmap_size; ///< The actual number of bytes that were mapped when \c mmap() was called uint8_t *m_data; ///< The data the user requested somewhere within the memory mapped data. size_t m_size; ///< The size of the data the user got when data was requested private: DISALLOW_COPY_AND_ASSIGN (DataBufferMemoryMap); }; } // namespace lldb_private #endif // #if defined(__cplusplus) #endif // liblldb_DataBufferMemoryMap_h_