X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FMemoryBuffer.cpp;h=ea72720b7f01c53e0cb7c799391cb0ab2c6b521a;hb=1af394766fe4e725d5af2fe82c2ad9cfcbc7dd34;hp=3c1ee90629550f27be7a8d28636d6cc7ba47eff4;hpb=9bc406019ef8e8c682afc10c46a9c4d4d6840d42;p=oota-llvm.git diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 3c1ee906295..ea72720b7f0 100644 --- a/lib/Support/MemoryBuffer.cpp +++ b/lib/Support/MemoryBuffer.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Chris Lattner and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -12,229 +12,357 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/MemoryBuffer.h" -#include "llvm/System/MappedFile.h" -#include "llvm/System/Process.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Support/Errno.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/Process.h" +#include "llvm/Support/Program.h" +#include "llvm/Support/system_error.h" #include #include #include #include +#include +#include +#include +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#include +#else +#include +#endif +#include using namespace llvm; +namespace { const llvm::error_code success; } + //===----------------------------------------------------------------------===// // MemoryBuffer implementation itself. //===----------------------------------------------------------------------===// -MemoryBuffer::~MemoryBuffer() { - if (MustDeleteBuffer) - delete [] BufferStart; -} - -/// initCopyOf - Initialize this source buffer with a copy of the specified -/// memory range. We make the copy so that we can null terminate it -/// successfully. -void MemoryBuffer::initCopyOf(const char *BufStart, const char *BufEnd) { - size_t Size = BufEnd-BufStart; - BufferStart = new char[Size+1]; - BufferEnd = BufferStart+Size; - memcpy(const_cast(BufferStart), BufStart, Size); - *const_cast(BufferEnd) = 0; // Null terminate buffer. - MustDeleteBuffer = false; -} +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) { - assert(BufEnd[0] == 0 && "Buffer is not null terminated!"); +void MemoryBuffer::init(const char *BufStart, const char *BufEnd, + bool RequiresNullTerminator) { + assert((!RequiresNullTerminator || BufEnd[0] == 0) && + "Buffer is not null terminated!"); BufferStart = BufStart; BufferEnd = BufEnd; - MustDeleteBuffer = false; } //===----------------------------------------------------------------------===// // MemoryBufferMem implementation. //===----------------------------------------------------------------------===// +/// CopyStringRef - Copies contents of a StringRef into a block of memory and +/// null-terminates it. +static void CopyStringRef(char *Memory, StringRef Data) { + memcpy(Memory, Data.data(), Data.size()); + Memory[Data.size()] = 0; // Null terminate string. +} + +/// GetNamedBuffer - Allocates a new MemoryBuffer with Name copied after it. +template +static T* GetNamedBuffer(StringRef Buffer, StringRef Name, + bool RequiresNullTerminator) { + char *Mem = static_cast(operator new(sizeof(T) + Name.size() + 1)); + CopyStringRef(Mem + sizeof(T), Name); + return new (Mem) T(Buffer, RequiresNullTerminator); +} + namespace { +/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory. class MemoryBufferMem : public MemoryBuffer { - std::string FileID; public: - MemoryBufferMem(const char *Start, const char *End, const char *FID) - : FileID(FID) { - init(Start, End); + MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) { + init(InputData.begin(), InputData.end(), RequiresNullTerminator); } - + virtual const char *getBufferIdentifier() const { - return FileID.c_str(); + // The name is stored after the class itself. + return reinterpret_cast(this + 1); } }; } /// getMemBuffer - Open the specified memory range as a MemoryBuffer. Note /// that EndPtr[0] must be a null byte and be accessible! -MemoryBuffer *MemoryBuffer::getMemBuffer(const char *StartPtr, - const char *EndPtr, - const char *BufferName) { - return new MemoryBufferMem(StartPtr, EndPtr, BufferName); +MemoryBuffer *MemoryBuffer::getMemBuffer(StringRef InputData, + StringRef BufferName, + bool RequiresNullTerminator) { + return GetNamedBuffer(InputData, BufferName, + RequiresNullTerminator); +} + +/// getMemBufferCopy - Open the specified memory range as a MemoryBuffer, +/// copying the contents and taking ownership of it. This has no requirements +/// on EndPtr[0]. +MemoryBuffer *MemoryBuffer::getMemBufferCopy(StringRef InputData, + StringRef BufferName) { + MemoryBuffer *Buf = getNewUninitMemBuffer(InputData.size(), BufferName); + if (!Buf) return 0; + memcpy(const_cast(Buf->getBufferStart()), InputData.data(), + InputData.size()); + return Buf; } /// getNewUninitMemBuffer - Allocate a new MemoryBuffer of the specified size -/// that is completely initialized to zeros. Note that the caller should -/// initialize the memory allocated by this method. The memory is owned by -/// the MemoryBuffer object. -MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(unsigned Size, - const char *BufferName) { - char *Buf = new char[Size+1]; - Buf[Size] = 0; - MemoryBufferMem *SB = new MemoryBufferMem(Buf, Buf+Size, BufferName); - // The memory for this buffer is owned by the MemoryBuffer. - SB->MustDeleteBuffer = true; - return SB; +/// that is not initialized. Note that the caller should initialize the +/// memory allocated by this method. The memory is owned by the MemoryBuffer +/// object. +MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(size_t Size, + StringRef BufferName) { + // Allocate space for the MemoryBuffer, the data and the name. It is important + // that MemoryBuffer and data are aligned so PointerIntPair works with them. + size_t AlignedStringLen = + RoundUpToAlignment(sizeof(MemoryBufferMem) + BufferName.size() + 1, + sizeof(void*)); // TODO: Is sizeof(void*) enough? + size_t RealLen = AlignedStringLen + Size + 1; + char *Mem = static_cast(operator new(RealLen, std::nothrow)); + if (!Mem) return 0; + + // The name is stored after the class itself. + CopyStringRef(Mem + sizeof(MemoryBufferMem), BufferName); + + // The buffer begins after the name and must be aligned. + char *Buf = Mem + AlignedStringLen; + Buf[Size] = 0; // Null terminate buffer. + + return new (Mem) MemoryBufferMem(StringRef(Buf, Size), true); } /// getNewMemBuffer - Allocate a new MemoryBuffer of the specified size that /// is completely initialized to zeros. Note that the caller should /// initialize the memory allocated by this method. The memory is owned by /// the MemoryBuffer object. -MemoryBuffer *MemoryBuffer::getNewMemBuffer(unsigned Size, - const char *BufferName) { +MemoryBuffer *MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) { MemoryBuffer *SB = getNewUninitMemBuffer(Size, BufferName); - memset(const_cast(SB->getBufferStart()), 0, Size+1); + if (!SB) return 0; + memset(const_cast(SB->getBufferStart()), 0, Size); return SB; } +/// getFileOrSTDIN - Open the specified file as a MemoryBuffer, or open stdin +/// if the Filename is "-". If an error occurs, this returns null and fills +/// in *ErrStr with a reason. If stdin is empty, this API (unlike getSTDIN) +/// returns an empty buffer. +error_code MemoryBuffer::getFileOrSTDIN(StringRef Filename, + OwningPtr &result, + int64_t FileSize) { + if (Filename == "-") + return getSTDIN(result); + return getFile(Filename, result, FileSize); +} + +error_code MemoryBuffer::getFileOrSTDIN(const char *Filename, + OwningPtr &result, + int64_t FileSize) { + if (strcmp(Filename, "-") == 0) + return getSTDIN(result); + return getFile(Filename, result, FileSize); +} + //===----------------------------------------------------------------------===// -// MemoryBufferMMapFile implementation. +// MemoryBuffer::getFile implementation. //===----------------------------------------------------------------------===// namespace { -class MemoryBufferMMapFile : public MemoryBuffer { - sys::MappedFile File; +/// MemoryBufferMMapFile - This represents a file that was mapped in with the +/// sys::Path::MapInFilePages method. When destroyed, it calls the +/// sys::Path::UnMapFilePages method. +class MemoryBufferMMapFile : public MemoryBufferMem { public: - MemoryBufferMMapFile(const sys::Path &Filename); - - virtual const char *getBufferIdentifier() const { - return File.path().c_str(); + MemoryBufferMMapFile(StringRef Buffer, bool RequiresNullTerminator) + : MemoryBufferMem(Buffer, RequiresNullTerminator) { } + + ~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); } - - ~MemoryBufferMMapFile(); }; } -MemoryBufferMMapFile::MemoryBufferMMapFile(const sys::Path &Filename) { - // FIXME: This does an extra stat syscall to figure out the size, but we - // already know the size! - bool Failure = File.open(Filename); - Failure = Failure; // Silence warning in no-asserts mode. - assert(!Failure && "Can't open file??"); - - File.map(); - - size_t Size = File.size(); - - static unsigned PageSize = sys::Process::GetPageSize(); - assert(((PageSize & (PageSize-1)) == 0) && PageSize && - "Page size is not a power of 2!"); - - // If this file is not an exact multiple of the system page size (common - // case), then the OS has zero terminated the buffer for us. - if ((Size & (PageSize-1))) { - init(File.charBase(), File.charBase()+Size); - } else { - // Otherwise, we allocate a new memory buffer and copy the data over - initCopyOf(File.charBase(), File.charBase()+Size); - - // No need to keep the file mapped any longer. - File.unmap(); +error_code MemoryBuffer::getFile(StringRef Filename, + OwningPtr &result, + int64_t FileSize, + bool RequiresNullTerminator) { + // Ensure the path is null terminated. + SmallString<256> PathBuf(Filename.begin(), Filename.end()); + return MemoryBuffer::getFile(PathBuf.c_str(), result, FileSize, + RequiresNullTerminator); +} + +error_code MemoryBuffer::getFile(const char *Filename, + OwningPtr &result, + int64_t FileSize, + bool RequiresNullTerminator) { + int OpenFlags = O_RDONLY; +#ifdef O_BINARY + OpenFlags |= O_BINARY; // Open input file in binary mode on win32. +#endif + int FD = ::open(Filename, OpenFlags); + if (FD == -1) { + return error_code(errno, posix_category()); } + error_code ret = getOpenFile(FD, Filename, result, FileSize, FileSize, + 0, RequiresNullTerminator); + close(FD); + return ret; } -MemoryBufferMMapFile::~MemoryBufferMMapFile() { - File.unmap(); +static bool shouldUseMmap(int FD, + 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 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. + // FIXME: this chunk of code is duplicated, but it avoids a fstat when + // RequiresNullTerminator = false and MapSize != -1. + if (FileSize == size_t(-1)) { + struct stat FileInfo; + // TODO: This should use fstat64 when available. + if (fstat(FD, &FileInfo) == -1) { + return error_code(errno, posix_category()); + } + FileSize = FileInfo.st_size; + } + + // 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; } -//===----------------------------------------------------------------------===// -// MemoryBuffer::getFile implementation. -//===----------------------------------------------------------------------===// +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(); -MemoryBuffer *MemoryBuffer::getFile(const char *FilenameStart, unsigned FnSize, - int64_t FileSize) { - sys::PathWithStatus P(std::string(FilenameStart, FnSize)); -#if 1 - return new MemoryBufferMMapFile(P); -#else - // FIXME: We need an efficient and portable method to open a file and then use - // 'read' to copy the bits out. The unix implementation is below. This is - // an important optimization for clients that want to open large numbers of - // small files (using mmap on everything can easily exhaust address space!). - - // If the user didn't specify a filesize, do a stat to find it. - if (FileSize == -1) { - const sys::FileStatus *FS = P.getFileStatus(); - if (FS == 0) return 0; // Error stat'ing file. - - FileSize = FS->fileSize; + // Default is to map the full file. + if (MapSize == size_t(-1)) { + // 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)) { + struct stat FileInfo; + // TODO: This should use fstat64 when available. + if (fstat(FD, &FileInfo) == -1) { + return error_code(errno, posix_category()); + } + FileSize = FileInfo.st_size; + } + MapSize = FileSize; } - - // If the file is larger than some threshold, use mmap, otherwise use 'read'. - if (FileSize >= 4096*4) - return new MemoryBufferMMapFile(P); - - MemoryBuffer *SB = getNewUninitMemBuffer(FileSize, FilenameStart); - char *BufPtr = const_cast(SB->getBufferStart()); - - int FD = ::open(FilenameStart, O_RDONLY); - if (FD == -1) { - delete SB; - return 0; + + if (shouldUseMmap(FD, 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)) { + result.reset(GetNamedBuffer( + StringRef(Pages + Delta, MapSize), Filename, RequiresNullTerminator)); + return success; + } + } + + MemoryBuffer *Buf = MemoryBuffer::getNewUninitMemBuffer(MapSize, Filename); + if (!Buf) { + // Failed to create a buffer. The only way it can fail is if + // new(std::nothrow) returns 0. + return make_error_code(errc::not_enough_memory); } - - unsigned BytesLeft = FileSize; + + 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()); + while (BytesLeft) { ssize_t NumRead = ::read(FD, BufPtr, BytesLeft); - if (NumRead != -1) { - BytesLeft -= NumRead; - BufPtr += NumRead; - } else if (errno == EINTR) { - // try again - } else { - // error reading. - close(FD); - delete SB; - return 0; + if (NumRead == -1) { + if (errno == EINTR) + continue; + // Error while reading. + return error_code(errno, posix_category()); + } else if (NumRead == 0) { + // We hit EOF early, truncate and terminate buffer. + Buf->BufferEnd = BufPtr; + *BufPtr = 0; + result.swap(SB); + return success; } + BytesLeft -= NumRead; + BufPtr += NumRead; } - close(FD); - - return SB; -#endif -} + result.swap(SB); + return success; +} //===----------------------------------------------------------------------===// // MemoryBuffer::getSTDIN implementation. //===----------------------------------------------------------------------===// -namespace { -class STDINBufferFile : public MemoryBuffer { -public: - virtual const char *getBufferIdentifier() const { - return ""; - } -}; -} - -MemoryBuffer *MemoryBuffer::getSTDIN() { - char Buffer[4096*4]; - - std::vector FileData; - +error_code MemoryBuffer::getSTDIN(OwningPtr &result) { // Read in all of the data from stdin, we cannot mmap stdin. - while (size_t ReadBytes = fread(Buffer, 1, 4096*4, stdin)) - FileData.insert(FileData.end(), Buffer, Buffer+ReadBytes); - - size_t Size = FileData.size(); - MemoryBuffer *B = new STDINBufferFile(); - B->initCopyOf(&FileData[0], &FileData[Size]); - return B; + // + // FIXME: That isn't necessarily true, we should try to mmap stdin and + // fallback if it fails. + sys::Program::ChangeStdinToBinary(); + + const ssize_t ChunkSize = 4096*4; + SmallString Buffer; + ssize_t ReadBytes; + // Read into Buffer until we hit EOF. + do { + Buffer.reserve(Buffer.size() + ChunkSize); + ReadBytes = read(0, Buffer.end(), ChunkSize); + if (ReadBytes == -1) { + if (errno == EINTR) continue; + return error_code(errno, posix_category()); + } + Buffer.set_size(Buffer.size() + ReadBytes); + } while (ReadBytes != 0); + + result.reset(getMemBufferCopy(Buffer, "")); + return success; }