2017-02-22 03:52:57 +08:00
|
|
|
//===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2017-02-22 03:52:57 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// 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"
|
2018-04-16 11:44:03 +08:00
|
|
|
#include "llvm/Support/SmallVectorMemoryBuffer.h"
|
2017-02-22 03:52:57 +08:00
|
|
|
#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.
|
2017-12-19 20:15:50 +08:00
|
|
|
template<typename MB>
|
|
|
|
class MemoryBufferMem : public MB {
|
2017-02-22 03:52:57 +08:00
|
|
|
public:
|
|
|
|
MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {
|
2017-12-19 20:15:50 +08:00
|
|
|
MemoryBuffer::init(InputData.begin(), InputData.end(),
|
|
|
|
RequiresNullTerminator);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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));
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
MemoryBuffer::BufferKind getBufferKind() const override {
|
|
|
|
return MemoryBuffer::MemoryBuffer_Malloc;
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
template <typename MB>
|
|
|
|
static ErrorOr<std::unique_ptr<MB>>
|
|
|
|
getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile);
|
2017-02-22 03:52:57 +08:00
|
|
|
|
|
|
|
std::unique_ptr<MemoryBuffer>
|
|
|
|
MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
|
|
|
|
bool RequiresNullTerminator) {
|
|
|
|
auto *Ret = new (NamedBufferAlloc(BufferName))
|
2017-12-19 20:15:50 +08:00
|
|
|
MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
|
2017-02-22 03:52:57 +08:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
|
|
|
|
getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
|
|
|
|
auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
|
|
|
|
if (!Buf)
|
|
|
|
return make_error_code(errc::not_enough_memory);
|
|
|
|
memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
|
2020-02-10 23:06:45 +08:00
|
|
|
return std::move(Buf);
|
2017-12-19 20:15:50 +08:00
|
|
|
}
|
|
|
|
|
2017-02-22 03:52:57 +08:00
|
|
|
std::unique_ptr<MemoryBuffer>
|
|
|
|
MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
|
2017-12-19 20:15:50 +08:00
|
|
|
auto Buf = getMemBufferCopyImpl(InputData, BufferName);
|
|
|
|
if (Buf)
|
|
|
|
return std::move(*Buf);
|
|
|
|
return nullptr;
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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>>
|
2018-07-31 03:41:25 +08:00
|
|
|
MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
uint64_t Offset, bool IsVolatile) {
|
2017-12-19 20:15:50 +08:00
|
|
|
return getFileAux<MemoryBuffer>(FilePath, -1, MapSize, Offset, false,
|
|
|
|
IsVolatile);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// MemoryBuffer::getFile implementation.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Memory maps a file descriptor using sys::fs::mapped_file_region.
|
2017-02-22 03:52:57 +08:00
|
|
|
///
|
|
|
|
/// This handles converting the offset into a legal offset on the platform.
|
2017-12-19 20:15:50 +08:00
|
|
|
template<typename MB>
|
|
|
|
class MemoryBufferMMapFile : public MB {
|
2017-02-22 03:52:57 +08:00
|
|
|
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:
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
MemoryBufferMMapFile(bool RequiresNullTerminator, sys::fs::file_t FD, uint64_t Len,
|
2017-02-22 03:52:57 +08:00
|
|
|
uint64_t Offset, std::error_code &EC)
|
2018-03-09 04:34:47 +08:00
|
|
|
: MFR(FD, MB::Mapmode, getLegalMapSize(Len, Offset),
|
|
|
|
getLegalMapOffset(Offset), EC) {
|
2017-02-22 03:52:57 +08:00
|
|
|
if (!EC) {
|
|
|
|
const char *Start = getStart(Len, Offset);
|
2017-12-19 20:15:50 +08:00
|
|
|
MemoryBuffer::init(Start, Start + Len, RequiresNullTerminator);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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));
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
MemoryBuffer::BufferKind getBufferKind() const override {
|
|
|
|
return MemoryBuffer::MemoryBuffer_MMap;
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
getMemoryBufferForStream(sys::fs::file_t FD, const Twine &BufferName) {
|
2017-02-22 03:52:57 +08:00
|
|
|
const ssize_t ChunkSize = 4096*4;
|
|
|
|
SmallString<ChunkSize> Buffer;
|
|
|
|
// Read into Buffer until we hit EOF.
|
2019-08-22 16:13:30 +08:00
|
|
|
for (;;) {
|
2017-02-22 03:52:57 +08:00
|
|
|
Buffer.reserve(Buffer.size() + ChunkSize);
|
2019-08-22 16:13:30 +08:00
|
|
|
Expected<size_t> ReadBytes = sys::fs::readNativeFile(
|
|
|
|
FD, makeMutableArrayRef(Buffer.end(), ChunkSize));
|
|
|
|
if (!ReadBytes)
|
|
|
|
return errorToErrorCode(ReadBytes.takeError());
|
|
|
|
if (*ReadBytes == 0)
|
|
|
|
break;
|
|
|
|
Buffer.set_size(Buffer.size() + *ReadBytes);
|
|
|
|
}
|
2017-02-22 03:52:57 +08:00
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
return getMemBufferCopyImpl(Buffer, BufferName);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>>
|
|
|
|
MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
bool RequiresNullTerminator, bool IsVolatile) {
|
2017-12-19 20:15:50 +08:00
|
|
|
return getFileAux<MemoryBuffer>(Filename, FileSize, FileSize, 0,
|
|
|
|
RequiresNullTerminator, IsVolatile);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
template <typename MB>
|
|
|
|
static ErrorOr<std::unique_ptr<MB>>
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
|
2017-02-22 03:52:57 +08:00
|
|
|
uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
|
2017-02-22 04:55:47 +08:00
|
|
|
bool IsVolatile);
|
2017-02-22 03:52:57 +08:00
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
template <typename MB>
|
|
|
|
static ErrorOr<std::unique_ptr<MB>>
|
2017-02-22 03:52:57 +08:00
|
|
|
getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile) {
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
Expected<sys::fs::file_t> FDOrErr =
|
|
|
|
sys::fs::openNativeFileForRead(Filename, sys::fs::OF_None);
|
|
|
|
if (!FDOrErr)
|
|
|
|
return errorToErrorCode(FDOrErr.takeError());
|
|
|
|
sys::fs::file_t FD = *FDOrErr;
|
2017-12-19 20:15:50 +08:00
|
|
|
auto Ret = getOpenFileImpl<MB>(FD, Filename, FileSize, MapSize, Offset,
|
|
|
|
RequiresNullTerminator, IsVolatile);
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
sys::fs::closeFile(FD);
|
2017-02-22 03:52:57 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
|
|
|
|
WritableMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
|
|
|
|
bool IsVolatile) {
|
|
|
|
return getFileAux<WritableMemoryBuffer>(Filename, FileSize, FileSize, 0,
|
|
|
|
/*RequiresNullTerminator*/ false,
|
|
|
|
IsVolatile);
|
|
|
|
}
|
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
|
|
|
|
WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
|
|
|
|
uint64_t Offset, bool IsVolatile) {
|
|
|
|
return getFileAux<WritableMemoryBuffer>(Filename, -1, MapSize, Offset, false,
|
|
|
|
IsVolatile);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<WritableMemoryBuffer>
|
|
|
|
WritableMemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName) {
|
|
|
|
using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
|
|
|
|
// 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(MemBuffer) + 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(MemBuffer), 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) MemBuffer(StringRef(Buf, Size), true);
|
|
|
|
return std::unique_ptr<WritableMemoryBuffer>(Ret);
|
|
|
|
}
|
|
|
|
|
2018-01-10 01:26:06 +08:00
|
|
|
std::unique_ptr<WritableMemoryBuffer>
|
|
|
|
WritableMemoryBuffer::getNewMemBuffer(size_t Size, const Twine &BufferName) {
|
|
|
|
auto SB = WritableMemoryBuffer::getNewUninitMemBuffer(Size, BufferName);
|
|
|
|
if (!SB)
|
|
|
|
return nullptr;
|
|
|
|
memset(SB->getBufferStart(), 0, Size);
|
|
|
|
return SB;
|
|
|
|
}
|
|
|
|
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
static bool shouldUseMmap(sys::fs::file_t FD,
|
2017-02-22 03:52:57 +08:00
|
|
|
size_t FileSize,
|
|
|
|
size_t MapSize,
|
|
|
|
off_t Offset,
|
|
|
|
bool RequiresNullTerminator,
|
|
|
|
int PageSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
bool IsVolatile) {
|
2017-02-22 03:52:57 +08:00
|
|
|
// 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.
|
2017-02-22 04:55:47 +08:00
|
|
|
if (IsVolatile)
|
2017-02-22 03:52:57 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-03-09 04:34:47 +08:00
|
|
|
static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
|
2018-03-09 04:57:37 +08:00
|
|
|
getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
|
2018-03-09 04:34:47 +08:00
|
|
|
uint64_t Offset) {
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForReadWrite(
|
|
|
|
Filename, sys::fs::CD_OpenExisting, sys::fs::OF_None);
|
|
|
|
if (!FDOrErr)
|
|
|
|
return errorToErrorCode(FDOrErr.takeError());
|
|
|
|
sys::fs::file_t FD = *FDOrErr;
|
2018-03-09 04:34:47 +08:00
|
|
|
|
|
|
|
// 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 mmap it, so error out.
|
|
|
|
sys::fs::file_type Type = Status.type();
|
|
|
|
if (Type != sys::fs::file_type::regular_file &&
|
|
|
|
Type != sys::fs::file_type::block_file)
|
|
|
|
return make_error_code(errc::invalid_argument);
|
|
|
|
|
|
|
|
FileSize = Status.getSize();
|
|
|
|
}
|
|
|
|
MapSize = FileSize;
|
|
|
|
}
|
|
|
|
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
std::error_code EC;
|
2018-03-09 04:34:47 +08:00
|
|
|
std::unique_ptr<WriteThroughMemoryBuffer> Result(
|
|
|
|
new (NamedBufferAlloc(Filename))
|
|
|
|
MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
|
|
|
|
Offset, EC));
|
|
|
|
if (EC)
|
|
|
|
return EC;
|
2020-02-10 23:06:45 +08:00
|
|
|
return std::move(Result);
|
2018-03-09 04:34:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
|
|
|
|
WriteThroughMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize) {
|
|
|
|
return getReadWriteFile(Filename, FileSize, FileSize, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Map a subrange of the specified file as a WritableMemoryBuffer.
|
|
|
|
ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
|
|
|
|
WriteThroughMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
|
|
|
|
uint64_t Offset) {
|
|
|
|
return getReadWriteFile(Filename, -1, MapSize, Offset);
|
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
template <typename MB>
|
|
|
|
static ErrorOr<std::unique_ptr<MB>>
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
|
2017-02-22 03:52:57 +08:00
|
|
|
uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
|
2017-02-22 04:55:47 +08:00
|
|
|
bool IsVolatile) {
|
2019-05-08 10:11:07 +08:00
|
|
|
static int PageSize = sys::Process::getPageSizeEstimate();
|
2017-02-22 03:52:57 +08:00
|
|
|
|
|
|
|
// 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,
|
2017-02-22 04:55:47 +08:00
|
|
|
PageSize, IsVolatile)) {
|
2017-02-22 03:52:57 +08:00
|
|
|
std::error_code EC;
|
2017-12-19 20:15:50 +08:00
|
|
|
std::unique_ptr<MB> Result(
|
|
|
|
new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile<MB>(
|
|
|
|
RequiresNullTerminator, FD, MapSize, Offset, EC));
|
2017-02-22 03:52:57 +08:00
|
|
|
if (!EC)
|
2020-02-10 23:06:45 +08:00
|
|
|
return std::move(Result);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
2017-12-19 20:15:50 +08:00
|
|
|
auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(MapSize, Filename);
|
2017-02-22 03:52:57 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-08-22 16:13:30 +08:00
|
|
|
// Read until EOF, zero-initialize the rest.
|
|
|
|
MutableArrayRef<char> ToRead = Buf->getBuffer();
|
|
|
|
while (!ToRead.empty()) {
|
|
|
|
Expected<size_t> ReadBytes =
|
|
|
|
sys::fs::readNativeFileSlice(FD, ToRead, Offset);
|
|
|
|
if (!ReadBytes)
|
|
|
|
return errorToErrorCode(ReadBytes.takeError());
|
|
|
|
if (*ReadBytes == 0) {
|
|
|
|
std::memset(ToRead.data(), 0, ToRead.size());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ToRead = ToRead.drop_front(*ReadBytes);
|
|
|
|
Offset += *ReadBytes;
|
|
|
|
}
|
2017-02-22 03:52:57 +08:00
|
|
|
|
2020-02-10 23:06:45 +08:00
|
|
|
return std::move(Buf);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>>
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
MemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
bool RequiresNullTerminator, bool IsVolatile) {
|
2017-12-19 20:15:50 +08:00
|
|
|
return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
|
2017-02-22 04:55:47 +08:00
|
|
|
RequiresNullTerminator, IsVolatile);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>>
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
MemoryBuffer::getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize,
|
2017-02-22 04:55:47 +08:00
|
|
|
int64_t Offset, bool IsVolatile) {
|
2017-02-22 03:52:57 +08:00
|
|
|
assert(MapSize != uint64_t(-1));
|
2017-12-19 20:15:50 +08:00
|
|
|
return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
|
|
|
|
IsVolatile);
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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();
|
|
|
|
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
return getMemoryBufferForStream(sys::fs::getStdinHandle(), "<stdin>");
|
2017-02-22 03:52:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>>
|
|
|
|
MemoryBuffer::getFileAsStream(const Twine &Filename) {
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
Expected<sys::fs::file_t> FDOrErr =
|
|
|
|
sys::fs::openNativeFileForRead(Filename, sys::fs::OF_None);
|
|
|
|
if (!FDOrErr)
|
|
|
|
return errorToErrorCode(FDOrErr.takeError());
|
|
|
|
sys::fs::file_t FD = *FDOrErr;
|
2017-02-22 03:52:57 +08:00
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =
|
|
|
|
getMemoryBufferForStream(FD, Filename);
|
[Support] Move llvm::MemoryBuffer to sys::fs::file_t
Summary:
On Windows, Posix integer file descriptors are a compatibility layer
over native file handles provided by the C runtime. There is a hard
limit on the maximum number of file descriptors that a process can open,
and the limit is 8192. LLD typically doesn't run into this limit because
it opens input files, maps them into memory, and then immediately closes
the file descriptor. This prevents it from running out of FDs.
For various reasons, I'd like to open handles to every input file and
keep them open during linking. That requires migrating MemoryBuffer over
to taking open native file handles instead of integer FDs.
Reviewers: aganea, Bigcheese
Reviewed By: aganea
Subscribers: smeenai, silvas, mehdi_amini, hiraditya, steven_wu, dexonsmith, dang, llvm-commits, zturner
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D63453
llvm-svn: 365588
2019-07-10 08:34:13 +08:00
|
|
|
sys::fs::closeFile(FD);
|
2017-02-22 03:52:57 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
MemoryBufferRef MemoryBuffer::getMemBufferRef() const {
|
|
|
|
StringRef Data = getBuffer();
|
|
|
|
StringRef Identifier = getBufferIdentifier();
|
|
|
|
return MemoryBufferRef(Data, Identifier);
|
|
|
|
}
|
Add missing vtable anchors
Summary: This patch adds anchor() for MemoryBuffer, raw_fd_ostream, RTDyldMemoryManager, SectionMemoryManager, etc.
Reviewers: jlebar, eli.friedman, dblaikie
Reviewed By: dblaikie
Subscribers: mehdi_amini, mgorny, dblaikie, weimingz, llvm-commits
Differential Revision: https://reviews.llvm.org/D45244
llvm-svn: 329861
2018-04-12 07:09:20 +08:00
|
|
|
|
2018-07-28 07:12:11 +08:00
|
|
|
SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() {}
|