-//===--- 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 <memory>
-#include <cstddef>
-#include <cstdint>
-
-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<std::unique_ptr<MemoryBuffer>>
- 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<std::unique_ptr<MemoryBuffer>>
- 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<std::unique_ptr<MemoryBuffer>>
- 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<std::unique_ptr<MemoryBuffer>>
- 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<MemoryBuffer>
- getMemBuffer(StringRef InputData, StringRef BufferName = "",
- bool RequiresNullTerminator = true);
-
- static std::unique_ptr<MemoryBuffer>
- 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<MemoryBuffer>
- 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<MemoryBuffer>
- 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<MemoryBuffer>
- getNewUninitMemBuffer(size_t Size, const Twine &BufferName = "");
-
- /// Read all of stdin into a file buffer, and return it.
- static ErrorOr<std::unique_ptr<MemoryBuffer>> getSTDIN();
-
- /// Open the specified file as a MemoryBuffer, or open stdin if the Filename
- /// is "-".
- static ErrorOr<std::unique_ptr<MemoryBuffer>>
- getFileOrSTDIN(const Twine &Filename, int64_t FileSize = -1,
- bool RequiresNullTerminator = true);
-
- /// Map a subrange of the specified file as a MemoryBuffer.
- static ErrorOr<std::unique_ptr<MemoryBuffer>>
- 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++ -*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file defines the MemoryBuffer interface.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_SUPPORT_MEMORYBUFFER_H\r
+#define LLVM_SUPPORT_MEMORYBUFFER_H\r
+\r
+#include "llvm/ADT/StringRef.h"\r
+#include "llvm/ADT/Twine.h"\r
+#include "llvm/Support/CBindingWrapping.h"\r
+#include "llvm/Support/ErrorOr.h"\r
+#include "llvm-c/Types.h"\r
+#include <memory>\r
+#include <cstddef>\r
+#include <cstdint>\r
+\r
+namespace llvm {\r
+\r
+class MemoryBufferRef;\r
+\r
+/// This interface provides simple read-only access to a block of memory, and\r
+/// provides simple methods for reading files and standard input into a memory\r
+/// buffer. In addition to basic access to the characters in the file, this\r
+/// interface guarantees you can read one character past the end of the file,\r
+/// and that this character will read as '\0'.\r
+///\r
+/// The '\0' guarantee is needed to support an optimization -- it's intended to\r
+/// be more efficient for clients which are reading all the data to stop\r
+/// reading when they encounter a '\0' than to continually check the file\r
+/// position to see if it has reached the end of the file.\r
+class MemoryBuffer {\r
+ const char *BufferStart; // Start of the buffer.\r
+ const char *BufferEnd; // End of the buffer.\r
+\r
+\r
+protected:\r
+ MemoryBuffer() = default;\r
+\r
+ void init(const char *BufStart, const char *BufEnd,\r
+ bool RequiresNullTerminator);\r
+public:\r
+ MemoryBuffer(const MemoryBuffer &) = delete;\r
+ MemoryBuffer &operator=(const MemoryBuffer &) = delete;\r
+ virtual ~MemoryBuffer();\r
+\r
+ const char *getBufferStart() const { return BufferStart; }\r
+ const char *getBufferEnd() const { return BufferEnd; }\r
+ size_t getBufferSize() const { return BufferEnd-BufferStart; }\r
+\r
+ StringRef getBuffer() const {\r
+ return StringRef(BufferStart, getBufferSize());\r
+ }\r
+\r
+ /// Return an identifier for this buffer, typically the filename it was read\r
+ /// from.\r
+ virtual StringRef getBufferIdentifier() const { return "Unknown buffer"; }\r
+\r
+ /// Open the specified file as a MemoryBuffer, returning a new MemoryBuffer\r
+ /// if successful, otherwise returning null. If FileSize is specified, this\r
+ /// means that the client knows that the file exists and that it has the\r
+ /// specified size.\r
+ ///\r
+ /// \param IsVolatileSize Set to true to indicate that the file size may be\r
+ /// changing, e.g. when libclang tries to parse while the user is\r
+ /// editing/updating the file.\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+ getFile(const Twine &Filename, int64_t FileSize = -1,\r
+ bool RequiresNullTerminator = true, bool IsVolatileSize = false);\r
+\r
+ /// Read all of the specified file into a MemoryBuffer as a stream\r
+ /// (i.e. until EOF reached). This is useful for special files that\r
+ /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux).\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+ getFileAsStream(const Twine &Filename);\r
+\r
+ /// Given an already-open file descriptor, map some slice of it into a\r
+ /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize.\r
+ /// Since this is in the middle of a file, the buffer is not null terminated.\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+ getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize,\r
+ int64_t Offset);\r
+\r
+ /// Given an already-open file descriptor, read the file and return a\r
+ /// MemoryBuffer.\r
+ ///\r
+ /// \param IsVolatileSize Set to true to indicate that the file size may be\r
+ /// changing, e.g. when libclang tries to parse while the user is\r
+ /// editing/updating the file.\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+ getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,\r
+ bool RequiresNullTerminator = true, bool IsVolatileSize = false);\r
+\r
+ /// Open the specified memory range as a MemoryBuffer. Note that InputData\r
+ /// must be null terminated if RequiresNullTerminator is true.\r
+ static std::unique_ptr<MemoryBuffer>\r
+ getMemBuffer(StringRef InputData, StringRef BufferName = "",\r
+ bool RequiresNullTerminator = true);\r
+\r
+ static std::unique_ptr<MemoryBuffer>\r
+ getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true);\r
+\r
+ /// Open the specified memory range as a MemoryBuffer, copying the contents\r
+ /// and taking ownership of it. InputData does not have to be null terminated.\r
+ static std::unique_ptr<MemoryBuffer>\r
+ getMemBufferCopy(StringRef InputData, const Twine &BufferName = "");\r
+\r
+ /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note\r
+ /// that the caller need not initialize the memory allocated by this method.\r
+ /// The memory is owned by the MemoryBuffer object.\r
+ static std::unique_ptr<MemoryBuffer>\r
+ getNewMemBuffer(size_t Size, StringRef BufferName = "");\r
+\r
+ /// Allocate a new MemoryBuffer of the specified size that is not initialized.\r
+ /// Note that the caller should initialize the memory allocated by this\r
+ /// method. The memory is owned by the MemoryBuffer object.\r
+ static std::unique_ptr<MemoryBuffer>\r
+ getNewUninitMemBuffer(size_t Size, const Twine &BufferName = "");\r
+\r
+ /// Read all of stdin into a file buffer, and return it.\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>> getSTDIN();\r
+\r
+ /// Open the specified file as a MemoryBuffer, or open stdin if the Filename\r
+ /// is "-".\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+ getFileOrSTDIN(const Twine &Filename, int64_t FileSize = -1,\r
+ bool RequiresNullTerminator = true);\r
+\r
+ /// Map a subrange of the specified file as a MemoryBuffer.\r
+ static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+ getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset);\r
+\r
+ //===--------------------------------------------------------------------===//\r
+ // Provided for performance analysis.\r
+ //===--------------------------------------------------------------------===//\r
+\r
+ /// The kind of memory backing used to support the MemoryBuffer.\r
+ enum BufferKind {\r
+ MemoryBuffer_Malloc,\r
+ MemoryBuffer_MMap\r
+ };\r
+\r
+ /// Return information on the memory mechanism used to support the\r
+ /// MemoryBuffer.\r
+ virtual BufferKind getBufferKind() const = 0;\r
+\r
+ MemoryBufferRef getMemBufferRef() const;\r
+};\r
+\r
+class MemoryBufferRef {\r
+ StringRef Buffer;\r
+ StringRef Identifier;\r
+\r
+public:\r
+ MemoryBufferRef() = default;\r
+ MemoryBufferRef(MemoryBuffer& Buffer)\r
+ : Buffer(Buffer.getBuffer()), Identifier(Buffer.getBufferIdentifier()) {}\r
+ MemoryBufferRef(StringRef Buffer, StringRef Identifier)\r
+ : Buffer(Buffer), Identifier(Identifier) {}\r
+\r
+ StringRef getBuffer() const { return Buffer; }\r
+\r
+ StringRef getBufferIdentifier() const { return Identifier; }\r
+\r
+ const char *getBufferStart() const { return Buffer.begin(); }\r
+ const char *getBufferEnd() const { return Buffer.end(); }\r
+ size_t getBufferSize() const { return Buffer.size(); }\r
+};\r
+\r
+// Create wrappers for C Binding types (see CBindingWrapping.h).\r
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef)\r
+\r
+} // end namespace llvm\r
+\r
+#endif // LLVM_SUPPORT_MEMORYBUFFER_H\r
-//===--- 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 <cassert>
-#include <cerrno>
-#include <cstring>
-#include <new>
-#include <sys/types.h>
-#include <system_error>
-#if !defined(_MSC_VER) && !defined(__MINGW32__)
-#include <unistd.h>
-#else
-#include <io.h>
-#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<char *>(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<const char *>(this + 1));
- }
-
- BufferKind getBufferKind() const override {
- return MemoryBuffer_Malloc;
- }
-};
-}
-
-static ErrorOr<std::unique_ptr<MemoryBuffer>>
-getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
- uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize);
-
-std::unique_ptr<MemoryBuffer>
-MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
- bool RequiresNullTerminator) {
- auto *Ret = new (NamedBufferAlloc(BufferName))
- MemoryBufferMem(InputData, RequiresNullTerminator);
- return std::unique_ptr<MemoryBuffer>(Ret);
-}
-
-std::unique_ptr<MemoryBuffer>
-MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
- return std::unique_ptr<MemoryBuffer>(getMemBuffer(
- Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator));
-}
-
-std::unique_ptr<MemoryBuffer>
-MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
- std::unique_ptr<MemoryBuffer> Buf =
- getNewUninitMemBuffer(InputData.size(), BufferName);
- if (!Buf)
- return nullptr;
- memcpy(const_cast<char*>(Buf->getBufferStart()), InputData.data(),
- InputData.size());
- return Buf;
-}
-
-std::unique_ptr<MemoryBuffer>
-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<char*>(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<MemoryBuffer>(Ret);
-}
-
-std::unique_ptr<MemoryBuffer>
-MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) {
- std::unique_ptr<MemoryBuffer> SB = getNewUninitMemBuffer(Size, BufferName);
- if (!SB)
- return nullptr;
- memset(const_cast<char*>(SB->getBufferStart()), 0, Size);
- return SB;
-}
-
-ErrorOr<std::unique_ptr<MemoryBuffer>>
-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<std::unique_ptr<MemoryBuffer>>
-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<const char *>(this + 1));
- }
-
- BufferKind getBufferKind() const override {
- return MemoryBuffer_MMap;
- }
-};
-}
-
-static ErrorOr<std::unique_ptr<MemoryBuffer>>
-getMemoryBufferForStream(int FD, const Twine &BufferName) {
- const ssize_t ChunkSize = 4096*4;
- SmallString<ChunkSize> 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<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
- bool RequiresNullTerminator, bool IsVolatileSize) {
- return getFileAux(Filename, FileSize, FileSize, 0,
- RequiresNullTerminator, IsVolatileSize);
-}
-
-static ErrorOr<std::unique_ptr<MemoryBuffer>>
-getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
- uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
- bool IsVolatileSize);
-
-static ErrorOr<std::unique_ptr<MemoryBuffer>>
-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<std::unique_ptr<MemoryBuffer>> 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<std::unique_ptr<MemoryBuffer>>
-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<MemoryBuffer> Result(
- new (NamedBufferAlloc(Filename))
- MemoryBufferMMapFile(RequiresNullTerminator, FD, MapSize, Offset, EC));
- if (!EC)
- return std::move(Result);
- }
-
- std::unique_ptr<MemoryBuffer> 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<char *>(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<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,
- bool RequiresNullTerminator, bool IsVolatileSize) {
- return getOpenFileImpl(FD, Filename, FileSize, FileSize, 0,
- RequiresNullTerminator, IsVolatileSize);
-}
-
-ErrorOr<std::unique_ptr<MemoryBuffer>>
-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<std::unique_ptr<MemoryBuffer>> 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, "<stdin>");
-}
-
-ErrorOr<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getFileAsStream(const Twine &Filename) {
- int FD;
- std::error_code EC = sys::fs::openFileForRead(Filename, FD);
- if (EC)
- return EC;
- ErrorOr<std::unique_ptr<MemoryBuffer>> 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 ------------------===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file implements the MemoryBuffer interface.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "llvm/Support/MemoryBuffer.h"\r
+#include "llvm/ADT/SmallString.h"\r
+#include "llvm/Config/config.h"\r
+#include "llvm/Support/Errc.h"\r
+#include "llvm/Support/Errno.h"\r
+#include "llvm/Support/FileSystem.h"\r
+#include "llvm/Support/MathExtras.h"\r
+#include "llvm/Support/Path.h"\r
+#include "llvm/Support/Process.h"\r
+#include "llvm/Support/Program.h"\r
+#include <cassert>\r
+#include <cerrno>\r
+#include <cstring>\r
+#include <new>\r
+#include <sys/types.h>\r
+#include <system_error>\r
+#if !defined(_MSC_VER) && !defined(__MINGW32__)\r
+#include <unistd.h>\r
+#else\r
+#include <io.h>\r
+#endif\r
+using namespace llvm;\r
+\r
+//===----------------------------------------------------------------------===//\r
+// MemoryBuffer implementation itself.\r
+//===----------------------------------------------------------------------===//\r
+\r
+MemoryBuffer::~MemoryBuffer() { }\r
+\r
+/// init - Initialize this MemoryBuffer as a reference to externally allocated\r
+/// memory, memory that we know is already null terminated.\r
+void MemoryBuffer::init(const char *BufStart, const char *BufEnd,\r
+ bool RequiresNullTerminator) {\r
+ assert((!RequiresNullTerminator || BufEnd[0] == 0) &&\r
+ "Buffer is not null terminated!");\r
+ BufferStart = BufStart;\r
+ BufferEnd = BufEnd;\r
+}\r
+\r
+//===----------------------------------------------------------------------===//\r
+// MemoryBufferMem implementation.\r
+//===----------------------------------------------------------------------===//\r
+\r
+/// CopyStringRef - Copies contents of a StringRef into a block of memory and\r
+/// null-terminates it.\r
+static void CopyStringRef(char *Memory, StringRef Data) {\r
+ if (!Data.empty())\r
+ memcpy(Memory, Data.data(), Data.size());\r
+ Memory[Data.size()] = 0; // Null terminate string.\r
+}\r
+\r
+namespace {\r
+struct NamedBufferAlloc {\r
+ const Twine &Name;\r
+ NamedBufferAlloc(const Twine &Name) : Name(Name) {}\r
+};\r
+}\r
+\r
+void *operator new(size_t N, const NamedBufferAlloc &Alloc) {\r
+ SmallString<256> NameBuf;\r
+ StringRef NameRef = Alloc.Name.toStringRef(NameBuf);\r
+\r
+ char *Mem = static_cast<char *>(operator new(N + NameRef.size() + 1));\r
+ CopyStringRef(Mem + N, NameRef);\r
+ return Mem;\r
+}\r
+\r
+namespace {\r
+/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.\r
+class MemoryBufferMem : public MemoryBuffer {\r
+public:\r
+ MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {\r
+ init(InputData.begin(), InputData.end(), RequiresNullTerminator);\r
+ }\r
+\r
+ /// Disable sized deallocation for MemoryBufferMem, because it has\r
+ /// tail-allocated data.\r
+ void operator delete(void *p) { ::operator delete(p); }\r
+\r
+ StringRef getBufferIdentifier() const override {\r
+ // The name is stored after the class itself.\r
+ return StringRef(reinterpret_cast<const char *>(this + 1));\r
+ }\r
+\r
+ BufferKind getBufferKind() const override {\r
+ return MemoryBuffer_Malloc;\r
+ }\r
+};\r
+}\r
+\r
+static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize, \r
+ uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize);\r
+\r
+std::unique_ptr<MemoryBuffer>\r
+MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,\r
+ bool RequiresNullTerminator) {\r
+ auto *Ret = new (NamedBufferAlloc(BufferName))\r
+ MemoryBufferMem(InputData, RequiresNullTerminator);\r
+ return std::unique_ptr<MemoryBuffer>(Ret);\r
+}\r
+\r
+std::unique_ptr<MemoryBuffer>\r
+MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {\r
+ return std::unique_ptr<MemoryBuffer>(getMemBuffer(\r
+ Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator));\r
+}\r
+\r
+std::unique_ptr<MemoryBuffer>\r
+MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {\r
+ std::unique_ptr<MemoryBuffer> Buf =\r
+ getNewUninitMemBuffer(InputData.size(), BufferName);\r
+ if (!Buf)\r
+ return nullptr;\r
+ memcpy(const_cast<char*>(Buf->getBufferStart()), InputData.data(),\r
+ InputData.size());\r
+ return Buf;\r
+}\r
+\r
+std::unique_ptr<MemoryBuffer>\r
+MemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName) {\r
+ // Allocate space for the MemoryBuffer, the data and the name. It is important\r
+ // that MemoryBuffer and data are aligned so PointerIntPair works with them.\r
+ // TODO: Is 16-byte alignment enough? We copy small object files with large\r
+ // alignment expectations into this buffer.\r
+ SmallString<256> NameBuf;\r
+ StringRef NameRef = BufferName.toStringRef(NameBuf);\r
+ size_t AlignedStringLen =\r
+ alignTo(sizeof(MemoryBufferMem) + NameRef.size() + 1, 16);\r
+ size_t RealLen = AlignedStringLen + Size + 1;\r
+ char *Mem = static_cast<char*>(operator new(RealLen, std::nothrow));\r
+ if (!Mem)\r
+ return nullptr;\r
+\r
+ // The name is stored after the class itself.\r
+ CopyStringRef(Mem + sizeof(MemoryBufferMem), NameRef);\r
+\r
+ // The buffer begins after the name and must be aligned.\r
+ char *Buf = Mem + AlignedStringLen;\r
+ Buf[Size] = 0; // Null terminate buffer.\r
+\r
+ auto *Ret = new (Mem) MemoryBufferMem(StringRef(Buf, Size), true);\r
+ return std::unique_ptr<MemoryBuffer>(Ret);\r
+}\r
+\r
+std::unique_ptr<MemoryBuffer>\r
+MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) {\r
+ std::unique_ptr<MemoryBuffer> SB = getNewUninitMemBuffer(Size, BufferName);\r
+ if (!SB)\r
+ return nullptr;\r
+ memset(const_cast<char*>(SB->getBufferStart()), 0, Size);\r
+ return SB;\r
+}\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize,\r
+ bool RequiresNullTerminator) {\r
+ SmallString<256> NameBuf;\r
+ StringRef NameRef = Filename.toStringRef(NameBuf);\r
+\r
+ if (NameRef == "-")\r
+ return getSTDIN();\r
+ return getFile(Filename, FileSize, RequiresNullTerminator);\r
+}\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize, \r
+ uint64_t Offset) {\r
+ return getFileAux(FilePath, -1, MapSize, Offset, false, false);\r
+}\r
+\r
+\r
+//===----------------------------------------------------------------------===//\r
+// MemoryBuffer::getFile implementation.\r
+//===----------------------------------------------------------------------===//\r
+\r
+namespace {\r
+/// \brief Memory maps a file descriptor using sys::fs::mapped_file_region.\r
+///\r
+/// This handles converting the offset into a legal offset on the platform.\r
+class MemoryBufferMMapFile : public MemoryBuffer {\r
+ sys::fs::mapped_file_region MFR;\r
+\r
+ static uint64_t getLegalMapOffset(uint64_t Offset) {\r
+ return Offset & ~(sys::fs::mapped_file_region::alignment() - 1);\r
+ }\r
+\r
+ static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) {\r
+ return Len + (Offset - getLegalMapOffset(Offset));\r
+ }\r
+\r
+ const char *getStart(uint64_t Len, uint64_t Offset) {\r
+ return MFR.const_data() + (Offset - getLegalMapOffset(Offset));\r
+ }\r
+\r
+public:\r
+ MemoryBufferMMapFile(bool RequiresNullTerminator, int FD, uint64_t Len,\r
+ uint64_t Offset, std::error_code &EC)\r
+ : MFR(FD, sys::fs::mapped_file_region::readonly,\r
+ getLegalMapSize(Len, Offset), getLegalMapOffset(Offset), EC) {\r
+ if (!EC) {\r
+ const char *Start = getStart(Len, Offset);\r
+ init(Start, Start + Len, RequiresNullTerminator);\r
+ }\r
+ }\r
+\r
+ /// Disable sized deallocation for MemoryBufferMMapFile, because it has\r
+ /// tail-allocated data.\r
+ void operator delete(void *p) { ::operator delete(p); }\r
+\r
+ StringRef getBufferIdentifier() const override {\r
+ // The name is stored after the class itself.\r
+ return StringRef(reinterpret_cast<const char *>(this + 1));\r
+ }\r
+\r
+ BufferKind getBufferKind() const override {\r
+ return MemoryBuffer_MMap;\r
+ }\r
+};\r
+}\r
+\r
+static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+getMemoryBufferForStream(int FD, const Twine &BufferName) {\r
+ const ssize_t ChunkSize = 4096*4;\r
+ SmallString<ChunkSize> Buffer;\r
+ ssize_t ReadBytes;\r
+ // Read into Buffer until we hit EOF.\r
+ do {\r
+ Buffer.reserve(Buffer.size() + ChunkSize);\r
+ ReadBytes = read(FD, Buffer.end(), ChunkSize);\r
+ if (ReadBytes == -1) {\r
+ if (errno == EINTR) continue;\r
+ return std::error_code(errno, std::generic_category());\r
+ }\r
+ Buffer.set_size(Buffer.size() + ReadBytes);\r
+ } while (ReadBytes != 0);\r
+\r
+ return MemoryBuffer::getMemBufferCopy(Buffer, BufferName);\r
+}\r
+\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,\r
+ bool RequiresNullTerminator, bool IsVolatileSize) {\r
+ return getFileAux(Filename, FileSize, FileSize, 0,\r
+ RequiresNullTerminator, IsVolatileSize);\r
+}\r
+\r
+static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,\r
+ uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,\r
+ bool IsVolatileSize);\r
+\r
+static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,\r
+ uint64_t Offset, bool RequiresNullTerminator, bool IsVolatileSize) {\r
+ int FD;\r
+ std::error_code EC = sys::fs::openFileForRead(Filename, FD);\r
+ if (EC)\r
+ return EC;\r
+\r
+ ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =\r
+ getOpenFileImpl(FD, Filename, FileSize, MapSize, Offset,\r
+ RequiresNullTerminator, IsVolatileSize);\r
+ close(FD);\r
+ return Ret;\r
+}\r
+\r
+static bool shouldUseMmap(int FD,\r
+ size_t FileSize,\r
+ size_t MapSize,\r
+ off_t Offset,\r
+ bool RequiresNullTerminator,\r
+ int PageSize,\r
+ bool IsVolatileSize) {\r
+ // mmap may leave the buffer without null terminator if the file size changed\r
+ // by the time the last page is mapped in, so avoid it if the file size is\r
+ // likely to change.\r
+ if (IsVolatileSize)\r
+ return false;\r
+\r
+ // We don't use mmap for small files because this can severely fragment our\r
+ // address space.\r
+ if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize)\r
+ return false;\r
+\r
+ if (!RequiresNullTerminator)\r
+ return true;\r
+\r
+\r
+ // If we don't know the file size, use fstat to find out. fstat on an open\r
+ // file descriptor is cheaper than stat on a random path.\r
+ // FIXME: this chunk of code is duplicated, but it avoids a fstat when\r
+ // RequiresNullTerminator = false and MapSize != -1.\r
+ if (FileSize == size_t(-1)) {\r
+ sys::fs::file_status Status;\r
+ if (sys::fs::status(FD, Status))\r
+ return false;\r
+ FileSize = Status.getSize();\r
+ }\r
+\r
+ // If we need a null terminator and the end of the map is inside the file,\r
+ // we cannot use mmap.\r
+ size_t End = Offset + MapSize;\r
+ assert(End <= FileSize);\r
+ if (End != FileSize)\r
+ return false;\r
+\r
+ // Don't try to map files that are exactly a multiple of the system page size\r
+ // if we need a null terminator.\r
+ if ((FileSize & (PageSize -1)) == 0)\r
+ return false;\r
+\r
+#if defined(__CYGWIN__)\r
+ // Don't try to map files that are exactly a multiple of the physical page size\r
+ // if we need a null terminator.\r
+ // FIXME: We should reorganize again getPageSize() on Win32.\r
+ if ((FileSize & (4096 - 1)) == 0)\r
+ return false;\r
+#endif\r
+\r
+ return true;\r
+}\r
+\r
+static ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,\r
+ uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,\r
+ bool IsVolatileSize) {\r
+ static int PageSize = sys::Process::getPageSize();\r
+\r
+ // Default is to map the full file.\r
+ if (MapSize == uint64_t(-1)) {\r
+ // If we don't know the file size, use fstat to find out. fstat on an open\r
+ // file descriptor is cheaper than stat on a random path.\r
+ if (FileSize == uint64_t(-1)) {\r
+ sys::fs::file_status Status;\r
+ std::error_code EC = sys::fs::status(FD, Status);\r
+ if (EC)\r
+ return EC;\r
+\r
+ // If this not a file or a block device (e.g. it's a named pipe\r
+ // or character device), we can't trust the size. Create the memory\r
+ // buffer by copying off the stream.\r
+ sys::fs::file_type Type = Status.type();\r
+ if (Type != sys::fs::file_type::regular_file &&\r
+ Type != sys::fs::file_type::block_file)\r
+ return getMemoryBufferForStream(FD, Filename);\r
+\r
+ FileSize = Status.getSize();\r
+ }\r
+ MapSize = FileSize;\r
+ }\r
+\r
+ if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,\r
+ PageSize, IsVolatileSize)) {\r
+ std::error_code EC;\r
+ std::unique_ptr<MemoryBuffer> Result(\r
+ new (NamedBufferAlloc(Filename))\r
+ MemoryBufferMMapFile(RequiresNullTerminator, FD, MapSize, Offset, EC));\r
+ if (!EC)\r
+ return std::move(Result);\r
+ }\r
+\r
+ std::unique_ptr<MemoryBuffer> Buf =\r
+ MemoryBuffer::getNewUninitMemBuffer(MapSize, Filename);\r
+ if (!Buf) {\r
+ // Failed to create a buffer. The only way it can fail is if\r
+ // new(std::nothrow) returns 0.\r
+ return make_error_code(errc::not_enough_memory);\r
+ }\r
+\r
+ char *BufPtr = const_cast<char *>(Buf->getBufferStart());\r
+\r
+ size_t BytesLeft = MapSize;\r
+#ifndef HAVE_PREAD\r
+ if (lseek(FD, Offset, SEEK_SET) == -1)\r
+ return std::error_code(errno, std::generic_category());\r
+#endif\r
+\r
+ while (BytesLeft) {\r
+#ifdef HAVE_PREAD\r
+ ssize_t NumRead = ::pread(FD, BufPtr, BytesLeft, MapSize-BytesLeft+Offset);\r
+#else\r
+ ssize_t NumRead = ::read(FD, BufPtr, BytesLeft);\r
+#endif\r
+ if (NumRead == -1) {\r
+ if (errno == EINTR)\r
+ continue;\r
+ // Error while reading.\r
+ return std::error_code(errno, std::generic_category());\r
+ }\r
+ if (NumRead == 0) {\r
+ memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer.\r
+ break;\r
+ }\r
+ BytesLeft -= NumRead;\r
+ BufPtr += NumRead;\r
+ }\r
+\r
+ return std::move(Buf);\r
+}\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,\r
+ bool RequiresNullTerminator, bool IsVolatileSize) {\r
+ return getOpenFileImpl(FD, Filename, FileSize, FileSize, 0,\r
+ RequiresNullTerminator, IsVolatileSize);\r
+}\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+MemoryBuffer::getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize,\r
+ int64_t Offset) {\r
+ assert(MapSize != uint64_t(-1));\r
+ return getOpenFileImpl(FD, Filename, -1, MapSize, Offset, false,\r
+ /*IsVolatileSize*/ false);\r
+}\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {\r
+ // Read in all of the data from stdin, we cannot mmap stdin.\r
+ //\r
+ // FIXME: That isn't necessarily true, we should try to mmap stdin and\r
+ // fallback if it fails.\r
+ sys::ChangeStdinToBinary();\r
+\r
+ return getMemoryBufferForStream(0, "<stdin>");\r
+}\r
+\r
+ErrorOr<std::unique_ptr<MemoryBuffer>>\r
+MemoryBuffer::getFileAsStream(const Twine &Filename) {\r
+ int FD;\r
+ std::error_code EC = sys::fs::openFileForRead(Filename, FD);\r
+ if (EC)\r
+ return EC;\r
+ ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =\r
+ getMemoryBufferForStream(FD, Filename);\r
+ close(FD);\r
+ return Ret;\r
+}\r
+\r
+MemoryBufferRef MemoryBuffer::getMemBufferRef() const {\r
+ StringRef Data = getBuffer();\r
+ StringRef Identifier = getBufferIdentifier();\r
+ return MemoryBufferRef(Data, Identifier);\r
+}\r
OSDN Git Service
