LLVM: lib/Support/MemoryBuffer.cpp Source File

LLVM 22.0.0git
MemoryBuffer.cpp
Go to the documentation of this file.
1//===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the MemoryBuffer interface.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Support/MemoryBuffer.h"
14#include "llvm/ADT/STLExtras.h"
15#include "llvm/ADT/SmallString.h"
16#include "llvm/Config/config.h"
17#include "llvm/Support/Alignment.h"
18#include "llvm/Support/AutoConvert.h"
19#include "llvm/Support/Errc.h"
20#include "llvm/Support/Error.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/FileSystem.h"
23#include "llvm/Support/Process.h"
24#include "llvm/Support/Program.h"
25#include "llvm/Support/SmallVectorMemoryBuffer.h"
26#include <algorithm>
27#include <cassert>
28#include <cstring>
29#include <new>
30#include <sys/types.h>
31#include <system_error>
32#if !defined(_MSC_VER) && !defined(__MINGW32__)
33#include <unistd.h>
34#else
35#include <io.h>
36#endif
37
38using namespace llvm;
39
40//===----------------------------------------------------------------------===//
41// MemoryBuffer implementation itself.
42//===----------------------------------------------------------------------===//
43
44MemoryBuffer::~MemoryBuffer() = default;
45
46/// init - Initialize this MemoryBuffer as a reference to externally allocated
47/// memory, memory that we know is already null terminated.
48 void MemoryBuffer::init(const char *BufStart, const char *BufEnd,
49 bool RequiresNullTerminator) {
50 assert((!RequiresNullTerminator || BufEnd[0] == 0) &&
51 "Buffer is not null terminated!");
52 BufferStart = BufStart;
53 BufferEnd = BufEnd;
54}
55
56//===----------------------------------------------------------------------===//
57// MemoryBufferMem implementation.
58//===----------------------------------------------------------------------===//
59
60/// CopyStringRef - Copies contents of a StringRef into a block of memory and
61/// null-terminates it.
62 static void CopyStringRef(char *Memory, StringRef Data) {
63 if (!Data.empty())
64 memcpy(Memory, Data.data(), Data.size());
65 Memory[Data.size()] = 0; // Null terminate string.
66}
67
68namespace {
69struct NamedBufferAlloc {
70 const Twine &Name;
71 NamedBufferAlloc(const Twine &Name) : Name(Name) {}
72};
73} // namespace
74
75 void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
76 SmallString<256> NameBuf;
77 StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
78
79 // We use malloc() and manually handle it returning null instead of calling
80 // operator new because we need all uses of NamedBufferAlloc to be
81 // deallocated with a call to free() due to needing to use malloc() in
82 // WritableMemoryBuffer::getNewUninitMemBuffer() to work around the out-of-
83 // memory handler installed by default in LLVM. See operator delete() member
84 // functions within this file for the paired call to free().
85 char *Mem =
86 static_cast<char *>(std::malloc(N + sizeof(size_t) + NameRef.size() + 1));
87 if (!Mem)
88 llvm::report_bad_alloc_error("Allocation failed");
89 *reinterpret_cast<size_t *>(Mem + N) = NameRef.size();
90 CopyStringRef(Mem + N + sizeof(size_t), NameRef);
91 return Mem;
92}
93
94namespace {
95/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.
96template<typename MB>
97class MemoryBufferMem : public MB {
98public:
99 MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {
100 MemoryBuffer::init(InputData.begin(), InputData.end(),
101 RequiresNullTerminator);
102 }
103
104 /// Disable sized deallocation for MemoryBufferMem, because it has
105 /// tail-allocated data.
106 void operator delete(void *p) { std::free(p); }
107
108 StringRef getBufferIdentifier() const override {
109 // The name is stored after the class itself.
110 return StringRef(reinterpret_cast<const char *>(this + 1) + sizeof(size_t),
111 *reinterpret_cast<const size_t *>(this + 1));
112 }
113
114 MemoryBuffer::BufferKind getBufferKind() const override {
115 return MemoryBuffer::MemoryBuffer_Malloc;
116 }
117};
118} // namespace
119
120template <typename MB>
121static ErrorOr<std::unique_ptr<MB>>
122getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
123 bool IsText, bool RequiresNullTerminator, bool IsVolatile,
124 std::optional<Align> Alignment);
125
126std::unique_ptr<MemoryBuffer>
128 bool RequiresNullTerminator) {
129 auto *Ret = new (NamedBufferAlloc(BufferName))
130 MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
131 return std::unique_ptr<MemoryBuffer>(Ret);
132}
133
134std::unique_ptr<MemoryBuffer>
135 MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
136 return std::unique_ptr<MemoryBuffer>(getMemBuffer(
137 Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator));
138}
139
140static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
141 getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
142 auto Buf =
143 WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
144 if (!Buf)
146 // Calling memcpy with null src/dst is UB, and an empty StringRef is
147 // represented with {nullptr, 0}.
148 llvm::copy(InputData, Buf->getBufferStart());
149 return std::move(Buf);
150}
151
152std::unique_ptr<MemoryBuffer>
153 MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
154 auto Buf = getMemBufferCopyImpl(InputData, BufferName);
155 if (Buf)
156 return std::move(*Buf);
157 return nullptr;
158}
159
160ErrorOr<std::unique_ptr<MemoryBuffer>>
161 MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText,
162 bool RequiresNullTerminator,
163 std::optional<Align> Alignment) {
164 SmallString<256> NameBuf;
165 StringRef NameRef = Filename.toStringRef(NameBuf);
166
167 if (NameRef == "-")
168 return getSTDIN();
169 return getFile(Filename, IsText, RequiresNullTerminator,
170 /*IsVolatile=*/false, Alignment);
171}
172
173ErrorOr<std::unique_ptr<MemoryBuffer>>
174 MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
175 uint64_t Offset, bool IsVolatile,
176 std::optional<Align> Alignment) {
177 return getFileAux<MemoryBuffer>(FilePath, MapSize, Offset, /*IsText=*/false,
178 /*RequiresNullTerminator=*/false, IsVolatile,
179 Alignment);
180}
181
182//===----------------------------------------------------------------------===//
183// MemoryBuffer::getFile implementation.
184//===----------------------------------------------------------------------===//
185
186namespace {
187
188template <typename MB>
189constexpr sys::fs::mapped_file_region::mapmode Mapmode =
190 sys::fs::mapped_file_region::readonly;
191template <>
192constexpr sys::fs::mapped_file_region::mapmode Mapmode<MemoryBuffer> =
193 sys::fs::mapped_file_region::readonly;
194template <>
195constexpr sys::fs::mapped_file_region::mapmode Mapmode<WritableMemoryBuffer> =
196 sys::fs::mapped_file_region::priv;
197template <>
198constexpr sys::fs::mapped_file_region::mapmode
199 Mapmode<WriteThroughMemoryBuffer> = sys::fs::mapped_file_region::readwrite;
200
201/// Memory maps a file descriptor using sys::fs::mapped_file_region.
202///
203/// This handles converting the offset into a legal offset on the platform.
204template<typename MB>
205class MemoryBufferMMapFile : public MB {
206 sys::fs::mapped_file_region MFR;
207
208 static uint64_t getLegalMapOffset(uint64_t Offset) {
209 return Offset & ~(sys::fs::mapped_file_region::alignment() - 1);
210 }
211
212 static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) {
213 return Len + (Offset - getLegalMapOffset(Offset));
214 }
215
216 const char *getStart(uint64_t Len, uint64_t Offset) {
217 return MFR.const_data() + (Offset - getLegalMapOffset(Offset));
218 }
219
220public:
221 MemoryBufferMMapFile(bool RequiresNullTerminator, sys::fs::file_t FD, uint64_t Len,
222 uint64_t Offset, std::error_code &EC)
223 : MFR(FD, Mapmode<MB>, getLegalMapSize(Len, Offset),
224 getLegalMapOffset(Offset), EC) {
225 if (!EC) {
226 const char *Start = getStart(Len, Offset);
227 MemoryBuffer::init(Start, Start + Len, RequiresNullTerminator);
228 }
229 }
230
231 /// Disable sized deallocation for MemoryBufferMMapFile, because it has
232 /// tail-allocated data.
233 void operator delete(void *p) { std::free(p); }
234
235 StringRef getBufferIdentifier() const override {
236 // The name is stored after the class itself.
237 return StringRef(reinterpret_cast<const char *>(this + 1) + sizeof(size_t),
238 *reinterpret_cast<const size_t *>(this + 1));
239 }
240
241 MemoryBuffer::BufferKind getBufferKind() const override {
242 return MemoryBuffer::MemoryBuffer_MMap;
243 }
244
245 void dontNeedIfMmap() override { MFR.dontNeed(); }
246};
247} // namespace
248
249static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
252 if (Error E = sys::fs::readNativeFileToEOF(FD, Buffer))
253 return errorToErrorCode(std::move(E));
254 return getMemBufferCopyImpl(Buffer, BufferName);
255}
256
257ErrorOr<std::unique_ptr<MemoryBuffer>>
258 MemoryBuffer::getFile(const Twine &Filename, bool IsText,
259 bool RequiresNullTerminator, bool IsVolatile,
260 std::optional<Align> Alignment) {
261 return getFileAux<MemoryBuffer>(Filename, /*MapSize=*/-1, /*Offset=*/0,
262 IsText, RequiresNullTerminator, IsVolatile,
263 Alignment);
264}
265
266template <typename MB>
267static ErrorOr<std::unique_ptr<MB>>
268getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
269 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
270 bool IsVolatile, std::optional<Align> Alignment);
271
272template <typename MB>
273static ErrorOr<std::unique_ptr<MB>>
274 getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
275 bool IsText, bool RequiresNullTerminator, bool IsVolatile,
276 std::optional<Align> Alignment) {
278 Filename, IsText ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None);
279 if (!FDOrErr)
280 return errorToErrorCode(FDOrErr.takeError());
281 sys::fs::file_t FD = *FDOrErr;
282 auto Ret = getOpenFileImpl<MB>(FD, Filename, /*FileSize=*/-1, MapSize, Offset,
283 RequiresNullTerminator, IsVolatile, Alignment);
285 return Ret;
286}
287
288ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
289 WritableMemoryBuffer::getFile(const Twine &Filename, bool IsVolatile,
290 std::optional<Align> Alignment) {
292 Filename, /*MapSize=*/-1, /*Offset=*/0, /*IsText=*/false,
293 /*RequiresNullTerminator=*/false, IsVolatile, Alignment);
294}
295
296ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
298 uint64_t Offset, bool IsVolatile,
299 std::optional<Align> Alignment) {
301 Filename, MapSize, Offset, /*IsText=*/false,
302 /*RequiresNullTerminator=*/false, IsVolatile, Alignment);
303}
304
305std::unique_ptr<WritableMemoryBuffer>
307 const Twine &BufferName,
308 std::optional<Align> Alignment) {
309 using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
310
311 // Use 16-byte alignment if no alignment is specified.
312 Align BufAlign = Alignment.value_or(Align(16));
313
314 // Allocate space for the MemoryBuffer, the data and the name. It is important
315 // that MemoryBuffer and data are aligned so PointerIntPair works with them.
316 SmallString<256> NameBuf;
317 StringRef NameRef = BufferName.toStringRef(NameBuf);
318
319 size_t StringLen = sizeof(MemBuffer) + sizeof(size_t) + NameRef.size() + 1;
320 size_t RealLen = StringLen + Size + 1 + BufAlign.value();
321 if (RealLen <= Size) // Check for rollover.
322 return nullptr;
323 // We use a call to malloc() rather than a call to a non-throwing operator
324 // new() because LLVM unconditionally installs an out of memory new handler
325 // when exceptions are disabled. This new handler intentionally crashes to
326 // aid with debugging, but that makes non-throwing new calls unhelpful.
327 // See MemoryBufferMem::operator delete() for the paired call to free(), and
328 // llvm::install_out_of_memory_new_handler() for the installation of the
329 // custom new handler.
330 char *Mem = static_cast<char *>(std::malloc(RealLen));
331 if (!Mem)
332 return nullptr;
333
334 // The name is stored after the class itself.
335 *reinterpret_cast<size_t *>(Mem + sizeof(MemBuffer)) = NameRef.size();
336 CopyStringRef(Mem + sizeof(MemBuffer) + sizeof(size_t), NameRef);
337
338 // The buffer begins after the name and must be aligned.
339 char *Buf = (char *)alignAddr(Mem + StringLen, BufAlign);
340 Buf[Size] = 0; // Null terminate buffer.
341
342 auto *Ret = new (Mem) MemBuffer(StringRef(Buf, Size), true);
343 return std::unique_ptr<WritableMemoryBuffer>(Ret);
344}
345
346std::unique_ptr<WritableMemoryBuffer>
349 if (!SB)
350 return nullptr;
351 memset(SB->getBufferStart(), 0, Size);
352 return SB;
353}
354
356 size_t FileSize,
357 size_t MapSize,
358 off_t Offset,
359 bool RequiresNullTerminator,
360 int PageSize,
361 bool IsVolatile) {
362#if defined(__MVS__)
363 // zOS Enhanced ASCII auto convert does not support mmap.
364 return false;
365#endif
366
367 // mmap may leave the buffer without null terminator if the file size changed
368 // by the time the last page is mapped in, so avoid it if the file size is
369 // likely to change.
370 if (IsVolatile && RequiresNullTerminator)
371 return false;
372
373 // We don't use mmap for small files because this can severely fragment our
374 // address space.
375 if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize)
376 return false;
377
378 if (!RequiresNullTerminator)
379 return true;
380
381 // If we don't know the file size, use fstat to find out. fstat on an open
382 // file descriptor is cheaper than stat on a random path.
383 // FIXME: this chunk of code is duplicated, but it avoids a fstat when
384 // RequiresNullTerminator = false and MapSize != -1.
385 if (FileSize == size_t(-1)) {
387 if (sys::fs::status(FD, Status))
388 return false;
389 FileSize = Status.getSize();
390 }
391
392 // If we need a null terminator and the end of the map is inside the file,
393 // we cannot use mmap.
394 size_t End = Offset + MapSize;
395 assert(End <= FileSize);
396 if (End != FileSize)
397 return false;
398
399 // Don't try to map files that are exactly a multiple of the system page size
400 // if we need a null terminator.
401 if ((FileSize & (PageSize -1)) == 0)
402 return false;
403
404#if defined(__CYGWIN__)
405 // Don't try to map files that are exactly a multiple of the physical page size
406 // if we need a null terminator.
407 // FIXME: We should reorganize again getPageSize() on Win32.
408 if ((FileSize & (4096 - 1)) == 0)
409 return false;
410#endif
411
412 return true;
413}
414
415static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
416 getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
420 if (!FDOrErr)
421 return errorToErrorCode(FDOrErr.takeError());
422 sys::fs::file_t FD = *FDOrErr;
423
424 // Default is to map the full file.
425 if (MapSize == uint64_t(-1)) {
426 // If we don't know the file size, use fstat to find out. fstat on an open
427 // file descriptor is cheaper than stat on a random path.
428 if (FileSize == uint64_t(-1)) {
430 std::error_code EC = sys::fs::status(FD, Status);
431 if (EC)
432 return EC;
433
434 // If this not a file or a block device (e.g. it's a named pipe
435 // or character device), we can't mmap it, so error out.
440
441 FileSize = Status.getSize();
442 }
443 MapSize = FileSize;
444 }
445
446 std::error_code EC;
447 std::unique_ptr<WriteThroughMemoryBuffer> Result(
448 new (NamedBufferAlloc(Filename))
449 MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
450 Offset, EC));
451 if (EC)
452 return EC;
453 return std::move(Result);
454}
455
456ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
457 WriteThroughMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize) {
458 return getReadWriteFile(Filename, FileSize, FileSize, 0);
459}
460
461/// Map a subrange of the specified file as a WritableMemoryBuffer.
462ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
465 return getReadWriteFile(Filename, -1, MapSize, Offset);
466}
467
468template <typename MB>
469static ErrorOr<std::unique_ptr<MB>>
470 getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
471 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
472 bool IsVolatile, std::optional<Align> Alignment) {
474
475 // Default is to map the full file.
476 if (MapSize == uint64_t(-1)) {
477 // If we don't know the file size, use fstat to find out. fstat on an open
478 // file descriptor is cheaper than stat on a random path.
479 if (FileSize == uint64_t(-1)) {
481 std::error_code EC = sys::fs::status(FD, Status);
482 if (EC)
483 return EC;
484
485 // If this not a file or a block device (e.g. it's a named pipe
486 // or character device), we can't trust the size. Create the memory
487 // buffer by copying off the stream.
491 return getMemoryBufferForStream(FD, Filename);
492
493 FileSize = Status.getSize();
494 }
495 MapSize = FileSize;
496 }
497
498 if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
499 PageSize, IsVolatile)) {
500 std::error_code EC;
501 std::unique_ptr<MB> Result(
502 new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile<MB>(
503 RequiresNullTerminator, FD, MapSize, Offset, EC));
504 if (!EC) {
505 // On at least Linux, and possibly on other systems, mmap may return pages
506 // from the page cache that are not properly filled with trailing zeroes,
507 // if some prior user of the page wrote non-zero bytes. Detect this and
508 // don't use mmap in that case.
509 if (!RequiresNullTerminator || *Result->getBufferEnd() == '0円')
510 return std::move(Result);
511 }
512 }
513
514#ifdef __MVS__
515 ErrorOr<bool> NeedsConversion = needConversion(Filename, FD);
516 if (std::error_code EC = NeedsConversion.getError())
517 return EC;
518 // File size may increase due to EBCDIC -> UTF-8 conversion, therefore we
519 // cannot trust the file size and we create the memory buffer by copying
520 // off the stream.
521 // Note: This only works with the assumption of reading a full file (i.e,
522 // Offset == 0 and MapSize == FileSize). Reading a file slice does not work.
523 if (*NeedsConversion && Offset == 0 && MapSize == FileSize)
524 return getMemoryBufferForStream(FD, Filename);
525#endif
526
527 auto Buf =
528 WritableMemoryBuffer::getNewUninitMemBuffer(MapSize, Filename, Alignment);
529 if (!Buf) {
530 // Failed to create a buffer. The only way it can fail is if
531 // new(std::nothrow) returns 0.
533 }
534
535 // Read until EOF, zero-initialize the rest.
536 MutableArrayRef<char> ToRead = Buf->getBuffer();
537 while (!ToRead.empty()) {
538 Expected<size_t> ReadBytes =
540 if (!ReadBytes)
541 return errorToErrorCode(ReadBytes.takeError());
542 if (*ReadBytes == 0) {
543 std::memset(ToRead.data(), 0, ToRead.size());
544 break;
545 }
546 ToRead = ToRead.drop_front(*ReadBytes);
547 Offset += *ReadBytes;
548 }
549
550 return std::move(Buf);
551}
552
553ErrorOr<std::unique_ptr<MemoryBuffer>>
555 uint64_t FileSize, bool RequiresNullTerminator,
556 bool IsVolatile, std::optional<Align> Alignment) {
557 return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
558 RequiresNullTerminator, IsVolatile,
559 Alignment);
560}
561
563 sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize, int64_t Offset,
564 bool IsVolatile, std::optional<Align> Alignment) {
565 assert(MapSize != uint64_t(-1));
566 return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
567 IsVolatile, Alignment);
568}
569
571 // Read in all of the data from stdin, we cannot mmap stdin.
572 //
573 // FIXME: That isn't necessarily true, we should try to mmap stdin and
574 // fallback if it fails.
576
578}
579
580ErrorOr<std::unique_ptr<MemoryBuffer>>
584 if (!FDOrErr)
585 return errorToErrorCode(FDOrErr.takeError());
586 sys::fs::file_t FD = *FDOrErr;
588 getMemoryBufferForStream(FD, Filename);
590 return Ret;
591}
592
595 StringRef Identifier = getBufferIdentifier();
596 return MemoryBufferRef(Data, Identifier);
597}
598
599SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() = default;
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU Prepare AGPR Alloc
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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 bool shouldUseMmap(sys::fs::file_t FD, size_t FileSize, size_t MapSize, off_t Offset, bool RequiresNullTerminator, int PageSize, bool IsVolatile)
static ErrorOr< std::unique_ptr< MB > > getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsText, bool RequiresNullTerminator, bool IsVolatile, std::optional< Align > Alignment)
static ErrorOr< std::unique_ptr< WriteThroughMemoryBuffer > > getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize, uint64_t Offset)
static ErrorOr< std::unique_ptr< MB > > getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, bool IsVolatile, std::optional< Align > Alignment)
static ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName)
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< WritableMemoryBuffer > > getMemoryBufferForStream(sys::fs::file_t FD, const Twine &BufferName)
Provides a library for accessing information about this process and other processes on the operating ...
This file contains some templates that are useful if you are working with the STL at all.
This file defines the SmallString class.
size_t size() const
size - Get the array size.
Definition ArrayRef.h:143
bool empty() const
empty - Check if the array is empty.
Definition ArrayRef.h:138
Represents either an error or a value T.
Definition ErrorOr.h:56
std::error_code getError() const
Definition ErrorOr.h:152
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
Tagged union holding either a T or a Error.
Definition Error.h:485
Error takeError()
Take ownership of the stored error.
Definition Error.h:612
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Given an already-open file descriptor, read the file and return a MemoryBuffer.
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
BufferKind
The kind of memory backing used to support the MemoryBuffer.
Definition MemoryBuffer.h:166
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition MemoryBuffer.h:77
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 ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize, int64_t Offset, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Given an already-open file descriptor, map some slice of it into a MemoryBuffer.
void init(const char *BufStart, const char *BufEnd, bool RequiresNullTerminator)
init - Initialize this MemoryBuffer as a reference to externally allocated memory,...
StringRef getBuffer() const
Definition MemoryBuffer.h:71
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileAsStream(const Twine &Filename)
Read all of the specified file into a MemoryBuffer as a stream (i.e.
MemoryBufferRef getMemBufferRef() const
virtual ~MemoryBuffer()
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Map a subrange of the specified file as a MemoryBuffer.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
static ErrorOr< std::unique_ptr< MemoryBuffer > > getSTDIN()
Read all of stdin into a file buffer, and return it.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition ArrayRef.h:299
T * data() const
Definition ArrayRef.h:341
MutableArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition ArrayRef.h:388
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:26
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
iterator begin() const
Definition StringRef.h:112
constexpr size_t size() const
size - Get the string size.
Definition StringRef.h:146
iterator end() const
Definition StringRef.h:114
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition Twine.h:461
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
static LLVM_ABI std::unique_ptr< WritableMemoryBuffer > getNewMemBuffer(size_t Size, const Twine &BufferName="")
Allocate a new zero-initialized MemoryBuffer of the specified size.
static LLVM_ABI ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getFile(const Twine &Filename, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
static LLVM_ABI std::unique_ptr< WritableMemoryBuffer > getNewUninitMemBuffer(size_t Size, const Twine &BufferName="", std::optional< Align > Alignment=std::nullopt)
Allocate a new MemoryBuffer of the specified size that is not initialized.
static LLVM_ABI ErrorOr< std::unique_ptr< WritableMemoryBuffer > > getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Map a subrange of the specified file as a WritableMemoryBuffer.
static LLVM_ABI ErrorOr< std::unique_ptr< WriteThroughMemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1)
static LLVM_ABI 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.
This class provides various memory handling functions that manipulate MemoryBlock instances.
Definition Memory.h:54
static unsigned getPageSizeEstimate()
Get the process's estimated page size.
Definition Process.h:62
Represents the result of a call to sys::fs::status().
Definition FileSystem.h:222
This class represents a memory mapped file.
Definition FileSystem.h:1280
static LLVM_ABI int alignment()
mapmode
Definition FileSystem.h:1282
@ priv
May modify via data, but changes are lost on destruction.
Definition FileSystem.h:1285
@ readonly
May only access map via const_data as read only.
Definition FileSystem.h:1283
@ readwrite
May access map via data and modify it. Written to path.
Definition FileSystem.h:1284
LLVM_ABI const char * const_data() const
Get a const view of the data.
Definition Path.cpp:1169
void dontNeed()
Definition FileSystem.h:1343
LLVM_ABI std::error_code closeFile(file_t &F)
Close the file object.
LLVM_ABI Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl< char > &Buffer, ssize_t ChunkSize=DefaultReadChunkSize)
Reads from FileHandle until EOF, appending to Buffer in chunks of size ChunkSize.
Definition Path.cpp:1174
@ OF_Text
The file should be opened in text mode on platforms like z/OS that make this distinction.
Definition FileSystem.h:755
@ OF_TextWithCRLF
The file should be opened in text mode and use a carriage linefeed '\r '.
Definition FileSystem.h:764
file_type
An enumeration for the file system's view of the type.
Definition FileSystem.h:62
@ CD_OpenExisting
CD_OpenExisting - When opening a file:
Definition FileSystem.h:737
LLVM_ABI Expected< size_t > readNativeFileSlice(file_t FileHandle, MutableArrayRef< char > Buf, uint64_t Offset)
Reads Buf.size() bytes from FileHandle at offset Offset into Buf.
Expected< file_t > openNativeFileForReadWrite(const Twine &Name, 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:1126
LLVM_ABI Expected< file_t > openNativeFileForRead(const Twine &Name, 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.
LLVM_ABI std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
LLVM_ABI file_t getStdinHandle()
Return an open handle to standard in.
LLVM_ABI std::error_code ChangeStdinMode(fs::OpenFlags Flags)
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
@ Offset
Definition DWP.cpp:477
std::error_code make_error_code(BitcodeError E)
@ not_enough_memory
Definition Errc.h:68
@ invalid_argument
Definition Errc.h:56
@ Ref
The access may reference the value stored in memory.
Definition ModRef.h:32
FunctionAddr VTableAddr uintptr_t uintptr_t Data
Definition InstrProf.h:189
OutputIt copy(R &&Range, OutputIt Out)
Definition STLExtras.h:1835
LLVM_ABI std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition Error.cpp:117
LLVM_ABI void report_bad_alloc_error(const char *Reason, bool GenCrashDiag=true)
Reports a bad alloc error, calling any user defined bad alloc error handler.
uintptr_t alignAddr(const void *Addr, Align Alignment)
Aligns Addr to Alignment bytes, rounding up.
Definition Alignment.h:176
N
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
constexpr uint64_t value() const
This is a hole in the type system and should not be abused.
Definition Alignment.h:77
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /