diff --git a/include/llvm/Debugger/SourceFile.h b/include/llvm/Debugger/SourceFile.h index 11d2b0bdfab..eeff469c03b 100644 --- a/include/llvm/Debugger/SourceFile.h +++ b/include/llvm/Debugger/SourceFile.h @@ -52,7 +52,7 @@ namespace llvm { SourceFile(const std::string &fn, const GlobalVariable *Desc) : Filename(fn), Descriptor(Desc), File() { std::string ErrMsg; - if (File.open(Filename, sys::MappedFile::READ_ACCESS, &ErrMsg)) + if (File.open(Filename, &ErrMsg)) throw ErrMsg; readFile(); } diff --git a/include/llvm/System/MappedFile.h b/include/llvm/System/MappedFile.h index 6f902d28a1e..82ed8403320 100644 --- a/include/llvm/System/MappedFile.h +++ b/include/llvm/System/MappedFile.h @@ -25,26 +25,16 @@ namespace sys { /// 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. + /// for mapping a file into memory for both read access. class MappedFile { sys::PathWithStatus Path; ///< Path to the file. - unsigned Options; ///< Options used to create the mapping void *BasePtr; ///< Pointer to the base memory address mutable MappedFileInfo *MapInfo; ///< Platform specific info for the mapping MappedFile& operator=(const MappedFile &that); // DO NOT IMPLEMENT MappedFile(const MappedFile &that); // DO NOT IMPLEMENT 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 - }; - - MappedFile() : Options(READ_ACCESS), BasePtr(0), MapInfo(0) {} + MappedFile() : BasePtr(0), MapInfo(0) {} /// Destruct a MappedFile and release all memory associated with it. ~MappedFile() { close(); } @@ -71,7 +61,7 @@ namespace sys { /// 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. - const sys::Path& path() const { return Path; } + const sys::PathWithStatus &path() const { return Path; } /// This function returns the number of bytes in the file. size_t size() const; @@ -80,10 +70,8 @@ namespace sys { /// Open a file to be mapped and get its size but don't map it yet. Return /// true on error. - bool open(const sys::Path &P, int options = READ_ACCESS, - std::string *ErrMsg = 0) { + bool open(const sys::Path &P, std::string *ErrMsg = 0) { Path = P; - Options = options; return initialize(ErrMsg); } @@ -97,14 +85,6 @@ namespace sys { /// or 0 if an error occurred. void *map(std::string* ErrMsg = 0); - /// resize - 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. - bool resize(size_t new_size, std::string *ErrMsg = 0); - void close() { if (MapInfo) terminate(); } private: diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp index 125b22e9d94..c5da1145384 100644 --- a/lib/Archive/Archive.cpp +++ b/lib/Archive/Archive.cpp @@ -148,7 +148,7 @@ bool Archive::mapToMemory(std::string* ErrMsg) { mapfile = new sys::MappedFile(); - if (mapfile->open(archPath, sys::MappedFile::READ_ACCESS, ErrMsg)) + if (mapfile->open(archPath, ErrMsg)) return true; if (!(base = (char*) mapfile->map(ErrMsg))) return true; diff --git a/lib/Archive/ArchiveWriter.cpp b/lib/Archive/ArchiveWriter.cpp index c73e170ee7a..6a71026a0ff 100644 --- a/lib/Archive/ArchiveWriter.cpp +++ b/lib/Archive/ArchiveWriter.cpp @@ -212,7 +212,7 @@ Archive::writeMember( sys::MappedFile* mFile = 0; if (!data) { mFile = new sys::MappedFile(); - if (mFile->open(member.getPath(), sys::MappedFile::READ_ACCESS, ErrMsg)) + if (mFile->open(member.getPath(), ErrMsg)) return true; if (!(data = (const char*) mFile->map(ErrMsg))) return true; @@ -411,7 +411,7 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress, // Map in the archive we just wrote. sys::MappedFile arch; - if (arch.open(TmpArchive, sys::MappedFile::READ_ACCESS, ErrMsg)) + if (arch.open(TmpArchive, ErrMsg)) return true; const char* base; if (!(base = (const char*) arch.map(ErrMsg))) diff --git a/lib/Support/FileUtilities.cpp b/lib/Support/FileUtilities.cpp index cde08d188ca..8cca9d96d9f 100644 --- a/lib/Support/FileUtilities.cpp +++ b/lib/Support/FileUtilities.cpp @@ -192,10 +192,10 @@ int llvm::DiffFilesWithTolerance(const sys::PathWithStatus &FileA, // Now its safe to mmap the files into memory becasue both files // have a non-zero size. sys::MappedFile F1; - if (F1.open(FileA, sys::MappedFile::READ_ACCESS, Error)) + if (F1.open(FileA, Error)) return 2; sys::MappedFile F2; - if (F2.open(FileB, sys::MappedFile::READ_ACCESS, Error)) + if (F2.open(FileB, Error)) return 2; if (!F1.map(Error)) return 2; diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 4d26d38731a..8cea07fdb54 100644 --- a/lib/Support/MemoryBuffer.cpp +++ b/lib/Support/MemoryBuffer.cpp @@ -159,7 +159,7 @@ bool MemoryBufferMMapFile::open(const sys::Path &Filename, std::string *ErrStr) { // FIXME: This does an extra stat syscall to figure out the size, but we // already know the size! - bool Failure = File.open(Filename, sys::MappedFile::READ_ACCESS, ErrStr); + bool Failure = File.open(Filename, ErrStr); if (Failure) return true; if (!File.map(ErrStr)) diff --git a/lib/System/Unix/MappedFile.inc b/lib/System/Unix/MappedFile.inc index dcfd1892f84..92dc6660439 100644 --- a/lib/System/Unix/MappedFile.inc +++ b/lib/System/Unix/MappedFile.inc @@ -1,4 +1,4 @@ -//===- Unix/MappedFile.cpp - Unix MappedFile Implementation -----*- C++ -*-===// +//===- Unix/MappedFile.inc - Unix MappedFile Implementation -----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -11,11 +11,6 @@ // //===----------------------------------------------------------------------===// -//===----------------------------------------------------------------------===// -//=== WARNING: Implementation here must contain only generic UNIX code that -//=== is guaranteed to work on *all* UNIX variants. -//===----------------------------------------------------------------------===// - #include "Unix.h" #include "llvm/System/Process.h" @@ -44,16 +39,7 @@ namespace llvm { } bool MappedFile::initialize(std::string* ErrMsg) { - int mode = 0; - if (Options & READ_ACCESS) - if (Options & WRITE_ACCESS) - mode = O_RDWR; - else - mode = O_RDONLY; - else if (Options & WRITE_ACCESS) - mode = O_WRONLY; - - int FD = ::open(Path.c_str(), mode); + int FD = ::open(Path.c_str(), O_RDONLY); if (FD < 0) { MakeErrMsg(ErrMsg, "can't open file '" + Path.toString() + "'"); return true; @@ -80,8 +66,6 @@ void MappedFile::unmap() { assert(MapInfo && "MappedFile not initialized"); if (!isMapped()) return; - if (Options & WRITE_ACCESS) - ::msync(BasePtr, MapInfo->Size, MS_SYNC); ::munmap(BasePtr, MapInfo->Size); BasePtr = 0; // Mark this as non-mapped. } @@ -90,28 +74,13 @@ void* MappedFile::map(std::string* ErrMsg) { assert(MapInfo && "MappedFile not initialized"); if (isMapped()) return BasePtr; - int prot = PROT_NONE; - int flags = 0; + int prot = PROT_READ; + int flags = MAP_PRIVATE; #ifdef MAP_FILE flags |= MAP_FILE; #endif - if (Options == 0) { - prot = PROT_READ; - flags = MAP_PRIVATE; - } else { - if (Options & READ_ACCESS) - prot |= PROT_READ; - if (Options & WRITE_ACCESS) - prot |= PROT_WRITE; - if (Options & EXEC_ACCESS) - prot |= PROT_EXEC; - if (Options & SHARED_MAPPING) - flags |= MAP_SHARED; - else - flags |= MAP_PRIVATE; - } - size_t map_size = ((MapInfo->Size / Process::GetPageSize())+1) * - Process::GetPageSize(); + size_t PageSize = Process::GetPageSize(); + size_t map_size = ((MapInfo->Size / PageSize)+1) * PageSize; BasePtr = ::mmap(0, map_size, prot, flags, MapInfo->FD, 0); if (BasePtr == MAP_FAILED) { @@ -126,30 +95,3 @@ size_t MappedFile::size() const { return MapInfo->Size; } -bool MappedFile::resize(size_t new_size, std::string* ErrMsg) { - assert(MapInfo && "MappedFile not initialized"); - - // Take the mapping out of memory - unmap(); - - // Adjust the current size to a page boundary - size_t cur_size = ((MapInfo->Size / Process::GetPageSize())+1) * - Process::GetPageSize(); - - // Adjust the new_size to a page boundary - new_size = ((new_size / Process::GetPageSize())+1) * - Process::GetPageSize(); - - // If the file needs to be extended - if (new_size > cur_size) { - // Ensure we can allocate at least the idodes necessary to handle the - // file size requested. - if ((off_t)-1 == ::lseek(MapInfo->FD, new_size, SEEK_SET)) - return MakeErrMsg(ErrMsg, "Can't lseek: "); - if (-1 == ::write(MapInfo->FD, "\0", 1)) - return MakeErrMsg(ErrMsg, "Can't write: "); - } - - // Put the mapping back into memory. - return map(ErrMsg); -} diff --git a/lib/System/Win32/MappedFile.inc b/lib/System/Win32/MappedFile.inc index de8eec3673d..830905debca 100644 --- a/lib/System/Win32/MappedFile.inc +++ b/lib/System/Win32/MappedFile.inc @@ -33,17 +33,13 @@ bool MappedFile::initialize(std::string* ErrMsg) { MapInfo->hFile = INVALID_HANDLE_VALUE; MapInfo->hMapping = NULL; - DWORD mode = Options & WRITE_ACCESS ? GENERIC_WRITE : GENERIC_READ; - DWORD disposition = Options & WRITE_ACCESS ? OPEN_ALWAYS : OPEN_EXISTING; - DWORD share = Options & WRITE_ACCESS ? FILE_SHARE_WRITE : FILE_SHARE_READ; - share = Options & SHARED_MAPPING ? share : 0; - MapInfo->hFile = CreateFile(Path.c_str(), mode, share, NULL, disposition, - FILE_ATTRIBUTE_NORMAL, NULL); + MapInfo->hFile = CreateFile(Path.c_str(), GENERIC_READ, 0, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (MapInfo->hFile == INVALID_HANDLE_VALUE) { delete MapInfo; MapInfo = NULL; return MakeErrMsg(ErrMsg, - std::string("Can't open file: ") + Path.toString()); + std::string("Can't open file: ") + Path.toString()); } LARGE_INTEGER size; @@ -81,19 +77,14 @@ void MappedFile::unmap() { void* MappedFile::map(std::string* ErrMsg) { if (!isMapped()) { - DWORD prot = PAGE_READONLY; - if (Options & EXEC_ACCESS) - prot = SEC_IMAGE; - else if (Options & WRITE_ACCESS) - prot = PAGE_READWRITE; - MapInfo->hMapping = CreateFileMapping(MapInfo->hFile, NULL, prot, 0, 0, NULL); + MapInfo->hMapping = CreateFileMapping(MapInfo->hFile, NULL, PAGE_READONLY, + 0, 0, NULL); if (MapInfo->hMapping == NULL) { MakeErrMsg(ErrMsg, std::string("Can't map file: ") + Path.toString()); return 0; } - prot = (Options & WRITE_ACCESS) ? FILE_MAP_WRITE : FILE_MAP_READ; - BasePtr = MapViewOfFileEx(MapInfo->hMapping, prot, 0, 0, 0, NULL); + BasePtr = MapViewOfFileEx(MapInfo->hMapping, FILE_MAP_READ, 0, 0, 0, NULL); if (BasePtr == NULL) { CloseHandle(MapInfo->hMapping); MapInfo->hMapping = NULL; @@ -109,32 +100,5 @@ size_t MappedFile::size() const { return MapInfo->size; } -bool MappedFile::resize(size_t new_size, std::string* ErrMsg) { - assert(MapInfo && "MappedFile not initialized"); - - // Take the mapping out of memory. - unmap(); - - // Adjust the new_size to a page boundary. - size_t pagesizem1 = Process::GetPageSize() - 1; - new_size = (new_size + pagesizem1) & ~pagesizem1; - - // If the file needs to be extended, do so. - if (new_size > MapInfo->size) { - LARGE_INTEGER eof; - eof.QuadPart = new_size; - if (!SetFilePointerEx(MapInfo->hFile, eof, NULL, FILE_BEGIN)) - return MakeErrMsg(ErrMsg, - std::string("Can't set end of file: ") + Path.toString()); - if (!SetEndOfFile(MapInfo->hFile)) - return MakeErrMsg(ErrMsg, - std::string("Can't set end of file: ") + Path.toString()); - MapInfo->size = new_size; - } - - // Remap the file. - return map(ErrMsg); -} - }