LLVM  8.0.0svn
MemoryBuffer.cpp
Go to the documentation of this file.
1 //===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the MemoryBuffer interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/Config/config.h"
17 #include "llvm/Support/Errc.h"
18 #include "llvm/Support/Errno.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Support/Process.h"
23 #include "llvm/Support/Program.h"
25 #include <cassert>
26 #include <cerrno>
27 #include <cstring>
28 #include <new>
29 #include <sys/types.h>
30 #include <system_error>
31 #if !defined(_MSC_VER) && !defined(__MINGW32__)
32 #include <unistd.h>
33 #else
34 #include <io.h>
35 #endif
36 using namespace llvm;
37 
38 //===----------------------------------------------------------------------===//
39 // MemoryBuffer implementation itself.
40 //===----------------------------------------------------------------------===//
41 
43 
44 /// init - Initialize this MemoryBuffer as a reference to externally allocated
45 /// memory, memory that we know is already null terminated.
46 void MemoryBuffer::init(const char *BufStart, const char *BufEnd,
47  bool RequiresNullTerminator) {
48  assert((!RequiresNullTerminator || BufEnd[0] == 0) &&
49  "Buffer is not null terminated!");
50  BufferStart = BufStart;
51  BufferEnd = BufEnd;
52 }
53 
54 //===----------------------------------------------------------------------===//
55 // MemoryBufferMem implementation.
56 //===----------------------------------------------------------------------===//
57 
58 /// CopyStringRef - Copies contents of a StringRef into a block of memory and
59 /// null-terminates it.
60 static void CopyStringRef(char *Memory, StringRef Data) {
61  if (!Data.empty())
62  memcpy(Memory, Data.data(), Data.size());
63  Memory[Data.size()] = 0; // Null terminate string.
64 }
65 
66 namespace {
67 struct NamedBufferAlloc {
68  const Twine &Name;
69  NamedBufferAlloc(const Twine &Name) : Name(Name) {}
70 };
71 }
72 
73 void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
74  SmallString<256> NameBuf;
75  StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
76 
77  char *Mem = static_cast<char *>(operator new(N + NameRef.size() + 1));
78  CopyStringRef(Mem + N, NameRef);
79  return Mem;
80 }
81 
82 namespace {
83 /// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.
84 template<typename MB>
85 class MemoryBufferMem : public MB {
86 public:
87  MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {
88  MemoryBuffer::init(InputData.begin(), InputData.end(),
89  RequiresNullTerminator);
90  }
91 
92  /// Disable sized deallocation for MemoryBufferMem, because it has
93  /// tail-allocated data.
94  void operator delete(void *p) { ::operator delete(p); }
95 
96  StringRef getBufferIdentifier() const override {
97  // The name is stored after the class itself.
98  return StringRef(reinterpret_cast<const char *>(this + 1));
99  }
100 
101  MemoryBuffer::BufferKind getBufferKind() const override {
103  }
104 };
105 }
106 
107 template <typename MB>
109 getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
110  uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile);
111 
112 std::unique_ptr<MemoryBuffer>
114  bool RequiresNullTerminator) {
115  auto *Ret = new (NamedBufferAlloc(BufferName))
116  MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
117  return std::unique_ptr<MemoryBuffer>(Ret);
118 }
119 
120 std::unique_ptr<MemoryBuffer>
121 MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
122  return std::unique_ptr<MemoryBuffer>(getMemBuffer(
123  Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator));
124 }
125 
127 getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
128  auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
129  if (!Buf)
131  memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
132  return std::move(Buf);
133 }
134 
135 std::unique_ptr<MemoryBuffer>
136 MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
137  auto Buf = getMemBufferCopyImpl(InputData, BufferName);
138  if (Buf)
139  return std::move(*Buf);
140  return nullptr;
141 }
142 
144 MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize,
145  bool RequiresNullTerminator) {
146  SmallString<256> NameBuf;
147  StringRef NameRef = Filename.toStringRef(NameBuf);
148 
149  if (NameRef == "-")
150  return getSTDIN();
151  return getFile(Filename, FileSize, RequiresNullTerminator);
152 }
153 
155 MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
156  uint64_t Offset, bool IsVolatile) {
157  return getFileAux<MemoryBuffer>(FilePath, -1, MapSize, Offset, false,
158  IsVolatile);
159 }
160 
161 //===----------------------------------------------------------------------===//
162 // MemoryBuffer::getFile implementation.
163 //===----------------------------------------------------------------------===//
164 
165 namespace {
166 /// Memory maps a file descriptor using sys::fs::mapped_file_region.
167 ///
168 /// This handles converting the offset into a legal offset on the platform.
169 template<typename MB>
170 class MemoryBufferMMapFile : public MB {
172 
173  static uint64_t getLegalMapOffset(uint64_t Offset) {
174  return Offset & ~(sys::fs::mapped_file_region::alignment() - 1);
175  }
176 
177  static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) {
178  return Len + (Offset - getLegalMapOffset(Offset));
179  }
180 
181  const char *getStart(uint64_t Len, uint64_t Offset) {
182  return MFR.const_data() + (Offset - getLegalMapOffset(Offset));
183  }
184 
185 public:
186  MemoryBufferMMapFile(bool RequiresNullTerminator, int FD, uint64_t Len,
187  uint64_t Offset, std::error_code &EC)
188  : MFR(FD, MB::Mapmode, getLegalMapSize(Len, Offset),
189  getLegalMapOffset(Offset), EC) {
190  if (!EC) {
191  const char *Start = getStart(Len, Offset);
192  MemoryBuffer::init(Start, Start + Len, RequiresNullTerminator);
193  }
194  }
195 
196  /// Disable sized deallocation for MemoryBufferMMapFile, because it has
197  /// tail-allocated data.
198  void operator delete(void *p) { ::operator delete(p); }
199 
200  StringRef getBufferIdentifier() const override {
201  // The name is stored after the class itself.
202  return StringRef(reinterpret_cast<const char *>(this + 1));
203  }
204 
205  MemoryBuffer::BufferKind getBufferKind() const override {
207  }
208 };
209 }
210 
212 getMemoryBufferForStream(int FD, const Twine &BufferName) {
213  const ssize_t ChunkSize = 4096*4;
214  SmallString<ChunkSize> Buffer;
215  ssize_t ReadBytes;
216  // Read into Buffer until we hit EOF.
217  do {
218  Buffer.reserve(Buffer.size() + ChunkSize);
219  ReadBytes = sys::RetryAfterSignal(-1, ::read, FD, Buffer.end(), ChunkSize);
220  if (ReadBytes == -1)
221  return std::error_code(errno, std::generic_category());
222  Buffer.set_size(Buffer.size() + ReadBytes);
223  } while (ReadBytes != 0);
224 
225  return getMemBufferCopyImpl(Buffer, BufferName);
226 }
227 
228 
230 MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
231  bool RequiresNullTerminator, bool IsVolatile) {
232  return getFileAux<MemoryBuffer>(Filename, FileSize, FileSize, 0,
233  RequiresNullTerminator, IsVolatile);
234 }
235 
236 template <typename MB>
238 getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
239  uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
240  bool IsVolatile);
241 
242 template <typename MB>
244 getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
245  uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile) {
246  int FD;
247  std::error_code EC = sys::fs::openFileForRead(Filename, FD, sys::fs::OF_None);
248 
249  if (EC)
250  return EC;
251 
252  auto Ret = getOpenFileImpl<MB>(FD, Filename, FileSize, MapSize, Offset,
253  RequiresNullTerminator, IsVolatile);
254  close(FD);
255  return Ret;
256 }
257 
259 WritableMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
260  bool IsVolatile) {
261  return getFileAux<WritableMemoryBuffer>(Filename, FileSize, FileSize, 0,
262  /*RequiresNullTerminator*/ false,
263  IsVolatile);
264 }
265 
267 WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
268  uint64_t Offset, bool IsVolatile) {
269  return getFileAux<WritableMemoryBuffer>(Filename, -1, MapSize, Offset, false,
270  IsVolatile);
271 }
272 
273 std::unique_ptr<WritableMemoryBuffer>
275  using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
276  // Allocate space for the MemoryBuffer, the data and the name. It is important
277  // that MemoryBuffer and data are aligned so PointerIntPair works with them.
278  // TODO: Is 16-byte alignment enough? We copy small object files with large
279  // alignment expectations into this buffer.
280  SmallString<256> NameBuf;
281  StringRef NameRef = BufferName.toStringRef(NameBuf);
282  size_t AlignedStringLen = alignTo(sizeof(MemBuffer) + NameRef.size() + 1, 16);
283  size_t RealLen = AlignedStringLen + Size + 1;
284  char *Mem = static_cast<char*>(operator new(RealLen, std::nothrow));
285  if (!Mem)
286  return nullptr;
287 
288  // The name is stored after the class itself.
289  CopyStringRef(Mem + sizeof(MemBuffer), NameRef);
290 
291  // The buffer begins after the name and must be aligned.
292  char *Buf = Mem + AlignedStringLen;
293  Buf[Size] = 0; // Null terminate buffer.
294 
295  auto *Ret = new (Mem) MemBuffer(StringRef(Buf, Size), true);
296  return std::unique_ptr<WritableMemoryBuffer>(Ret);
297 }
298 
299 std::unique_ptr<WritableMemoryBuffer>
301  auto SB = WritableMemoryBuffer::getNewUninitMemBuffer(Size, BufferName);
302  if (!SB)
303  return nullptr;
304  memset(SB->getBufferStart(), 0, Size);
305  return SB;
306 }
307 
308 static bool shouldUseMmap(int FD,
309  size_t FileSize,
310  size_t MapSize,
311  off_t Offset,
312  bool RequiresNullTerminator,
313  int PageSize,
314  bool IsVolatile) {
315  // mmap may leave the buffer without null terminator if the file size changed
316  // by the time the last page is mapped in, so avoid it if the file size is
317  // likely to change.
318  if (IsVolatile)
319  return false;
320 
321  // We don't use mmap for small files because this can severely fragment our
322  // address space.
323  if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize)
324  return false;
325 
326  if (!RequiresNullTerminator)
327  return true;
328 
329  // If we don't know the file size, use fstat to find out. fstat on an open
330  // file descriptor is cheaper than stat on a random path.
331  // FIXME: this chunk of code is duplicated, but it avoids a fstat when
332  // RequiresNullTerminator = false and MapSize != -1.
333  if (FileSize == size_t(-1)) {
334  sys::fs::file_status Status;
335  if (sys::fs::status(FD, Status))
336  return false;
337  FileSize = Status.getSize();
338  }
339 
340  // If we need a null terminator and the end of the map is inside the file,
341  // we cannot use mmap.
342  size_t End = Offset + MapSize;
343  assert(End <= FileSize);
344  if (End != FileSize)
345  return false;
346 
347  // Don't try to map files that are exactly a multiple of the system page size
348  // if we need a null terminator.
349  if ((FileSize & (PageSize -1)) == 0)
350  return false;
351 
352 #if defined(__CYGWIN__)
353  // Don't try to map files that are exactly a multiple of the physical page size
354  // if we need a null terminator.
355  // FIXME: We should reorganize again getPageSize() on Win32.
356  if ((FileSize & (4096 - 1)) == 0)
357  return false;
358 #endif
359 
360  return true;
361 }
362 
364 getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
365  uint64_t Offset) {
366  int FD;
367  std::error_code EC = sys::fs::openFileForReadWrite(
369 
370  if (EC)
371  return EC;
372 
373  // Default is to map the full file.
374  if (MapSize == uint64_t(-1)) {
375  // If we don't know the file size, use fstat to find out. fstat on an open
376  // file descriptor is cheaper than stat on a random path.
377  if (FileSize == uint64_t(-1)) {
378  sys::fs::file_status Status;
379  std::error_code EC = sys::fs::status(FD, Status);
380  if (EC)
381  return EC;
382 
383  // If this not a file or a block device (e.g. it's a named pipe
384  // or character device), we can't mmap it, so error out.
385  sys::fs::file_type Type = Status.type();
386  if (Type != sys::fs::file_type::regular_file &&
389 
390  FileSize = Status.getSize();
391  }
392  MapSize = FileSize;
393  }
394 
395  std::unique_ptr<WriteThroughMemoryBuffer> Result(
396  new (NamedBufferAlloc(Filename))
397  MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
398  Offset, EC));
399  if (EC)
400  return EC;
401  return std::move(Result);
402 }
403 
405 WriteThroughMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize) {
406  return getReadWriteFile(Filename, FileSize, FileSize, 0);
407 }
408 
409 /// Map a subrange of the specified file as a WritableMemoryBuffer.
411 WriteThroughMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
412  uint64_t Offset) {
413  return getReadWriteFile(Filename, -1, MapSize, Offset);
414 }
415 
416 template <typename MB>
418 getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
419  uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
420  bool IsVolatile) {
421  static int PageSize = sys::Process::getPageSize();
422 
423  // Default is to map the full file.
424  if (MapSize == uint64_t(-1)) {
425  // If we don't know the file size, use fstat to find out. fstat on an open
426  // file descriptor is cheaper than stat on a random path.
427  if (FileSize == uint64_t(-1)) {
428  sys::fs::file_status Status;
429  std::error_code EC = sys::fs::status(FD, Status);
430  if (EC)
431  return EC;
432 
433  // If this not a file or a block device (e.g. it's a named pipe
434  // or character device), we can't trust the size. Create the memory
435  // buffer by copying off the stream.
436  sys::fs::file_type Type = Status.type();
437  if (Type != sys::fs::file_type::regular_file &&
439  return getMemoryBufferForStream(FD, Filename);
440 
441  FileSize = Status.getSize();
442  }
443  MapSize = FileSize;
444  }
445 
446  if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
447  PageSize, IsVolatile)) {
448  std::error_code EC;
449  std::unique_ptr<MB> Result(
450  new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile<MB>(
451  RequiresNullTerminator, FD, MapSize, Offset, EC));
452  if (!EC)
453  return std::move(Result);
454  }
455 
456  auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(MapSize, Filename);
457  if (!Buf) {
458  // Failed to create a buffer. The only way it can fail is if
459  // new(std::nothrow) returns 0.
461  }
462 
463  char *BufPtr = Buf.get()->getBufferStart();
464 
465  size_t BytesLeft = MapSize;
466 #ifndef HAVE_PREAD
467  if (lseek(FD, Offset, SEEK_SET) == -1)
468  return std::error_code(errno, std::generic_category());
469 #endif
470 
471  while (BytesLeft) {
472 #ifdef HAVE_PREAD
473  ssize_t NumRead = sys::RetryAfterSignal(-1, ::pread, FD, BufPtr, BytesLeft,
474  MapSize - BytesLeft + Offset);
475 #else
476  ssize_t NumRead = sys::RetryAfterSignal(-1, ::read, FD, BufPtr, BytesLeft);
477 #endif
478  if (NumRead == -1) {
479  // Error while reading.
480  return std::error_code(errno, std::generic_category());
481  }
482  if (NumRead == 0) {
483  memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer.
484  break;
485  }
486  BytesLeft -= NumRead;
487  BufPtr += NumRead;
488  }
489 
490  return std::move(Buf);
491 }
492 
494 MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,
495  bool RequiresNullTerminator, bool IsVolatile) {
496  return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
497  RequiresNullTerminator, IsVolatile);
498 }
499 
501 MemoryBuffer::getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize,
502  int64_t Offset, bool IsVolatile) {
503  assert(MapSize != uint64_t(-1));
504  return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
505  IsVolatile);
506 }
507 
509  // Read in all of the data from stdin, we cannot mmap stdin.
510  //
511  // FIXME: That isn't necessarily true, we should try to mmap stdin and
512  // fallback if it fails.
514 
515  return getMemoryBufferForStream(0, "<stdin>");
516 }
517 
520  int FD;
521  std::error_code EC = sys::fs::openFileForRead(Filename, FD, sys::fs::OF_None);
522  if (EC)
523  return EC;
525  getMemoryBufferForStream(FD, Filename);
526  close(FD);
527  return Ret;
528 }
529 
533  return MemoryBufferRef(Data, Identifier);
534 }
535 
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition: MemoryBuffer.h:70
void init(const char *BufStart, const char *BufEnd, bool RequiresNullTerminator)
init - Initialize this MemoryBuffer as a reference to externally allocated memory, memory that we know is already null terminated.
std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD, CreationDisposition Disp, OpenFlags Flags, unsigned Mode=0666)
Opens the file with the given name in a write-only or read-write mode, returning its open file descri...
Definition: FileSystem.h:968
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize, int64_t Offset, bool IsVolatile=false)
Given an already-open file descriptor, map some slice of it into a MemoryBuffer.
Represents either an error or a value T.
Definition: ErrorOr.h:57
StringRef getBuffer() const
Definition: MemoryBuffer.h:64
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
std::error_code openFileForRead(const Twine &Name, int &ResultFD, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
constexpr char IsVolatile[]
Key for Kernel::Arg::Metadata::mIsVolatile.
static ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile=false)
Map a subrange of the specified file as a WritableMemoryBuffer.
This class provides various memory handling functions that manipulate MemoryBlock instances...
Definition: Memory.h:46
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:453
This class represents a memory mapped file.
Definition: FileSystem.h:1051
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:685
void reserve(size_type N)
Definition: SmallVector.h:376
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:229
CD_OpenAlways - When opening a file:
Definition: FileSystem.h:707
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
const char * const_data() const
Get a const view of the data.
virtual BufferKind getBufferKind() const =0
Return information on the memory mechanism used to support the MemoryBuffer.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
StringRef getBuffer() const
Definition: MemoryBuffer.h:273
static ErrorOr< std::unique_ptr< MB > > getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize, uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, bool IsVolatile)
The access may reference the value stored in memory.
std::error_code make_error_code(BitcodeError E)
static ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool IsVolatile=false)
static ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getMemoryBufferForStream(int FD, const Twine &BufferName)
static std::unique_ptr< WritableMemoryBuffer > getNewMemBuffer(size_t Size, const Twine &BufferName="")
Allocate a new zero-initialized MemoryBuffer of the specified size.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
static ErrorOr< std::unique_ptr< MB > > getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize, uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile)
static void CopyStringRef(char *Memory, StringRef Data)
CopyStringRef - Copies contents of a StringRef into a block of memory and null-terminates it...
static ErrorOr< std::unique_ptr< MemoryBuffer > > getSTDIN()
Read all of stdin into a file buffer, and return it.
static ErrorOr< std::unique_ptr< WriteThroughMemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
static std::unique_ptr< WritableMemoryBuffer > getNewUninitMemBuffer(size_t Size, const Twine &BufferName="")
Allocate a new MemoryBuffer of the specified size that is not initialized.
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
auto RetryAfterSignal(const FailT &Fail, const Fun &F, const Args &... As) -> decltype(F(As...))
Definition: Errno.h:34
size_t size() const
Definition: SmallVector.h:53
static unsigned getPageSize()
MemoryBufferRef getMemBufferRef() const
static std::unique_ptr< MemoryBuffer > getMemBufferCopy(StringRef InputData, const Twine &BufferName="")
Open the specified memory range as a MemoryBuffer, copying the contents and taking ownership of it...
static bool shouldUseMmap(int FD, size_t FileSize, size_t MapSize, off_t Offset, bool RequiresNullTerminator, int PageSize, bool IsVolatile)
StringRef getBufferIdentifier() const
Definition: MemoryBuffer.h:275
iterator begin() const
Definition: StringRef.h:106
std::error_code ChangeStdinToBinary()
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile=false)
Map a subrange of the specified file as a MemoryBuffer.
static ErrorOr< std::unique_ptr< WriteThroughMemoryBuffer > > getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize, uint64_t Offset)
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
static ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName)
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:133
Provides a library for accessing information about this process and other processes on the operating ...
file_type
An enumeration for the file system&#39;s view of the type.
Definition: FileSystem.h:67
virtual ~MemoryBuffer()
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:66
#define N
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileAsStream(const Twine &Filename)
Read all of the specified file into a MemoryBuffer as a stream (i.e.
BufferKind
The kind of memory backing used to support the MemoryBuffer.
Definition: MemoryBuffer.h:140
static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void set_size(size_t Size)
Set the array size to N, which the current array must have enough capacity for.
Definition: SmallVector.h:67
static ErrorOr< std::unique_ptr< WriteThroughMemoryBuffer > > getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset)
Map a subrange of the specified file as a ReadWriteMemoryBuffer.
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(int FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator=true, bool IsVolatile=false)
Given an already-open file descriptor, read the file and return a MemoryBuffer.
iterator end() const
Definition: StringRef.h:108