First version of the MappedFile abstraction for operating system idependent

mapping of files. This first version uses mmap where its available. The
class needs to implement an alternate mechanism based on malloc'd memory
and file reading/writing for platforms without virtual memory.


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

1 files changed, 160 insertions, 0 deletions

diff --git a/include/llvm/System/MappedFile.h b/include/llvm/System/MappedFile.h
new file mode 100644
index 0000000000..3aa1840319
--- /dev/null
+++ b/include/llvm/System/MappedFile.h
@@ -0,0 +1,160 @@
+//===- llvm/System/MappedFile.h - MappedFile OS Concept ---------*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the 
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// This file declares the llvm::sys::MappedFile class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SYSTEM_MAPPEDFILE_H
+#define LLVM_SYSTEM_MAPPEDFILE_H
+
+#include "llvm/System/Path.h"
+
+namespace llvm {
+namespace sys {
+
+  /// Forward declare a class used for holding platform specific information
+  /// that needs to be 
+  class MappedFileInfo;
+
+  /// This class provides an abstraction for a memory mapped file in the 
+  /// operating system's filesystem. It provides platform independent operations
+  /// for mapping a file into memory for both read and write access. This class
+  /// does not provide facilities for finding the file or operating on paths to
+  /// files. The sys::Path class is used for that. 
+  /// @since 1.4
+  /// @brief An abstraction for memory mapped files.
+  class MappedFile {
+  /// @name Types
+  /// @{
+  public:
+    enum MappingOptions {
+      READ_ACCESS = 0x0001,     ///< Map the file for reading
+      WRITE_ACCESS = 0x0002,    ///< Map the file for write access
+      EXEC_ACCESS = 0x0004,     ///< Map the file for execution access
+      SHARED_MAPPING = 0x0008,  ///< Map the file shared with other processes
+    };
+  /// @}
+  /// @name Constructors
+  /// @{
+  public:
+    /// Construct a MappedFile to the \p path in the operating system's file
+    /// system with the mapping \p options provided.
+    /// @throws std::string if an error occurs
+    MappedFile(const Path& path, int options = READ_ACCESS)
+      : path_(path), options_(options), base_(0), info_(0) {
+      initialize();
+    }
+
+    /// Destruct a MappedFile and release all memory associated with it.
+    /// @throws std::string if an error occurs
+    ~MappedFile() {
+      terminate();
+      path_.clear();
+    }
+
+  /// @}
+  /// @name Accessors
+  /// @{
+  public:
+    /// This function determines if the file is currently mapped or not.
+    /// @returns true iff the file is mapped into memory, false otherwise
+    /// @brief Determine if a MappedFile is currently mapped
+    /// @throws nothing
+    bool isMapped() const { return base_ != 0; }
+
+    /// This function returns a void* pointer to the base address of the file
+    /// mapping. This is the memory address of the first byte in the file.
+    /// Note that although a non-const pointer is returned, the memory might
+    /// not actually be writable, depending on the MappingOptions used when
+    /// the MappedFile was opened.
+    /// @returns The base pointer to the memory mapped file.
+    /// @brief Obtain the base pointer to the memory mapped file.
+    /// @throws nothing
+    void* base() const { return base_; }
+
+    /// This function returns a char* pointer to the base address of the file
+    /// mapping. This is the memory address of the first byte in the file.
+    /// Note that although a non-const pointer is returned, the memory might
+    /// not actually be writable, depending on the MappingOptions used when
+    /// the MappedFile was opened.
+    /// @returns The base pointer to the memory mapped file as a char pointer.
+    /// @brief Obtain the base pointer to the memory mapped file.
+    /// @throws nothing
+    char* charBase() const { return reinterpret_cast<char*>(base_); }
+
+    /// This function returns a reference to the sys::Path object kept by the
+    /// MappedFile object. This contains the path to the file that is or 
+    /// will be mapped.
+    /// @returns sys::Path containing the path name.
+    /// @brief Returns the mapped file's path as a sys::Path
+    /// @throws nothing
+    const sys::Path& path() const { return path_; }
+
+    /// This function returns the number of bytes in the file. 
+    /// @throws std::string if an error occurs
+    size_t size();
+
+  /// @}
+  /// @name Mutators
+  /// @{
+  public:
+    /// The mapped file is removed from memory. If the file was mapped for
+    /// write access, the memory contents will be automatically synchronized
+    /// with the file's disk contents.
+    /// @brief Remove the file mapping from memory.
+    void unmap();
+
+    /// The mapped file is put into memory. 
+    /// @returns The base memory address of the mapped file.
+    /// @brief Map the file into memory.
+    void* map();
+
+    /// This method causes the size of the file, and consequently the size
+    /// of the mapping to be set. This is logically the same as unmap(), 
+    /// adjust size of the file, map(). Consequently, when calling this 
+    /// function, the caller should not rely on previous results of the 
+    /// map(), base(), or baseChar() members as they may point to invalid
+    /// areas of memory after this call.
+    /// @throws std::string if an error occurs
+    /// @brief Set a full path from a std::string
+    void size(size_t new_size);
+
+  /// @}
+  /// @name Implementation
+  /// @{
+  private:
+    void initialize(); ///< Initialize platform-specific portion
+    void terminate();  ///< Terminate platform-specific portion
+
+  /// @}
+  /// @name Data
+  /// @{
+  private:
+    sys::Path path_;       ///< Path to the file.
+    int options_;          ///< Options used to create the mapping
+    void* base_;           ///< Pointer to the base memory address
+    MappedFileInfo* info_; ///< Platform specific info for the mapping
+
+  /// @}
+  /// @name Deprecated
+  /// @{
+  private:
+    ///< Disallow assignment
+    MappedFile& operator = ( const MappedFile & that );
+    ///< Disallow copying
+    MappedFile(const MappedFile& that);
+  /// @}
+  };
+}
+}
+
+// vim: sw=2
+
+#endif