From e413d9d3411a45f8b7c6f4f95f5f7cdfa25e5b12 Mon Sep 17 00:00:00 2001 From: Jakob Stoklund Olesen Date: Thu, 10 Mar 2011 18:01:43 +0000 Subject: [PATCH] Revert r127409 which broke all the Windows bots. llvm-svn: 127413 --- llvm/include/llvm/Support/MemoryBuffer.h | 8 +- llvm/include/llvm/Support/PathV1.h | 5 +- llvm/lib/Support/MemoryBuffer.cpp | 99 ++++++------------------ llvm/lib/Support/Unix/Path.inc | 6 +- 4 files changed, 32 insertions(+), 86 deletions(-) diff --git a/llvm/include/llvm/Support/MemoryBuffer.h b/llvm/include/llvm/Support/MemoryBuffer.h index a52dc11cffa6..b6243b7b10dd 100644 --- a/llvm/include/llvm/Support/MemoryBuffer.h +++ b/llvm/include/llvm/Support/MemoryBuffer.h @@ -40,8 +40,7 @@ class MemoryBuffer { MemoryBuffer &operator=(const MemoryBuffer &); // DO NOT IMPLEMENT protected: MemoryBuffer() {} - void init(const char *BufStart, const char *BufEnd, - bool RequiresNullTerminator); + void init(const char *BufStart, const char *BufEnd); public: virtual ~MemoryBuffer(); @@ -73,10 +72,7 @@ public: /// return a MemoryBuffer. static error_code getOpenFile(int FD, const char *Filename, OwningPtr &result, - size_t FileSize = -1, - size_t MapSize = -1, - off_t Offset = 0, - bool RequiresNullTerminator = true); + int64_t FileSize = -1); /// getMemBuffer - Open the specified memory range as a MemoryBuffer. Note /// that InputData must be null terminated. diff --git a/llvm/include/llvm/Support/PathV1.h b/llvm/include/llvm/Support/PathV1.h index 024bb39cedc2..d7753a3e71e7 100644 --- a/llvm/include/llvm/Support/PathV1.h +++ b/llvm/include/llvm/Support/PathV1.h @@ -608,15 +608,14 @@ namespace sys { /// /// This API is not intended for general use, clients should use /// MemoryBuffer::getFile instead. - static const char *MapInFilePages(int FD, size_t FileSize, - off_t Offset); + static const char *MapInFilePages(int FD, uint64_t FileSize); /// UnMapFilePages - Free pages mapped into the current process by /// MapInFilePages. /// /// This API is not intended for general use, clients should use /// MemoryBuffer::getFile instead. - static void UnMapFilePages(const char *Base, size_t FileSize); + static void UnMapFilePages(const char *Base, uint64_t FileSize); /// @} /// @name Data diff --git a/llvm/lib/Support/MemoryBuffer.cpp b/llvm/lib/Support/MemoryBuffer.cpp index 80d556cbf5be..a0c650d6820b 100644 --- a/llvm/lib/Support/MemoryBuffer.cpp +++ b/llvm/lib/Support/MemoryBuffer.cpp @@ -46,10 +46,8 @@ MemoryBuffer::~MemoryBuffer() { } /// init - Initialize this MemoryBuffer as a reference to externally allocated /// memory, memory that we know is already null terminated. -void MemoryBuffer::init(const char *BufStart, const char *BufEnd, - bool RequiresNullTerminator) { - assert((BufEnd[0] == 0 || !RequiresNullTerminator) && - "Buffer is not null terminated!"); +void MemoryBuffer::init(const char *BufStart, const char *BufEnd) { + assert(BufEnd[0] == 0 && "Buffer is not null terminated!"); BufferStart = BufStart; BufferEnd = BufEnd; } @@ -67,19 +65,18 @@ static void CopyStringRef(char *Memory, StringRef Data) { /// GetNamedBuffer - Allocates a new MemoryBuffer with Name copied after it. template -static T* GetNamedBuffer(StringRef Buffer, StringRef Name, - bool RequiresNullTerminator) { +static T* GetNamedBuffer(StringRef Buffer, StringRef Name) { char *Mem = static_cast(operator new(sizeof(T) + Name.size() + 1)); CopyStringRef(Mem + sizeof(T), Name); - return new (Mem) T(Buffer, RequiresNullTerminator); + return new (Mem) T(Buffer); } namespace { /// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory. class MemoryBufferMem : public MemoryBuffer { public: - MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) { - init(InputData.begin(), InputData.end(), RequiresNullTerminator); + MemoryBufferMem(StringRef InputData) { + init(InputData.begin(), InputData.end()); } virtual const char *getBufferIdentifier() const { @@ -93,7 +90,7 @@ public: /// that EndPtr[0] must be a null byte and be accessible! MemoryBuffer *MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName) { - return GetNamedBuffer(InputData, BufferName, true); + return GetNamedBuffer(InputData, BufferName); } /// getMemBufferCopy - Open the specified memory range as a MemoryBuffer, @@ -130,7 +127,7 @@ MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(size_t Size, char *Buf = Mem + AlignedStringLen; Buf[Size] = 0; // Null terminate buffer. - return new (Mem) MemoryBufferMem(StringRef(Buf, Size), true); + return new (Mem) MemoryBufferMem(StringRef(Buf, Size)); } /// getNewMemBuffer - Allocate a new MemoryBuffer of the specified size that @@ -175,19 +172,11 @@ namespace { /// sys::Path::UnMapFilePages method. class MemoryBufferMMapFile : public MemoryBufferMem { public: - MemoryBufferMMapFile(StringRef Buffer, bool RequiresNullTerminator) - : MemoryBufferMem(Buffer, RequiresNullTerminator) { } + MemoryBufferMMapFile(StringRef Buffer) + : MemoryBufferMem(Buffer) { } ~MemoryBufferMMapFile() { - static int PageSize = sys::Process::GetPageSize(); - - uintptr_t Start = reinterpret_cast(getBufferStart()); - size_t Size = getBufferSize(); - uintptr_t RealStart = Start & ~(PageSize - 1); - size_t RealSize = Size + (Start - RealStart); - - sys::Path::UnMapFilePages(reinterpret_cast(RealStart), - RealSize); + sys::Path::UnMapFilePages(getBufferStart(), getBufferSize()); } }; } @@ -216,44 +205,12 @@ error_code MemoryBuffer::getFile(const char *Filename, return ret; } -static bool shouldUseMmap(size_t FileSize, - size_t MapSize, - off_t Offset, - bool RequiresNullTerminator, - int PageSize) { - // We don't use mmap for small files because this can severely fragment our - // address space. - if (MapSize < 4096*4) - return false; - - if (!RequiresNullTerminator) - return true; - - // If we need a null terminator and the end of the map is inside the file, - // we cannot use mmap. - size_t End = Offset + MapSize; - assert(End <= FileSize); - if (End != FileSize) - return false; - - // Don't try to map files that are exactly a multiple of the system page size - // if we need a null terminator. - if ((FileSize & (PageSize -1)) == 0) - return false; - - return true; -} - error_code MemoryBuffer::getOpenFile(int FD, const char *Filename, OwningPtr &result, - size_t FileSize, size_t MapSize, - off_t Offset, - bool RequiresNullTerminator) { - static int PageSize = sys::Process::GetPageSize(); - + int64_t FileSize) { // If we don't know the file size, use fstat to find out. fstat on an open // file descriptor is cheaper than stat on a random path. - if (FileSize == size_t(-1)) { + if (FileSize == -1) { struct stat FileInfo; // TODO: This should use fstat64 when available. if (fstat(FD, &FileInfo) == -1) { @@ -262,26 +219,23 @@ error_code MemoryBuffer::getOpenFile(int FD, const char *Filename, FileSize = FileInfo.st_size; } - // Default is to map the full file. - if (MapSize == size_t(-1)) - MapSize = FileSize; - if (shouldUseMmap(FileSize, MapSize, Offset, RequiresNullTerminator, - PageSize)) { - off_t RealMapOffset = Offset & ~(PageSize - 1); - off_t Delta = Offset - RealMapOffset; - size_t RealMapSize = MapSize + Delta; - - if (const char *Pages = sys::Path::MapInFilePages(FD, - RealMapSize, - RealMapOffset)) { + // If the file is large, try to use mmap to read it in. We don't use mmap + // for small files, because this can severely fragment our address space. Also + // don't try to map files that are exactly a multiple of the system page size, + // as the file would not have the required null terminator. + // + // FIXME: Can we just mmap an extra page in the latter case? + if (FileSize >= 4096*4 && + (FileSize & (sys::Process::GetPageSize()-1)) != 0) { + if (const char *Pages = sys::Path::MapInFilePages(FD, FileSize)) { result.reset(GetNamedBuffer( - StringRef(Pages + Delta, MapSize), Filename, RequiresNullTerminator)); + StringRef(Pages, FileSize), Filename)); return success; } } - MemoryBuffer *Buf = MemoryBuffer::getNewUninitMemBuffer(MapSize, Filename); + MemoryBuffer *Buf = MemoryBuffer::getNewUninitMemBuffer(FileSize, Filename); if (!Buf) { // Failed to create a buffer. The only way it can fail is if // new(std::nothrow) returns 0. @@ -291,10 +245,7 @@ error_code MemoryBuffer::getOpenFile(int FD, const char *Filename, OwningPtr SB(Buf); char *BufPtr = const_cast(SB->getBufferStart()); - size_t BytesLeft = MapSize; - if (lseek(FD, Offset, SEEK_SET) == -1) - return error_code(errno, posix_category()); - + size_t BytesLeft = FileSize; while (BytesLeft) { ssize_t NumRead = ::read(FD, BufPtr, BytesLeft); if (NumRead == -1) { diff --git a/llvm/lib/Support/Unix/Path.inc b/llvm/lib/Support/Unix/Path.inc index 430cf2ed8e8f..0f6e800505e1 100644 --- a/llvm/lib/Support/Unix/Path.inc +++ b/llvm/lib/Support/Unix/Path.inc @@ -869,18 +869,18 @@ Path::makeUnique(bool reuse_current, std::string* ErrMsg) { return false; } -const char *Path::MapInFilePages(int FD, size_t FileSize, off_t Offset) { +const char *Path::MapInFilePages(int FD, uint64_t FileSize) { int Flags = MAP_PRIVATE; #ifdef MAP_FILE Flags |= MAP_FILE; #endif - void *BasePtr = ::mmap(0, FileSize, PROT_READ, Flags, FD, Offset); + void *BasePtr = ::mmap(0, FileSize, PROT_READ, Flags, FD, 0); if (BasePtr == MAP_FAILED) return 0; return (const char*)BasePtr; } -void Path::UnMapFilePages(const char *BasePtr, size_t FileSize) { +void Path::UnMapFilePages(const char *BasePtr, uint64_t FileSize) { ::munmap((void*)BasePtr, FileSize); }