//===----------------------------------------------------------------------===//
#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Config/config.h"
#include "llvm/Support/Errno.h"
#include <cstdio>
#include <cstring>
#include <new>
-#include <sys/stat.h>
#include <sys/types.h>
#if !defined(_MSC_VER) && !defined(__MINGW32__)
#include <unistd.h>
#else
#include <io.h>
-// Simplistic definitinos of these macros for use in getOpenFile.
-#ifndef S_ISREG
-#define S_ISREG(x) (1)
-#endif
-#ifndef S_ISBLK
-#define S_ISBLK(x) (0)
-#endif
#endif
using namespace llvm;
MemoryBuffer *MemoryBuffer::getMemBufferCopy(StringRef InputData,
StringRef BufferName) {
MemoryBuffer *Buf = getNewUninitMemBuffer(InputData.size(), BufferName);
- if (!Buf) return 0;
+ if (!Buf) return nullptr;
memcpy(const_cast<char*>(Buf->getBufferStart()), InputData.data(),
InputData.size());
return Buf;
RoundUpToAlignment(sizeof(MemoryBufferMem) + BufferName.size() + 1, 16);
size_t RealLen = AlignedStringLen + Size + 1;
char *Mem = static_cast<char*>(operator new(RealLen, std::nothrow));
- if (!Mem) return 0;
+ if (!Mem) return nullptr;
// The name is stored after the class itself.
CopyStringRef(Mem + sizeof(MemoryBufferMem), BufferName);
/// the MemoryBuffer object.
MemoryBuffer *MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) {
MemoryBuffer *SB = getNewUninitMemBuffer(Size, BufferName);
- if (!SB) return 0;
+ if (!SB) return nullptr;
memset(const_cast<char*>(SB->getBufferStart()), 0, Size);
return SB;
}
return getFile(Filename, Result, FileSize);
}
-error_code MemoryBuffer::getFileOrSTDIN(StringRef Filename,
- OwningPtr<MemoryBuffer> &Result,
- int64_t FileSize) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getFileOrSTDIN(Filename, MB, FileSize);
- Result = std::move(MB);
- return ec;
-}
-
//===----------------------------------------------------------------------===//
// MemoryBuffer::getFile implementation.
static error_code getFileAux(const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
int64_t FileSize,
- bool RequiresNullTerminator);
+ bool RequiresNullTerminator,
+ bool IsVolatileSize);
error_code MemoryBuffer::getFile(Twine Filename,
std::unique_ptr<MemoryBuffer> &Result,
int64_t FileSize,
- bool RequiresNullTerminator) {
+ bool RequiresNullTerminator,
+ bool IsVolatileSize) {
// Ensure the path is null terminated.
SmallString<256> PathBuf;
StringRef NullTerminatedName = Filename.toNullTerminatedStringRef(PathBuf);
return getFileAux(NullTerminatedName.data(), Result, FileSize,
- RequiresNullTerminator);
-}
-
-error_code MemoryBuffer::getFile(Twine Filename,
- OwningPtr<MemoryBuffer> &Result,
- int64_t FileSize,
- bool RequiresNullTerminator) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getFile(Filename, MB, FileSize, RequiresNullTerminator);
- Result = std::move(MB);
- return ec;
+ RequiresNullTerminator, IsVolatileSize);
}
static error_code getOpenFileImpl(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t FileSize, uint64_t MapSize,
- int64_t Offset, bool RequiresNullTerminator);
+ int64_t Offset, bool RequiresNullTerminator,
+ bool IsVolatileSize);
static error_code getFileAux(const char *Filename,
std::unique_ptr<MemoryBuffer> &Result, int64_t FileSize,
- bool RequiresNullTerminator) {
+ bool RequiresNullTerminator,
+ bool IsVolatileSize) {
int FD;
error_code EC = sys::fs::openFileForRead(Filename, FD);
if (EC)
return EC;
error_code ret = getOpenFileImpl(FD, Filename, Result, FileSize, FileSize, 0,
- RequiresNullTerminator);
+ RequiresNullTerminator, IsVolatileSize);
close(FD);
return ret;
}
size_t MapSize,
off_t Offset,
bool RequiresNullTerminator,
- int PageSize) {
+ 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)
// RequiresNullTerminator = false and MapSize != -1.
if (FileSize == size_t(-1)) {
sys::fs::file_status Status;
- error_code EC = sys::fs::status(FD, Status);
- if (EC)
- return EC;
+ if (sys::fs::status(FD, Status))
+ return false;
FileSize = Status.getSize();
}
if (End != FileSize)
return false;
-#if defined(_WIN32) || defined(__CYGWIN__)
- // Don't peek the next page if file is multiple of *physical* pagesize(4k)
- // but is not multiple of AllocationGranularity(64k),
- // when a null terminator is required.
- // FIXME: It's not good to hardcode 4096 here. dwPageSize shows 4096.
- if ((FileSize & (4096 - 1)) == 0)
- return false;
-#endif
-
// 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)
static error_code getOpenFileImpl(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t FileSize, uint64_t MapSize,
- int64_t Offset, bool RequiresNullTerminator) {
+ int64_t Offset, bool RequiresNullTerminator,
+ bool IsVolatileSize) {
static int PageSize = sys::process::get_self()->page_size();
// Default is to map the full file.
}
if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
- PageSize)) {
+ PageSize, IsVolatileSize)) {
error_code EC;
Result.reset(new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile(
RequiresNullTerminator, FD, MapSize, Offset, EC));
return error_code(errno, posix_category());
}
if (NumRead == 0) {
- assert(0 && "We got inaccurate FileSize value or fstat reported an "
- "invalid file size.");
- *BufPtr = '\0'; // null-terminate at the actual size.
+ memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer.
break;
}
BytesLeft -= NumRead;
error_code MemoryBuffer::getOpenFile(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t FileSize,
- bool RequiresNullTerminator) {
+ bool RequiresNullTerminator,
+ bool IsVolatileSize) {
return getOpenFileImpl(FD, Filename, Result, FileSize, FileSize, 0,
- RequiresNullTerminator);
-}
-
-error_code MemoryBuffer::getOpenFile(int FD, const char *Filename,
- OwningPtr<MemoryBuffer> &Result,
- uint64_t FileSize,
- bool RequiresNullTerminator) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getOpenFileImpl(FD, Filename, MB, FileSize, FileSize, 0,
- RequiresNullTerminator);
- Result = std::move(MB);
- return ec;
+ RequiresNullTerminator, IsVolatileSize);
}
error_code MemoryBuffer::getOpenFileSlice(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
- uint64_t MapSize, int64_t Offset) {
- return getOpenFileImpl(FD, Filename, Result, -1, MapSize, Offset, false);
-}
-
-error_code MemoryBuffer::getOpenFileSlice(int FD, const char *Filename,
- OwningPtr<MemoryBuffer> &Result,
- uint64_t MapSize, int64_t Offset) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getOpenFileImpl(FD, Filename, MB, -1, MapSize, Offset, false);
- Result = std::move(MB);
- return ec;
+ uint64_t MapSize, int64_t Offset,
+ bool IsVolatileSize) {
+ return getOpenFileImpl(FD, Filename, Result, -1, MapSize, Offset, false,
+ IsVolatileSize);
}
//===----------------------------------------------------------------------===//
return getMemoryBufferForStream(0, "<stdin>", Result);
}
-
-error_code MemoryBuffer::getSTDIN(OwningPtr<MemoryBuffer> &Result) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getSTDIN(MB);
- Result = std::move(MB);
- return ec;
-}
OSDN Git Service
