From: Zachary Turner Date: Tue, 21 Feb 2017 19:29:56 +0000 (+0000) Subject: Remove svn:eol-style property from 2 files. X-Git-Tag: android-x86-7.1-r4~20012 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=d48932ae6b42f06748578b3f0099f521925fc7b9;p=android-x86%2Fexternal-llvm.git Remove svn:eol-style property from 2 files. There are still over 3400 files remaining with this property set, but there are tens of thousands more with the property not set. Until we decide what to do on a global scale, this at least unblocks me temporarily. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@295756 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Support/MemoryBuffer.h b/include/llvm/Support/MemoryBuffer.h index f739d19907b..9709366c021 100644 --- a/include/llvm/Support/MemoryBuffer.h +++ b/include/llvm/Support/MemoryBuffer.h @@ -1,183 +1,183 @@ -//===--- MemoryBuffer.h - Memory Buffer Interface ---------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the MemoryBuffer interface. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_SUPPORT_MEMORYBUFFER_H -#define LLVM_SUPPORT_MEMORYBUFFER_H - -#include "llvm/ADT/StringRef.h" -#include "llvm/ADT/Twine.h" -#include "llvm/Support/CBindingWrapping.h" -#include "llvm/Support/ErrorOr.h" -#include "llvm-c/Types.h" -#include -#include -#include - -namespace llvm { - -class MemoryBufferRef; - -/// This interface provides simple read-only access to a block of memory, and -/// provides simple methods for reading files and standard input into a memory -/// buffer. In addition to basic access to the characters in the file, this -/// interface guarantees you can read one character past the end of the file, -/// and that this character will read as '\0'. -/// -/// The '\0' guarantee is needed to support an optimization -- it's intended to -/// be more efficient for clients which are reading all the data to stop -/// reading when they encounter a '\0' than to continually check the file -/// position to see if it has reached the end of the file. -class MemoryBuffer { - const char *BufferStart; // Start of the buffer. - const char *BufferEnd; // End of the buffer. - - -protected: - MemoryBuffer() = default; - - void init(const char *BufStart, const char *BufEnd, - bool RequiresNullTerminator); -public: - MemoryBuffer(const MemoryBuffer &) = delete; - MemoryBuffer &operator=(const MemoryBuffer &) = delete; - virtual ~MemoryBuffer(); - - const char *getBufferStart() const { return BufferStart; } - const char *getBufferEnd() const { return BufferEnd; } - size_t getBufferSize() const { return BufferEnd-BufferStart; } - - StringRef getBuffer() const { - return StringRef(BufferStart, getBufferSize()); - } - - /// Return an identifier for this buffer, typically the filename it was read - /// from. - virtual StringRef getBufferIdentifier() const { return "Unknown buffer"; } - - /// Open the specified file as a MemoryBuffer, returning a new MemoryBuffer - /// if successful, otherwise returning null. If FileSize is specified, this - /// means that the client knows that the file exists and that it has the - /// specified size. - /// - /// \param IsVolatileSize Set to true to indicate that the file size may be - /// changing, e.g. when libclang tries to parse while the user is - /// editing/updating the file. - static ErrorOr> - getFile(const Twine &Filename, int64_t FileSize = -1, - bool RequiresNullTerminator = true, bool IsVolatileSize = false); - - /// Read all of the specified file into a MemoryBuffer as a stream - /// (i.e. until EOF reached). This is useful for special files that - /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux). - static ErrorOr> - getFileAsStream(const Twine &Filename); - - /// Given an already-open file descriptor, map some slice of it into a - /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize. - /// Since this is in the middle of a file, the buffer is not null terminated. - static ErrorOr> - getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize, - int64_t Offset); - - /// Given an already-open file descriptor, read the file and return a - /// MemoryBuffer. - /// - /// \param IsVolatileSize Set to true to indicate that the file size may be - /// changing, e.g. when libclang tries to parse while the user is - /// editing/updating the file. - static ErrorOr> - getOpenFile(int FD, const Twine &Filename, uint64_t FileSize, - bool RequiresNullTerminator = true, bool IsVolatileSize = false); - - /// Open the specified memory range as a MemoryBuffer. Note that InputData - /// must be null terminated if RequiresNullTerminator is true. - static std::unique_ptr - getMemBuffer(StringRef InputData, StringRef BufferName = "", - bool RequiresNullTerminator = true); - - static std::unique_ptr - getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true); - - /// Open the specified memory range as a MemoryBuffer, copying the contents - /// and taking ownership of it. InputData does not have to be null terminated. - static std::unique_ptr - getMemBufferCopy(StringRef InputData, const Twine &BufferName = ""); - - /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note - /// that the caller need not initialize the memory allocated by this method. - /// The memory is owned by the MemoryBuffer object. - static std::unique_ptr - getNewMemBuffer(size_t Size, StringRef BufferName = ""); - - /// Allocate a new MemoryBuffer of the specified size that is not initialized. - /// Note that the caller should initialize the memory allocated by this - /// method. The memory is owned by the MemoryBuffer object. - static std::unique_ptr - getNewUninitMemBuffer(size_t Size, const Twine &BufferName = ""); - - /// Read all of stdin into a file buffer, and return it. - static ErrorOr> getSTDIN(); - - /// Open the specified file as a MemoryBuffer, or open stdin if the Filename - /// is "-". - static ErrorOr> - getFileOrSTDIN(const Twine &Filename, int64_t FileSize = -1, - bool RequiresNullTerminator = true); - - /// Map a subrange of the specified file as a MemoryBuffer. - static ErrorOr> - getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset); - - //===--------------------------------------------------------------------===// - // Provided for performance analysis. - //===--------------------------------------------------------------------===// - - /// The kind of memory backing used to support the MemoryBuffer. - enum BufferKind { - MemoryBuffer_Malloc, - MemoryBuffer_MMap - }; - - /// Return information on the memory mechanism used to support the - /// MemoryBuffer. - virtual BufferKind getBufferKind() const = 0; - - MemoryBufferRef getMemBufferRef() const; -}; - -class MemoryBufferRef { - StringRef Buffer; - StringRef Identifier; - -public: - MemoryBufferRef() = default; - MemoryBufferRef(MemoryBuffer& Buffer) - : Buffer(Buffer.getBuffer()), Identifier(Buffer.getBufferIdentifier()) {} - MemoryBufferRef(StringRef Buffer, StringRef Identifier) - : Buffer(Buffer), Identifier(Identifier) {} - - StringRef getBuffer() const { return Buffer; } - - StringRef getBufferIdentifier() const { return Identifier; } - - const char *getBufferStart() const { return Buffer.begin(); } - const char *getBufferEnd() const { return Buffer.end(); } - size_t getBufferSize() const { return Buffer.size(); } -}; - -// Create wrappers for C Binding types (see CBindingWrapping.h). -DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef) - -} // end namespace llvm - -#endif // LLVM_SUPPORT_MEMORYBUFFER_H +//===--- MemoryBuffer.h - Memory Buffer Interface ---------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the MemoryBuffer interface. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_SUPPORT_MEMORYBUFFER_H +#define LLVM_SUPPORT_MEMORYBUFFER_H + +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/Twine.h" +#include "llvm/Support/CBindingWrapping.h" +#include "llvm/Support/ErrorOr.h" +#include "llvm-c/Types.h" +#include +#include +#include + +namespace llvm { + +class MemoryBufferRef; + +/// This interface provides simple read-only access to a block of memory, and +/// provides simple methods for reading files and standard input into a memory +/// buffer. In addition to basic access to the characters in the file, this +/// interface guarantees you can read one character past the end of the file, +/// and that this character will read as '\0'. +/// +/// The '\0' guarantee is needed to support an optimization -- it's intended to +/// be more efficient for clients which are reading all the data to stop +/// reading when they encounter a '\0' than to continually check the file +/// position to see if it has reached the end of the file. +class MemoryBuffer { + const char *BufferStart; // Start of the buffer. + const char *BufferEnd; // End of the buffer. + + +protected: + MemoryBuffer() = default; + + void init(const char *BufStart, const char *BufEnd, + bool RequiresNullTerminator); +public: + MemoryBuffer(const MemoryBuffer &) = delete; + MemoryBuffer &operator=(const MemoryBuffer &) = delete; + virtual ~MemoryBuffer(); + + const char *getBufferStart() const { return BufferStart; } + const char *getBufferEnd() const { return BufferEnd; } + size_t getBufferSize() const { return BufferEnd-BufferStart; } + + StringRef getBuffer() const { + return StringRef(BufferStart, getBufferSize()); + } + + /// Return an identifier for this buffer, typically the filename it was read + /// from. + virtual StringRef getBufferIdentifier() const { return "Unknown buffer"; } + + /// Open the specified file as a MemoryBuffer, returning a new MemoryBuffer + /// if successful, otherwise returning null. If FileSize is specified, this + /// means that the client knows that the file exists and that it has the + /// specified size. + /// + /// \param IsVolatileSize Set to true to indicate that the file size may be + /// changing, e.g. when libclang tries to parse while the user is + /// editing/updating the file. + static ErrorOr> + getFile(const Twine &Filename, int64_t FileSize = -1, + bool RequiresNullTerminator = true, bool IsVolatileSize = false); + + /// Read all of the specified file into a MemoryBuffer as a stream + /// (i.e. until EOF reached). This is useful for special files that + /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux). + static ErrorOr> + getFileAsStream(const Twine &Filename); + + /// Given an already-open file descriptor, map some slice of it into a + /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize. + /// Since this is in the middle of a file, the buffer is not null terminated. + static ErrorOr> + getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize, + int64_t Offset); + + /// Given an already-open file descriptor, read the file and return a + /// MemoryBuffer. + /// + /// \param IsVolatileSize Set to true to indicate that the file size may be + /// changing, e.g. when libclang tries to parse while the user is + /// editing/updating the file. + static ErrorOr> + getOpenFile(int FD, const Twine &Filename, uint64_t FileSize, + bool RequiresNullTerminator = true, bool IsVolatileSize = false); + + /// Open the specified memory range as a MemoryBuffer. Note that InputData + /// must be null terminated if RequiresNullTerminator is true. + static std::unique_ptr + getMemBuffer(StringRef InputData, StringRef BufferName = "", + bool RequiresNullTerminator = true); + + static std::unique_ptr + getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true); + + /// Open the specified memory range as a MemoryBuffer, copying the contents + /// and taking ownership of it. InputData does not have to be null terminated. + static std::unique_ptr + getMemBufferCopy(StringRef InputData, const Twine &BufferName = ""); + + /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note + /// that the caller need not initialize the memory allocated by this method. + /// The memory is owned by the MemoryBuffer object. + static std::unique_ptr + getNewMemBuffer(size_t Size, StringRef BufferName = ""); + + /// Allocate a new MemoryBuffer of the specified size that is not initialized. + /// Note that the caller should initialize the memory allocated by this + /// method. The memory is owned by the MemoryBuffer object. + static std::unique_ptr + getNewUninitMemBuffer(size_t Size, const Twine &BufferName = ""); + + /// Read all of stdin into a file buffer, and return it. + static ErrorOr> getSTDIN(); + + /// Open the specified file as a MemoryBuffer, or open stdin if the Filename + /// is "-". + static ErrorOr> + getFileOrSTDIN(const Twine &Filename, int64_t FileSize = -1, + bool RequiresNullTerminator = true); + + /// Map a subrange of the specified file as a MemoryBuffer. + static ErrorOr> + getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset); + + //===--------------------------------------------------------------------===// + // Provided for performance analysis. + //===--------------------------------------------------------------------===// + + /// The kind of memory backing used to support the MemoryBuffer. + enum BufferKind { + MemoryBuffer_Malloc, + MemoryBuffer_MMap + }; + + /// Return information on the memory mechanism used to support the + /// MemoryBuffer. + virtual BufferKind getBufferKind() const = 0; + + MemoryBufferRef getMemBufferRef() const; +}; + +class MemoryBufferRef { + StringRef Buffer; + StringRef Identifier; + +public: + MemoryBufferRef() = default; + MemoryBufferRef(MemoryBuffer& Buffer) + : Buffer(Buffer.getBuffer()), Identifier(Buffer.getBufferIdentifier()) {} + MemoryBufferRef(StringRef Buffer, StringRef Identifier) + : Buffer(Buffer), Identifier(Identifier) {} + + StringRef getBuffer() const { return Buffer; } + + StringRef getBufferIdentifier() const { return Identifier; } + + const char *getBufferStart() const { return Buffer.begin(); } + const char *getBufferEnd() const { return Buffer.end(); } + size_t getBufferSize() const { return Buffer.size(); } +}; + +// Create wrappers for C Binding types (see CBindingWrapping.h). +DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef) + +} // end namespace llvm + +#endif // LLVM_SUPPORT_MEMORYBUFFER_H diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index a3a18c9283c..ce0a8c89180 100644 --- a/lib/Support/MemoryBuffer.cpp +++ b/lib/Support/MemoryBuffer.cpp @@ -1,457 +1,457 @@ -//===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements the MemoryBuffer interface. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/ADT/SmallString.h" -#include "llvm/Config/config.h" -#include "llvm/Support/Errc.h" -#include "llvm/Support/Errno.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/MathExtras.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/Process.h" -#include "llvm/Support/Program.h" -#include -#include -#include -#include -#include -#include -#if !defined(_MSC_VER) && !defined(__MINGW32__) -#include -#else -#include -#endif -using namespace llvm; - -//===----------------------------------------------------------------------===// -// MemoryBuffer implementation itself. -//===----------------------------------------------------------------------===// - -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, - bool RequiresNullTerminator) { - assert((!RequiresNullTerminator || BufEnd[0] == 0) && - "Buffer is not null terminated!"); - BufferStart = BufStart; - BufferEnd = BufEnd; -} - -//===----------------------------------------------------------------------===// -// MemoryBufferMem implementation. -//===----------------------------------------------------------------------===// - -/// CopyStringRef - Copies contents of a StringRef into a block of memory and -/// null-terminates it. -static void CopyStringRef(char *Memory, StringRef Data) { - if (!Data.empty()) - memcpy(Memory, Data.data(), Data.size()); - Memory[Data.size()] = 0; // Null terminate string. -} - -namespace { -struct NamedBufferAlloc { - const Twine &Name; - NamedBufferAlloc(const Twine &Name) : Name(Name) {} -}; -} - -void *operator new(size_t N, const NamedBufferAlloc &Alloc) { - SmallString<256> NameBuf; - StringRef NameRef = Alloc.Name.toStringRef(NameBuf); - - char *Mem = static_cast(operator new(N + NameRef.size() + 1)); - CopyStringRef(Mem + N, NameRef); - return Mem; -} - -namespace { -/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory. -class MemoryBufferMem : public MemoryBuffer { -public: - MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) { - init(InputData.begin(), InputData.end(), RequiresNullTerminator); - } - - /// Disable sized deallocation for MemoryBufferMem, because it has - /// tail-allocated data. - void operator delete(void *p) { ::operator delete(p); } - - StringRef getBufferIdentifier() const override { - // The name is stored after the class itself. - return StringRef(reinterpret_cast(this + 1)); - } - - BufferKind getBufferKind() const override { - return MemoryBuffer_Malloc; - } -}; -} - -static ErrorOr> -getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize, - uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize); - -std::unique_ptr -MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName, - bool RequiresNullTerminator) { - auto *Ret = new (NamedBufferAlloc(BufferName)) - MemoryBufferMem(InputData, RequiresNullTerminator); - return std::unique_ptr(Ret); -} - -std::unique_ptr -MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) { - return std::unique_ptr(getMemBuffer( - Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator)); -} - -std::unique_ptr -MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) { - std::unique_ptr Buf = - getNewUninitMemBuffer(InputData.size(), BufferName); - if (!Buf) - return nullptr; - memcpy(const_cast(Buf->getBufferStart()), InputData.data(), - InputData.size()); - return Buf; -} - -std::unique_ptr -MemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &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. - // TODO: Is 16-byte alignment enough? We copy small object files with large - // alignment expectations into this buffer. - SmallString<256> NameBuf; - StringRef NameRef = BufferName.toStringRef(NameBuf); - size_t AlignedStringLen = - alignTo(sizeof(MemoryBufferMem) + NameRef.size() + 1, 16); - size_t RealLen = AlignedStringLen + Size + 1; - char *Mem = static_cast(operator new(RealLen, std::nothrow)); - if (!Mem) - return nullptr; - - // The name is stored after the class itself. - CopyStringRef(Mem + sizeof(MemoryBufferMem), NameRef); - - // The buffer begins after the name and must be aligned. - char *Buf = Mem + AlignedStringLen; - Buf[Size] = 0; // Null terminate buffer. - - auto *Ret = new (Mem) MemoryBufferMem(StringRef(Buf, Size), true); - return std::unique_ptr(Ret); -} - -std::unique_ptr -MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) { - std::unique_ptr SB = getNewUninitMemBuffer(Size, BufferName); - if (!SB) - return nullptr; - memset(const_cast(SB->getBufferStart()), 0, Size); - return SB; -} - -ErrorOr> -MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize, - bool RequiresNullTerminator) { - SmallString<256> NameBuf; - StringRef NameRef = Filename.toStringRef(NameBuf); - - if (NameRef == "-") - return getSTDIN(); - return getFile(Filename, FileSize, RequiresNullTerminator); -} - -ErrorOr> -MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize, - uint64_t Offset) { - return getFileAux(FilePath, -1, MapSize, Offset, false, false); -} - - -//===----------------------------------------------------------------------===// -// MemoryBuffer::getFile implementation. -//===----------------------------------------------------------------------===// - -namespace { -/// \brief Memory maps a file descriptor using sys::fs::mapped_file_region. -/// -/// This handles converting the offset into a legal offset on the platform. -class MemoryBufferMMapFile : public MemoryBuffer { - sys::fs::mapped_file_region MFR; - - static uint64_t getLegalMapOffset(uint64_t Offset) { - return Offset & ~(sys::fs::mapped_file_region::alignment() - 1); - } - - static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) { - return Len + (Offset - getLegalMapOffset(Offset)); - } - - const char *getStart(uint64_t Len, uint64_t Offset) { - return MFR.const_data() + (Offset - getLegalMapOffset(Offset)); - } - -public: - MemoryBufferMMapFile(bool RequiresNullTerminator, int FD, uint64_t Len, - uint64_t Offset, std::error_code &EC) - : MFR(FD, sys::fs::mapped_file_region::readonly, - getLegalMapSize(Len, Offset), getLegalMapOffset(Offset), EC) { - if (!EC) { - const char *Start = getStart(Len, Offset); - init(Start, Start + Len, RequiresNullTerminator); - } - } - - /// Disable sized deallocation for MemoryBufferMMapFile, because it has - /// tail-allocated data. - void operator delete(void *p) { ::operator delete(p); } - - StringRef getBufferIdentifier() const override { - // The name is stored after the class itself. - return StringRef(reinterpret_cast(this + 1)); - } - - BufferKind getBufferKind() const override { - return MemoryBuffer_MMap; - } -}; -} - -static ErrorOr> -getMemoryBufferForStream(int FD, const Twine &BufferName) { - 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(FD, Buffer.end(), ChunkSize); - if (ReadBytes == -1) { - if (errno == EINTR) continue; - return std::error_code(errno, std::generic_category()); - } - Buffer.set_size(Buffer.size() + ReadBytes); - } while (ReadBytes != 0); - - return MemoryBuffer::getMemBufferCopy(Buffer, BufferName); -} - - -ErrorOr> -MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize, - bool RequiresNullTerminator, bool IsVolatileSize) { - return getFileAux(Filename, FileSize, FileSize, 0, - RequiresNullTerminator, IsVolatileSize); -} - -static ErrorOr> -getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize, - uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, - bool IsVolatileSize); - -static ErrorOr> -getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize, - uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize) { - int FD; - std::error_code EC = sys::fs::openFileForRead(Filename, FD); - if (EC) - return EC; - - ErrorOr> Ret = - getOpenFileImpl(FD, Filename, FileSize, MapSize, Offset, - RequiresNullTerminator, IsVolatileSize); - close(FD); - return Ret; -} - -static bool shouldUseMmap(int FD, - size_t FileSize, - size_t MapSize, - off_t Offset, - bool RequiresNullTerminator, - int PageSize, - bool IsVolatileSize) { - // mmap may leave the buffer without null terminator if the file size changed - // by the time the last page is mapped in, so avoid it if the file size is - // likely to change. - if (IsVolatileSize) - return false; - - // We don't use mmap for small files because this can severely fragment our - // address space. - if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize) - 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)) { - sys::fs::file_status Status; - if (sys::fs::status(FD, Status)) - return false; - FileSize = Status.getSize(); - } - - // 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; - -#if defined(__CYGWIN__) - // Don't try to map files that are exactly a multiple of the physical page size - // if we need a null terminator. - // FIXME: We should reorganize again getPageSize() on Win32. - if ((FileSize & (4096 - 1)) == 0) - return false; -#endif - - return true; -} - -static ErrorOr> -getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize, - uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, - bool IsVolatileSize) { - static int PageSize = sys::Process::getPageSize(); - - // Default is to map the full file. - if (MapSize == uint64_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 == uint64_t(-1)) { - sys::fs::file_status Status; - std::error_code EC = sys::fs::status(FD, Status); - if (EC) - return EC; - - // If this not a file or a block device (e.g. it's a named pipe - // or character device), we can't trust the size. Create the memory - // buffer by copying off the stream. - sys::fs::file_type Type = Status.type(); - if (Type != sys::fs::file_type::regular_file && - Type != sys::fs::file_type::block_file) - return getMemoryBufferForStream(FD, Filename); - - FileSize = Status.getSize(); - } - MapSize = FileSize; - } - - if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator, - PageSize, IsVolatileSize)) { - std::error_code EC; - std::unique_ptr Result( - new (NamedBufferAlloc(Filename)) - MemoryBufferMMapFile(RequiresNullTerminator, FD, MapSize, Offset, EC)); - if (!EC) - return std::move(Result); - } - - std::unique_ptr 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); - } - - char *BufPtr = const_cast(Buf->getBufferStart()); - - size_t BytesLeft = MapSize; -#ifndef HAVE_PREAD - if (lseek(FD, Offset, SEEK_SET) == -1) - return std::error_code(errno, std::generic_category()); -#endif - - while (BytesLeft) { -#ifdef HAVE_PREAD - ssize_t NumRead = ::pread(FD, BufPtr, BytesLeft, MapSize-BytesLeft+Offset); -#else - ssize_t NumRead = ::read(FD, BufPtr, BytesLeft); -#endif - if (NumRead == -1) { - if (errno == EINTR) - continue; - // Error while reading. - return std::error_code(errno, std::generic_category()); - } - if (NumRead == 0) { - memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer. - break; - } - BytesLeft -= NumRead; - BufPtr += NumRead; - } - - return std::move(Buf); -} - -ErrorOr> -MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize, - bool RequiresNullTerminator, bool IsVolatileSize) { - return getOpenFileImpl(FD, Filename, FileSize, FileSize, 0, - RequiresNullTerminator, IsVolatileSize); -} - -ErrorOr> -MemoryBuffer::getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize, - int64_t Offset) { - assert(MapSize != uint64_t(-1)); - return getOpenFileImpl(FD, Filename, -1, MapSize, Offset, false, - /*IsVolatileSize*/ false); -} - -ErrorOr> MemoryBuffer::getSTDIN() { - // 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::ChangeStdinToBinary(); - - return getMemoryBufferForStream(0, ""); -} - -ErrorOr> -MemoryBuffer::getFileAsStream(const Twine &Filename) { - int FD; - std::error_code EC = sys::fs::openFileForRead(Filename, FD); - if (EC) - return EC; - ErrorOr> Ret = - getMemoryBufferForStream(FD, Filename); - close(FD); - return Ret; -} - -MemoryBufferRef MemoryBuffer::getMemBufferRef() const { - StringRef Data = getBuffer(); - StringRef Identifier = getBufferIdentifier(); - return MemoryBufferRef(Data, Identifier); -} +//===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the MemoryBuffer interface. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/Config/config.h" +#include "llvm/Support/Errc.h" +#include "llvm/Support/Errno.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/Process.h" +#include "llvm/Support/Program.h" +#include +#include +#include +#include +#include +#include +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#else +#include +#endif +using namespace llvm; + +//===----------------------------------------------------------------------===// +// MemoryBuffer implementation itself. +//===----------------------------------------------------------------------===// + +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, + bool RequiresNullTerminator) { + assert((!RequiresNullTerminator || BufEnd[0] == 0) && + "Buffer is not null terminated!"); + BufferStart = BufStart; + BufferEnd = BufEnd; +} + +//===----------------------------------------------------------------------===// +// MemoryBufferMem implementation. +//===----------------------------------------------------------------------===// + +/// CopyStringRef - Copies contents of a StringRef into a block of memory and +/// null-terminates it. +static void CopyStringRef(char *Memory, StringRef Data) { + if (!Data.empty()) + memcpy(Memory, Data.data(), Data.size()); + Memory[Data.size()] = 0; // Null terminate string. +} + +namespace { +struct NamedBufferAlloc { + const Twine &Name; + NamedBufferAlloc(const Twine &Name) : Name(Name) {} +}; +} + +void *operator new(size_t N, const NamedBufferAlloc &Alloc) { + SmallString<256> NameBuf; + StringRef NameRef = Alloc.Name.toStringRef(NameBuf); + + char *Mem = static_cast(operator new(N + NameRef.size() + 1)); + CopyStringRef(Mem + N, NameRef); + return Mem; +} + +namespace { +/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory. +class MemoryBufferMem : public MemoryBuffer { +public: + MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) { + init(InputData.begin(), InputData.end(), RequiresNullTerminator); + } + + /// Disable sized deallocation for MemoryBufferMem, because it has + /// tail-allocated data. + void operator delete(void *p) { ::operator delete(p); } + + StringRef getBufferIdentifier() const override { + // The name is stored after the class itself. + return StringRef(reinterpret_cast(this + 1)); + } + + BufferKind getBufferKind() const override { + return MemoryBuffer_Malloc; + } +}; +} + +static ErrorOr> +getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize, + uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize); + +std::unique_ptr +MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName, + bool RequiresNullTerminator) { + auto *Ret = new (NamedBufferAlloc(BufferName)) + MemoryBufferMem(InputData, RequiresNullTerminator); + return std::unique_ptr(Ret); +} + +std::unique_ptr +MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) { + return std::unique_ptr(getMemBuffer( + Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator)); +} + +std::unique_ptr +MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) { + std::unique_ptr Buf = + getNewUninitMemBuffer(InputData.size(), BufferName); + if (!Buf) + return nullptr; + memcpy(const_cast(Buf->getBufferStart()), InputData.data(), + InputData.size()); + return Buf; +} + +std::unique_ptr +MemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &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. + // TODO: Is 16-byte alignment enough? We copy small object files with large + // alignment expectations into this buffer. + SmallString<256> NameBuf; + StringRef NameRef = BufferName.toStringRef(NameBuf); + size_t AlignedStringLen = + alignTo(sizeof(MemoryBufferMem) + NameRef.size() + 1, 16); + size_t RealLen = AlignedStringLen + Size + 1; + char *Mem = static_cast(operator new(RealLen, std::nothrow)); + if (!Mem) + return nullptr; + + // The name is stored after the class itself. + CopyStringRef(Mem + sizeof(MemoryBufferMem), NameRef); + + // The buffer begins after the name and must be aligned. + char *Buf = Mem + AlignedStringLen; + Buf[Size] = 0; // Null terminate buffer. + + auto *Ret = new (Mem) MemoryBufferMem(StringRef(Buf, Size), true); + return std::unique_ptr(Ret); +} + +std::unique_ptr +MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) { + std::unique_ptr SB = getNewUninitMemBuffer(Size, BufferName); + if (!SB) + return nullptr; + memset(const_cast(SB->getBufferStart()), 0, Size); + return SB; +} + +ErrorOr> +MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize, + bool RequiresNullTerminator) { + SmallString<256> NameBuf; + StringRef NameRef = Filename.toStringRef(NameBuf); + + if (NameRef == "-") + return getSTDIN(); + return getFile(Filename, FileSize, RequiresNullTerminator); +} + +ErrorOr> +MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize, + uint64_t Offset) { + return getFileAux(FilePath, -1, MapSize, Offset, false, false); +} + + +//===----------------------------------------------------------------------===// +// MemoryBuffer::getFile implementation. +//===----------------------------------------------------------------------===// + +namespace { +/// \brief Memory maps a file descriptor using sys::fs::mapped_file_region. +/// +/// This handles converting the offset into a legal offset on the platform. +class MemoryBufferMMapFile : public MemoryBuffer { + sys::fs::mapped_file_region MFR; + + static uint64_t getLegalMapOffset(uint64_t Offset) { + return Offset & ~(sys::fs::mapped_file_region::alignment() - 1); + } + + static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) { + return Len + (Offset - getLegalMapOffset(Offset)); + } + + const char *getStart(uint64_t Len, uint64_t Offset) { + return MFR.const_data() + (Offset - getLegalMapOffset(Offset)); + } + +public: + MemoryBufferMMapFile(bool RequiresNullTerminator, int FD, uint64_t Len, + uint64_t Offset, std::error_code &EC) + : MFR(FD, sys::fs::mapped_file_region::readonly, + getLegalMapSize(Len, Offset), getLegalMapOffset(Offset), EC) { + if (!EC) { + const char *Start = getStart(Len, Offset); + init(Start, Start + Len, RequiresNullTerminator); + } + } + + /// Disable sized deallocation for MemoryBufferMMapFile, because it has + /// tail-allocated data. + void operator delete(void *p) { ::operator delete(p); } + + StringRef getBufferIdentifier() const override { + // The name is stored after the class itself. + return StringRef(reinterpret_cast(this + 1)); + } + + BufferKind getBufferKind() const override { + return MemoryBuffer_MMap; + } +}; +} + +static ErrorOr> +getMemoryBufferForStream(int FD, const Twine &BufferName) { + 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(FD, Buffer.end(), ChunkSize); + if (ReadBytes == -1) { + if (errno == EINTR) continue; + return std::error_code(errno, std::generic_category()); + } + Buffer.set_size(Buffer.size() + ReadBytes); + } while (ReadBytes != 0); + + return MemoryBuffer::getMemBufferCopy(Buffer, BufferName); +} + + +ErrorOr> +MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize, + bool RequiresNullTerminator, bool IsVolatileSize) { + return getFileAux(Filename, FileSize, FileSize, 0, + RequiresNullTerminator, IsVolatileSize); +} + +static ErrorOr> +getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize, + uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, + bool IsVolatileSize); + +static ErrorOr> +getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize, + uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize) { + int FD; + std::error_code EC = sys::fs::openFileForRead(Filename, FD); + if (EC) + return EC; + + ErrorOr> Ret = + getOpenFileImpl(FD, Filename, FileSize, MapSize, Offset, + RequiresNullTerminator, IsVolatileSize); + close(FD); + return Ret; +} + +static bool shouldUseMmap(int FD, + size_t FileSize, + size_t MapSize, + off_t Offset, + bool RequiresNullTerminator, + int PageSize, + bool IsVolatileSize) { + // mmap may leave the buffer without null terminator if the file size changed + // by the time the last page is mapped in, so avoid it if the file size is + // likely to change. + if (IsVolatileSize) + return false; + + // We don't use mmap for small files because this can severely fragment our + // address space. + if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize) + 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)) { + sys::fs::file_status Status; + if (sys::fs::status(FD, Status)) + return false; + FileSize = Status.getSize(); + } + + // 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; + +#if defined(__CYGWIN__) + // Don't try to map files that are exactly a multiple of the physical page size + // if we need a null terminator. + // FIXME: We should reorganize again getPageSize() on Win32. + if ((FileSize & (4096 - 1)) == 0) + return false; +#endif + + return true; +} + +static ErrorOr> +getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize, + uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, + bool IsVolatileSize) { + static int PageSize = sys::Process::getPageSize(); + + // Default is to map the full file. + if (MapSize == uint64_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 == uint64_t(-1)) { + sys::fs::file_status Status; + std::error_code EC = sys::fs::status(FD, Status); + if (EC) + return EC; + + // If this not a file or a block device (e.g. it's a named pipe + // or character device), we can't trust the size. Create the memory + // buffer by copying off the stream. + sys::fs::file_type Type = Status.type(); + if (Type != sys::fs::file_type::regular_file && + Type != sys::fs::file_type::block_file) + return getMemoryBufferForStream(FD, Filename); + + FileSize = Status.getSize(); + } + MapSize = FileSize; + } + + if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator, + PageSize, IsVolatileSize)) { + std::error_code EC; + std::unique_ptr Result( + new (NamedBufferAlloc(Filename)) + MemoryBufferMMapFile(RequiresNullTerminator, FD, MapSize, Offset, EC)); + if (!EC) + return std::move(Result); + } + + std::unique_ptr 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); + } + + char *BufPtr = const_cast(Buf->getBufferStart()); + + size_t BytesLeft = MapSize; +#ifndef HAVE_PREAD + if (lseek(FD, Offset, SEEK_SET) == -1) + return std::error_code(errno, std::generic_category()); +#endif + + while (BytesLeft) { +#ifdef HAVE_PREAD + ssize_t NumRead = ::pread(FD, BufPtr, BytesLeft, MapSize-BytesLeft+Offset); +#else + ssize_t NumRead = ::read(FD, BufPtr, BytesLeft); +#endif + if (NumRead == -1) { + if (errno == EINTR) + continue; + // Error while reading. + return std::error_code(errno, std::generic_category()); + } + if (NumRead == 0) { + memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer. + break; + } + BytesLeft -= NumRead; + BufPtr += NumRead; + } + + return std::move(Buf); +} + +ErrorOr> +MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize, + bool RequiresNullTerminator, bool IsVolatileSize) { + return getOpenFileImpl(FD, Filename, FileSize, FileSize, 0, + RequiresNullTerminator, IsVolatileSize); +} + +ErrorOr> +MemoryBuffer::getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize, + int64_t Offset) { + assert(MapSize != uint64_t(-1)); + return getOpenFileImpl(FD, Filename, -1, MapSize, Offset, false, + /*IsVolatileSize*/ false); +} + +ErrorOr> MemoryBuffer::getSTDIN() { + // 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::ChangeStdinToBinary(); + + return getMemoryBufferForStream(0, ""); +} + +ErrorOr> +MemoryBuffer::getFileAsStream(const Twine &Filename) { + int FD; + std::error_code EC = sys::fs::openFileForRead(Filename, FD); + if (EC) + return EC; + ErrorOr> Ret = + getMemoryBufferForStream(FD, Filename); + close(FD); + return Ret; +} + +MemoryBufferRef MemoryBuffer::getMemBufferRef() const { + StringRef Data = getBuffer(); + StringRef Identifier = getBufferIdentifier(); + return MemoryBufferRef(Data, Identifier); +}