X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FMemoryBuffer.cpp;h=a4963d92fb65f7e0a539fdd0a1d773128d3fa2c7;hb=f871ccb853a2ccbe8675c912330c041b318be8cd;hp=185008402c3f0f22423dbc000dd9c9ebda9899fa;hpb=37db5d67f92504226c17cfbf98c07c7bbe3afc3b;p=oota-llvm.git diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 185008402c3..a4963d92fb6 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) * sizeof(char)); BufferEnd = BufferStart+Size; memcpy(const_cast(BufferStart), BufStart, Size); *const_cast(BufferEnd) = 0; // Null terminate buffer. @@ -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, +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. @@ -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,12 +134,11 @@ 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(const char *Filename, std::string *ErrStr, int64_t FileSize) { - if (FnSize != 1 || FilenameStart[0] != '-') - return getFile(FilenameStart, FnSize, ErrStr, FileSize); + if (Filename[0] != '-' || Filename[1] != 0) + return getFile(Filename, ErrStr, FileSize); MemoryBuffer *M = getSTDIN(); if (M) return M; @@ -136,109 +148,82 @@ MemoryBuffer *MemoryBuffer::getFileOrSTDIN(const char *FilenameStart, } //===----------------------------------------------------------------------===// -// 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, 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. - 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); - - // 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) { @@ -249,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. //===----------------------------------------------------------------------===//