X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FMemoryBuffer.cpp;h=a4963d92fb65f7e0a539fdd0a1d773128d3fa2c7;hb=d7fd2126c248f5887954cfd5ee6628f3a4cf4a9b;hp=43eb1813ad6c06575f7dd76590d627e3f665792c;hpb=ea332946d3577cc75422a1ad0cbce9321e9e8c59;p=oota-llvm.git diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 43eb1813ad6..a4963d92fb6 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,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) * sizeof(char)); BufferEnd = BufferStart+Size; memcpy(const_cast(BufferStart), BufStart, Size); *const_cast(BufferEnd) = 0; // Null terminate buffer. @@ -59,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, const char *FID, + bool Copy = false) : FileID(FID) { - init(Start, End); + if (!Copy) + init(Start, End); + else + initCopyOf(Start, End); } virtual const char *getBufferIdentifier() const { @@ -78,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, +MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(size_t Size, const char *BufferName) { - char *Buf = new char[Size+1]; + char *Buf = (char *)malloc((Size+1) * sizeof(char)); + 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. @@ -96,117 +121,109 @@ 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(const char *Filename, + std::string *ErrStr, + int64_t FileSize) { + if (Filename[0] != '-' || Filename[1] != 0) + return getFile(Filename, 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, ""); +} + //===----------------------------------------------------------------------===// -// 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(const char *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, sys::MappedFile::READ_ACCESS, 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!"); - - // 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(const char *Filename, std::string *ErrStr, + int64_t FileSize) { + int OpenFlags = 0; +#ifdef O_BINARY + OpenFlags |= O_BINARY; // Open input file in binary mode on win32. +#endif + int FD = ::open(Filename, O_RDONLY|OpenFlags); + if (FD == -1) { + if (ErrStr) *ErrStr = "could not open file"; + return 0; } - 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 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) { - 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; + struct stat FileInfo; + // TODO: This should use fstat64 when available. + if (fstat(FD, &FileInfo) == -1) { + if (ErrStr) *ErrStr = "could not get file length"; + ::close(FD); + return 0; + } + FileSize = FileInfo.st_size; } - 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. + 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) { @@ -217,17 +234,15 @@ MemoryBuffer *MemoryBuffer::getFile(const char *FilenameStart, unsigned FnSize, } else { // error reading. close(FD); - delete SB; + if (ErrStr) *ErrStr = "error reading file data"; return 0; } } close(FD); - return SB; -#endif + return SB.take(); } - //===----------------------------------------------------------------------===// // MemoryBuffer::getSTDIN implementation. //===----------------------------------------------------------------------===// @@ -248,11 +263,13 @@ MemoryBuffer *MemoryBuffer::getSTDIN() { // Read in all of the data from stdin, we cannot mmap stdin. sys::Program::ChangeStdinToBinary(); - while (size_t ReadBytes = fread(Buffer, 1, 4096*4, stdin)) + while (size_t ReadBytes = fread(Buffer, sizeof(char), 4096*4, stdin)) FileData.insert(FileData.end(), Buffer, Buffer+ReadBytes); - + 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;