X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FMemoryBuffer.cpp;h=345a78c190c05ae102072dd716aec93ba26c210f;hb=b9312690a2a79de490ab9c439b9b5d7c9319bff8;hp=185008402c3f0f22423dbc000dd9c9ebda9899fa;hpb=37db5d67f92504226c17cfbf98c07c7bbe3afc3b;p=oota-llvm.git diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 185008402c3..345a78c190c 100644 --- a/lib/Support/MemoryBuffer.cpp +++ b/lib/Support/MemoryBuffer.cpp @@ -12,13 +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; //===----------------------------------------------------------------------===// @@ -27,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 @@ -35,7 +46,7 @@ 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. @@ -59,7 +70,7 @@ 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) { if (!Copy) @@ -95,9 +106,10 @@ MemoryBuffer *MemoryBuffer::getMemBufferCopy(const char *StartPtr, /// 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. @@ -109,9 +121,10 @@ 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; } @@ -121,145 +134,116 @@ MemoryBuffer *MemoryBuffer::getNewMemBuffer(unsigned Size, /// 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(const char *FilenameStart, - unsigned FnSize, +MemoryBuffer *MemoryBuffer::getFileOrSTDIN(StringRef Filename, std::string *ErrStr, - int64_t FileSize) { - if (FnSize != 1 || FilenameStart[0] != '-') - return getFile(FilenameStart, FnSize, ErrStr, FileSize); - MemoryBuffer *M = getSTDIN(); - if (M) return M; - - // If stdin was empty, M is null. Cons up an empty memory buffer now. - const char *EmptyStr = ""; - return MemoryBuffer::getMemBuffer(EmptyStr, EmptyStr, ""); + 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() {} - - bool open(const sys::Path &Filename, std::string *ErrStr); + 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()); + } }; } -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, ErrStr); - if (Failure) return true; - - if (!File.map(ErrStr)) - return true; - - 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!"); +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; + } - // 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. - const char *FileBase = static_cast(File.getBase()); - if ((Size & (PageSize-1)) != 0) { - init(FileBase, FileBase+Size); - } else { - // Otherwise, we allocate a new memory buffer and copy the data over - initCopyOf(FileBase, FileBase+Size); + // 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; - // No need to keep the file mapped any longer. - File.unmap(); + // 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; } - return false; -} - -MemoryBufferMMapFile::~MemoryBufferMMapFile() { - if (File.isMapped()) - File.unmap(); -} - -//===----------------------------------------------------------------------===// -// MemoryBuffer::getFile implementation. -//===----------------------------------------------------------------------===// - -MemoryBuffer *MemoryBuffer::getFile(const char *FilenameStart, unsigned FnSize, - std::string *ErrStr, int64_t FileSize){ - // FIXME: it would be nice if PathWithStatus didn't copy the filename into a - // temporary string. :( - sys::PathWithStatus P(FilenameStart, FnSize); -#if 1 - MemoryBufferMMapFile *M = new MemoryBufferMMapFile(); - if (!M->open(P, ErrStr)) - return M; - delete M; - return 0; -#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 the file is larger than some threshold, use mmap, otherwise use 'read'. - if (FileSize >= 4096*4) { - MemoryBufferMMapFile *M = new MemoryBufferMMapFile(); - if (!M->open(P, ErrStr)) - return M; - delete M; - return 0; + // 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 *SB = getNewUninitMemBuffer(FileSize, FilenameStart); - char *BufPtr = const_cast(SB->getBufferStart()); - - int FD = ::open(FilenameStart, O_RDONLY); - if (FD == -1) { - delete SB; + + 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. //===----------------------------------------------------------------------===// @@ -275,18 +259,22 @@ public: MemoryBuffer *MemoryBuffer::getSTDIN() { char Buffer[4096*4]; - + std::vector FileData; - + // Read in all of the data from stdin, we cannot mmap stdin. + // + // FIXME: That isn't necessarily true, we should try to mmap stdin and + // fallback if it fails. sys::Program::ChangeStdinToBinary(); - while (size_t ReadBytes = fread(Buffer, sizeof(char), 4096*4, stdin)) + 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(); - if (Size <= 1) - return 0; MemoryBuffer *B = new STDINBufferFile(); B->initCopyOf(&FileData[0], &FileData[Size-1]); return B;