X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FMemoryBuffer.cpp;h=345a78c190c05ae102072dd716aec93ba26c210f;hb=b9312690a2a79de490ab9c439b9b5d7c9319bff8;hp=96035354e52ba57c295a1d01dd79b0e71972487c;hpb=930c0fead9ad8cb91322c02fdead15cdd8dcbe0d;p=oota-llvm.git diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 96035354e52..345a78c190c 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,12 +12,24 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/MemoryBuffer.h" -#include "llvm/System/MappedFile.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/System/Path.h" #include "llvm/System/Process.h" +#include "llvm/System/Program.h" #include #include #include #include +#include +#include +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#include +#else +#include +#endif +#include using namespace llvm; //===----------------------------------------------------------------------===// @@ -26,7 +38,7 @@ using namespace llvm; MemoryBuffer::~MemoryBuffer() { if (MustDeleteBuffer) - delete [] BufferStart; + free((void*)BufferStart); } /// initCopyOf - Initialize this source buffer with a copy of the specified @@ -34,11 +46,11 @@ MemoryBuffer::~MemoryBuffer() { /// successfully. void MemoryBuffer::initCopyOf(const char *BufStart, const char *BufEnd) { size_t Size = BufEnd-BufStart; - BufferStart = new char[Size+1]; + BufferStart = (char *)malloc(Size+1); BufferEnd = BufferStart+Size; memcpy(const_cast(BufferStart), BufStart, Size); *const_cast(BufferEnd) = 0; // Null terminate buffer. - MustDeleteBuffer = false; + MustDeleteBuffer = true; } /// init - Initialize this MemoryBuffer as a reference to externally allocated @@ -58,9 +70,13 @@ namespace { class MemoryBufferMem : public MemoryBuffer { std::string FileID; public: - MemoryBufferMem(const char *Start, const char *End, const char *FID) + MemoryBufferMem(const char *Start, const char *End, StringRef FID, + bool Copy = false) : FileID(FID) { - init(Start, End); + if (!Copy) + init(Start, End); + else + initCopyOf(Start, End); } virtual const char *getBufferIdentifier() const { @@ -77,13 +93,23 @@ MemoryBuffer *MemoryBuffer::getMemBuffer(const char *StartPtr, return new MemoryBufferMem(StartPtr, EndPtr, BufferName); } +/// 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(const char *StartPtr, + const char *EndPtr, + const char *BufferName) { + return new MemoryBufferMem(StartPtr, EndPtr, BufferName, true); +} + /// 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]; +MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(size_t Size, + StringRef BufferName) { + char *Buf = (char *)malloc(Size+1); + if (!Buf) return 0; Buf[Size] = 0; MemoryBufferMem *SB = new MemoryBufferMem(Buf, Buf+Size, BufferName); // The memory for this buffer is owned by the MemoryBuffer. @@ -95,122 +121,129 @@ MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(unsigned Size, /// 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, +MemoryBuffer *MemoryBuffer::getNewMemBuffer(size_t Size, const char *BufferName) { MemoryBuffer *SB = getNewUninitMemBuffer(Size, BufferName); + if (!SB) return 0; memset(const_cast(SB->getBufferStart()), 0, Size+1); 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. +MemoryBuffer *MemoryBuffer::getFileOrSTDIN(StringRef Filename, + std::string *ErrStr, + int64_t FileSize, + struct stat *FileInfo) { + if (Filename == "-") + return getSTDIN(); + return getFile(Filename, ErrStr, FileSize, FileInfo); +} + //===----------------------------------------------------------------------===// -// MemoryBufferMMapFile implementation. +// MemoryBuffer::getFile implementation. //===----------------------------------------------------------------------===// namespace { +/// 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 MemoryBuffer { - sys::MappedFile File; + std::string Filename; public: - MemoryBufferMMapFile(const sys::Path &Filename); + MemoryBufferMMapFile(StringRef filename, const char *Pages, uint64_t Size) + : Filename(filename) { + init(Pages, Pages+Size); + } virtual const char *getBufferIdentifier() const { - return File.path().c_str(); + return Filename.c_str(); } - ~MemoryBufferMMapFile(); + ~MemoryBufferMMapFile() { + sys::Path::UnMapFilePages(getBufferStart(), getBufferSize()); + } }; } -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(); +MemoryBuffer *MemoryBuffer::getFile(StringRef Filename, std::string *ErrStr, + int64_t FileSize, struct stat *FileInfo) { + int OpenFlags = 0; +#ifdef O_BINARY + OpenFlags |= O_BINARY; // Open input file in binary mode on win32. +#endif + SmallString<256> PathBuf(Filename.begin(), Filename.end()); + int FD = ::open(PathBuf.c_str(), O_RDONLY|OpenFlags); + if (FD == -1) { + if (ErrStr) *ErrStr = strerror(errno); + return 0; } -} - -MemoryBufferMMapFile::~MemoryBufferMMapFile() { - File.unmap(); -} - -//===----------------------------------------------------------------------===// -// MemoryBuffer::getFile implementation. -//===----------------------------------------------------------------------===// - -MemoryBuffer *MemoryBuffer::getFile(const char *FilenameStart, unsigned FnSize, - int64_t FileSize) { - sys::PathWithStatus P(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; + // 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 == -1 || FileInfo) { + struct stat MyFileInfo; + struct stat *FileInfoPtr = FileInfo? FileInfo : &MyFileInfo; + + // TODO: This should use fstat64 when available. + if (fstat(FD, FileInfoPtr) == -1) { + if (ErrStr) *ErrStr = strerror(errno); + ::close(FD); + return 0; + } + FileSize = FileInfoPtr->st_size; } - // 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; + // 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)) { + // Close the file descriptor, now that the whole file is in memory. + ::close(FD); + return new MemoryBufferMMapFile(Filename, Pages, FileSize); + } + } + + MemoryBuffer *Buf = MemoryBuffer::getNewUninitMemBuffer(FileSize, Filename); + if (!Buf) { + // Failed to create a buffer. + if (ErrStr) *ErrStr = "could not allocate buffer"; + ::close(FD); return 0; } + + OwningPtr SB(Buf); + char *BufPtr = const_cast(SB->getBufferStart()); - unsigned BytesLeft = FileSize; + size_t BytesLeft = FileSize; while (BytesLeft) { ssize_t NumRead = ::read(FD, BufPtr, BytesLeft); - if (NumRead != -1) { + if (NumRead > 0) { BytesLeft -= NumRead; BufPtr += NumRead; - } else if (errno == EINTR) { + } else if (NumRead == -1 && errno == EINTR) { // try again } else { // error reading. + if (ErrStr) *ErrStr = strerror(errno); close(FD); - delete SB; return 0; } } close(FD); - return SB; -#endif + return SB.take(); } - //===----------------------------------------------------------------------===// // MemoryBuffer::getSTDIN implementation. //===----------------------------------------------------------------------===// @@ -226,15 +259,23 @@ public: MemoryBuffer *MemoryBuffer::getSTDIN() { char Buffer[4096*4]; - + std::vector FileData; - + // Read in all of the data from stdin, we cannot mmap stdin. - while (size_t ReadBytes = fread(Buffer, 1, 4096*4, stdin)) + // + // FIXME: That isn't necessarily true, we should try to mmap stdin and + // fallback if it fails. + sys::Program::ChangeStdinToBinary(); + size_t ReadBytes; + do { + ReadBytes = fread(Buffer, sizeof(char), sizeof(Buffer), stdin); FileData.insert(FileData.end(), Buffer, Buffer+ReadBytes); - + } while (ReadBytes == sizeof(Buffer)); + + FileData.push_back(0); // &FileData[Size] is invalid. So is &*FileData.end(). size_t Size = FileData.size(); MemoryBuffer *B = new STDINBufferFile(); - B->initCopyOf(&FileData[0], &FileData[Size]); + B->initCopyOf(&FileData[0], &FileData[Size-1]); return B; }