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/IOSandbox.h"
24#include "llvm/Support/Process.h"
25#include "llvm/Support/Program.h"
26#include "llvm/Support/SmallVectorMemoryBuffer.h"
27#include <algorithm>
28#include <cassert>
29#include <cstring>
30#include <new>
31#include <sys/types.h>
32#include <system_error>
33#if !defined(_MSC_VER) && !defined(__MINGW32__)
34#include <unistd.h>
35#else
36#include <io.h>
37#endif
38
39using namespace llvm;
40
41//===----------------------------------------------------------------------===//
42// MemoryBuffer implementation itself.
43//===----------------------------------------------------------------------===//
44
45MemoryBuffer::~MemoryBuffer() = default;
46
47/// init - Initialize this MemoryBuffer as a reference to externally allocated
48/// memory, memory that we know is already null terminated.
49void MemoryBuffer::init(const char *BufStart, const char *BufEnd,
50 bool RequiresNullTerminator) {
51 assert((!RequiresNullTerminator || BufEnd[0] == 0) &&
52 "Buffer is not null terminated!");
53 BufferStart = BufStart;
54 BufferEnd = BufEnd;
55}
56
57//===----------------------------------------------------------------------===//
58// MemoryBufferMem implementation.
59//===----------------------------------------------------------------------===//
60
61/// CopyStringRef - Copies contents of a StringRef into a block of memory and
62/// null-terminates it.
63static void CopyStringRef(char *Memory, StringRef Data) {
64 if (!Data.empty())
65 memcpy(dest: Memory, src: Data.data(), n: Data.size());
66 Memory[Data.size()] = 0; // Null terminate string.
67}
68
69namespace {
70struct NamedBufferAlloc {
71 const Twine &Name;
72 NamedBufferAlloc(const Twine &Name) : Name(Name) {}
73};
74} // namespace
75
76void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
77 SmallString<256> NameBuf;
78 StringRef NameRef = Alloc.Name.toStringRef(Out&: NameBuf);
79
80 // We use malloc() and manually handle it returning null instead of calling
81 // operator new because we need all uses of NamedBufferAlloc to be
82 // deallocated with a call to free() due to needing to use malloc() in
83 // WritableMemoryBuffer::getNewUninitMemBuffer() to work around the out-of-
84 // memory handler installed by default in LLVM. See operator delete() member
85 // functions within this file for the paired call to free().
86 char *Mem =
87 static_cast<char *>(std::malloc(size: N + sizeof(size_t) + NameRef.size() + 1));
88 if (!Mem)
89 llvm::report_bad_alloc_error(Reason: "Allocation failed");
90 *reinterpret_cast<size_t *>(Mem + N) = NameRef.size();
91 CopyStringRef(Memory: Mem + N + sizeof(size_t), Data: NameRef);
92 return Mem;
93}
94
95namespace {
96/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.
97template<typename MB>
98class MemoryBufferMem : public MB {
99public:
100 MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {
101 MemoryBuffer::init(BufStart: InputData.begin(), BufEnd: InputData.end(),
102 RequiresNullTerminator);
103 }
104
105 /// Disable sized deallocation for MemoryBufferMem, because it has
106 /// tail-allocated data.
107 void operator delete(void *p) { std::free(ptr: p); }
108
109 StringRef getBufferIdentifier() const override {
110 // The name is stored after the class itself.
111 return StringRef(reinterpret_cast<const char *>(this + 1) + sizeof(size_t),
112 *reinterpret_cast<const size_t *>(this + 1));
113 }
114
115 MemoryBuffer::BufferKind getBufferKind() const override {
116 return MemoryBuffer::MemoryBuffer_Malloc;
117 }
118};
119} // namespace
120
121template <typename MB>
122static ErrorOr<std::unique_ptr<MB>>
123getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
124 bool IsText, bool RequiresNullTerminator, bool IsVolatile,
125 std::optional<Align> Alignment);
126
127std::unique_ptr<MemoryBuffer>
128MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
129 bool RequiresNullTerminator) {
130 auto *Ret = new (NamedBufferAlloc(BufferName))
131 MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
132 return std::unique_ptr<MemoryBuffer>(Ret);
133}
134
135std::unique_ptr<MemoryBuffer>
136MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
137 return std::unique_ptr<MemoryBuffer>(getMemBuffer(
138 InputData: Ref.getBuffer(), BufferName: Ref.getBufferIdentifier(), RequiresNullTerminator));
139}
140
141static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
142getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
143 auto Buf =
144 WritableMemoryBuffer::getNewUninitMemBuffer(Size: InputData.size(), BufferName);
145 if (!Buf)
146 return make_error_code(E: errc::not_enough_memory);
147 // Calling memcpy with null src/dst is UB, and an empty StringRef is
148 // represented with {nullptr, 0}.
149 llvm::copy(Range&: InputData, Out: Buf->getBufferStart());
150 return std::move(Buf);
151}
152
153std::unique_ptr<MemoryBuffer>
154MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
155 auto Buf = getMemBufferCopyImpl(InputData, BufferName);
156 if (Buf)
157 return std::move(*Buf);
158 return nullptr;
159}
160
161ErrorOr<std::unique_ptr<MemoryBuffer>>
162MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText,
163 bool RequiresNullTerminator,
164 std::optional<Align> Alignment) {
165 sys::sandbox::violationIfEnabled();
166
167 SmallString<256> NameBuf;
168 StringRef NameRef = Filename.toStringRef(Out&: NameBuf);
169
170 if (NameRef == "-")
171 return getSTDIN();
172 return getFile(Filename, IsText, RequiresNullTerminator,
173 /*IsVolatile=*/false, Alignment);
174}
175
176ErrorOr<std::unique_ptr<MemoryBuffer>>
177MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
178 uint64_t Offset, bool IsVolatile,
179 std::optional<Align> Alignment) {
180 sys::sandbox::violationIfEnabled();
181
182 return getFileAux<MemoryBuffer>(Filename: FilePath, MapSize, Offset, /*IsText=*/false,
183 /*RequiresNullTerminator=*/false, IsVolatile,
184 Alignment);
185}
186
187//===----------------------------------------------------------------------===//
188// MemoryBuffer::getFile implementation.
189//===----------------------------------------------------------------------===//
190
191namespace {
192
193template <typename MB>
194constexpr sys::fs::mapped_file_region::mapmode Mapmode =
195 sys::fs::mapped_file_region::readonly;
196template <>
197constexpr sys::fs::mapped_file_region::mapmode Mapmode<MemoryBuffer> =
198 sys::fs::mapped_file_region::readonly;
199template <>
200constexpr sys::fs::mapped_file_region::mapmode Mapmode<WritableMemoryBuffer> =
201 sys::fs::mapped_file_region::priv;
202template <>
203constexpr sys::fs::mapped_file_region::mapmode
204 Mapmode<WriteThroughMemoryBuffer> = sys::fs::mapped_file_region::readwrite;
205
206/// Memory maps a file descriptor using sys::fs::mapped_file_region.
207///
208/// This handles converting the offset into a legal offset on the platform.
209template<typename MB>
210class MemoryBufferMMapFile : public MB {
211 sys::fs::mapped_file_region MFR;
212
213 static uint64_t getLegalMapOffset(uint64_t Offset) {
214 return Offset & ~(sys::fs::mapped_file_region::alignment() - 1);
215 }
216
217 static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) {
218 return Len + (Offset - getLegalMapOffset(Offset));
219 }
220
221 const char *getStart(uint64_t Len, uint64_t Offset) {
222 return MFR.const_data() + (Offset - getLegalMapOffset(Offset));
223 }
224
225public:
226 MemoryBufferMMapFile(bool RequiresNullTerminator, sys::fs::file_t FD, uint64_t Len,
227 uint64_t Offset, std::error_code &EC)
228 : MFR(FD, Mapmode<MB>, getLegalMapSize(Len, Offset),
229 getLegalMapOffset(Offset), EC) {
230 if (!EC) {
231 const char *Start = getStart(Len, Offset);
232 MemoryBuffer::init(BufStart: Start, BufEnd: Start + Len, RequiresNullTerminator);
233 }
234 }
235
236 /// Disable sized deallocation for MemoryBufferMMapFile, because it has
237 /// tail-allocated data.
238 void operator delete(void *p) { std::free(ptr: p); }
239
240 StringRef getBufferIdentifier() const override {
241 // The name is stored after the class itself.
242 return StringRef(reinterpret_cast<const char *>(this + 1) + sizeof(size_t),
243 *reinterpret_cast<const size_t *>(this + 1));
244 }
245
246 MemoryBuffer::BufferKind getBufferKind() const override {
247 return MemoryBuffer::MemoryBuffer_MMap;
248 }
249
250 void dontNeedIfMmap() override { MFR.dontNeed(); }
251 void willNeedIfMmap() override { MFR.willNeed(); }
252 void randomAccessIfMmap() override { MFR.randomAccess(); }
253};
254} // namespace
255
256static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
257getMemoryBufferForStream(sys::fs::file_t FD, const Twine &BufferName) {
258 SmallString<sys::fs::DefaultReadChunkSize> Buffer;
259 if (Error E = sys::fs::readNativeFileToEOF(FileHandle: FD, Buffer))
260 return errorToErrorCode(Err: std::move(E));
261 return getMemBufferCopyImpl(InputData: Buffer, BufferName);
262}
263
264ErrorOr<std::unique_ptr<MemoryBuffer>>
265MemoryBuffer::getFile(const Twine &Filename, bool IsText,
266 bool RequiresNullTerminator, bool IsVolatile,
267 std::optional<Align> Alignment) {
268 sys::sandbox::violationIfEnabled();
269
270 return getFileAux<MemoryBuffer>(Filename, /*MapSize=*/-1, /*Offset=*/0,
271 IsText, RequiresNullTerminator, IsVolatile,
272 Alignment);
273}
274
275template <typename MB>
276static ErrorOr<std::unique_ptr<MB>>
277getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
278 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
279 bool IsVolatile, std::optional<Align> Alignment);
280
281template <typename MB>
282static ErrorOr<std::unique_ptr<MB>>
283getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
284 bool IsText, bool RequiresNullTerminator, bool IsVolatile,
285 std::optional<Align> Alignment) {
286 Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
287 Name: Filename, Flags: IsText ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None);
288 if (!FDOrErr)
289 return errorToErrorCode(Err: FDOrErr.takeError());
290 sys::fs::file_t FD = *FDOrErr;
291 auto Ret = getOpenFileImpl<MB>(FD, Filename, /*FileSize=*/-1, MapSize, Offset,
292 RequiresNullTerminator, IsVolatile, Alignment);
293 sys::fs::closeFile(F&: FD);
294 return Ret;
295}
296
297ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
298WritableMemoryBuffer::getFile(const Twine &Filename, bool IsVolatile,
299 std::optional<Align> Alignment) {
300 sys::sandbox::violationIfEnabled();
301
302 return getFileAux<WritableMemoryBuffer>(
303 Filename, /*MapSize=*/-1, /*Offset=*/0, /*IsText=*/false,
304 /*RequiresNullTerminator=*/false, IsVolatile, Alignment);
305}
306
307ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
308WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
309 uint64_t Offset, bool IsVolatile,
310 std::optional<Align> Alignment) {
311 sys::sandbox::violationIfEnabled();
312
313 return getFileAux<WritableMemoryBuffer>(
314 Filename, MapSize, Offset, /*IsText=*/false,
315 /*RequiresNullTerminator=*/false, IsVolatile, Alignment);
316}
317
318std::unique_ptr<WritableMemoryBuffer>
319WritableMemoryBuffer::getNewUninitMemBuffer(size_t Size,
320 const Twine &BufferName,
321 std::optional<Align> Alignment) {
322 using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
323
324 // Use 16-byte alignment if no alignment is specified.
325 Align BufAlign = Alignment.value_or(u: Align(16));
326
327 // Allocate space for the MemoryBuffer, the data and the name. It is important
328 // that MemoryBuffer and data are aligned so PointerIntPair works with them.
329 SmallString<256> NameBuf;
330 StringRef NameRef = BufferName.toStringRef(Out&: NameBuf);
331
332 size_t StringLen = sizeof(MemBuffer) + sizeof(size_t) + NameRef.size() + 1;
333 size_t RealLen = StringLen + Size + 1 + BufAlign.value();
334 if (RealLen <= Size) // Check for rollover.
335 return nullptr;
336 // We use a call to malloc() rather than a call to a non-throwing operator
337 // new() because LLVM unconditionally installs an out of memory new handler
338 // when exceptions are disabled. This new handler intentionally crashes to
339 // aid with debugging, but that makes non-throwing new calls unhelpful.
340 // See MemoryBufferMem::operator delete() for the paired call to free(), and
341 // llvm::install_out_of_memory_new_handler() for the installation of the
342 // custom new handler.
343 char *Mem = static_cast<char *>(std::malloc(size: RealLen));
344 if (!Mem)
345 return nullptr;
346
347 // The name is stored after the class itself.
348 *reinterpret_cast<size_t *>(Mem + sizeof(MemBuffer)) = NameRef.size();
349 CopyStringRef(Memory: Mem + sizeof(MemBuffer) + sizeof(size_t), Data: NameRef);
350
351 // The buffer begins after the name and must be aligned.
352 char *Buf = (char *)alignAddr(Addr: Mem + StringLen, Alignment: BufAlign);
353 Buf[Size] = 0; // Null terminate buffer.
354
355 auto *Ret = new (Mem) MemBuffer(StringRef(Buf, Size), true);
356 return std::unique_ptr<WritableMemoryBuffer>(Ret);
357}
358
359std::unique_ptr<WritableMemoryBuffer>
360WritableMemoryBuffer::getNewMemBuffer(size_t Size, const Twine &BufferName) {
361 auto SB = WritableMemoryBuffer::getNewUninitMemBuffer(Size, BufferName);
362 if (!SB)
363 return nullptr;
364 memset(s: SB->getBufferStart(), c: 0, n: Size);
365 return SB;
366}
367
368static bool shouldUseMmap(sys::fs::file_t FD,
369 size_t FileSize,
370 size_t MapSize,
371 off_t Offset,
372 bool RequiresNullTerminator,
373 int PageSize,
374 bool IsVolatile) {
375#if defined(__MVS__)
376 // zOS Enhanced ASCII auto convert does not support mmap.
377 return false;
378#endif
379
380 // mmap may leave the buffer without null terminator if the file size changed
381 // by the time the last page is mapped in, so avoid it if the file size is
382 // likely to change.
383 if (IsVolatile && RequiresNullTerminator)
384 return false;
385
386 // We don't use mmap for small files because this can severely fragment our
387 // address space.
388 if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize)
389 return false;
390
391 if (!RequiresNullTerminator)
392 return true;
393
394 // If we don't know the file size, use fstat to find out. fstat on an open
395 // file descriptor is cheaper than stat on a random path.
396 // FIXME: this chunk of code is duplicated, but it avoids a fstat when
397 // RequiresNullTerminator = false and MapSize != -1.
398 if (FileSize == size_t(-1)) {
399 sys::fs::file_status Status;
400 if (sys::fs::status(FD, Result&: Status))
401 return false;
402 FileSize = Status.getSize();
403 }
404
405 // If we need a null terminator and the end of the map is inside the file,
406 // we cannot use mmap.
407 size_t End = Offset + MapSize;
408 assert(End <= FileSize);
409 if (End != FileSize)
410 return false;
411
412 // Don't try to map files that are exactly a multiple of the system page size
413 // if we need a null terminator.
414 if ((FileSize & (PageSize -1)) == 0)
415 return false;
416
417#if defined(__CYGWIN__)
418 // Don't try to map files that are exactly a multiple of the physical page size
419 // if we need a null terminator.
420 // FIXME: We should reorganize again getPageSize() on Win32.
421 if ((FileSize & (4096 - 1)) == 0)
422 return false;
423#endif
424
425 return true;
426}
427
428static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
429getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
430 uint64_t Offset) {
431 Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForReadWrite(
432 Name: Filename, Disp: sys::fs::CD_OpenExisting, Flags: sys::fs::OF_None);
433 if (!FDOrErr)
434 return errorToErrorCode(Err: FDOrErr.takeError());
435 sys::fs::file_t FD = *FDOrErr;
436
437 // Default is to map the full file.
438 if (MapSize == uint64_t(-1)) {
439 // If we don't know the file size, use fstat to find out. fstat on an open
440 // file descriptor is cheaper than stat on a random path.
441 if (FileSize == uint64_t(-1)) {
442 sys::fs::file_status Status;
443 std::error_code EC = sys::fs::status(FD, Result&: Status);
444 if (EC)
445 return EC;
446
447 // If this not a file or a block device (e.g. it's a named pipe
448 // or character device), we can't mmap it, so error out.
449 sys::fs::file_type Type = Status.type();
450 if (Type != sys::fs::file_type::regular_file &&
451 Type != sys::fs::file_type::block_file)
452 return make_error_code(E: errc::invalid_argument);
453
454 FileSize = Status.getSize();
455 }
456 MapSize = FileSize;
457 }
458
459 std::error_code EC;
460 std::unique_ptr<WriteThroughMemoryBuffer> Result(
461 new (NamedBufferAlloc(Filename))
462 MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
463 Offset, EC));
464 if (EC)
465 return EC;
466 return std::move(Result);
467}
468
469ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
470WriteThroughMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize) {
471 sys::sandbox::violationIfEnabled();
472
473 return getReadWriteFile(Filename, FileSize, MapSize: FileSize, Offset: 0);
474}
475
476/// Map a subrange of the specified file as a WritableMemoryBuffer.
477ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
478WriteThroughMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
479 uint64_t Offset) {
480 sys::sandbox::violationIfEnabled();
481
482 return getReadWriteFile(Filename, FileSize: -1, MapSize, Offset);
483}
484
485template <typename MB>
486static ErrorOr<std::unique_ptr<MB>>
487getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
488 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
489 bool IsVolatile, std::optional<Align> Alignment) {
490 static int PageSize = sys::Process::getPageSizeEstimate();
491
492 // Default is to map the full file.
493 if (MapSize == uint64_t(-1)) {
494 // If we don't know the file size, use fstat to find out. fstat on an open
495 // file descriptor is cheaper than stat on a random path.
496 if (FileSize == uint64_t(-1)) {
497 sys::fs::file_status Status;
498 std::error_code EC = sys::fs::status(FD, Result&: Status);
499 if (EC)
500 return EC;
501
502 // If this not a file or a block device (e.g. it's a named pipe
503 // or character device), we can't trust the size. Create the memory
504 // buffer by copying off the stream.
505 sys::fs::file_type Type = Status.type();
506 if (Type != sys::fs::file_type::regular_file &&
507 Type != sys::fs::file_type::block_file)
508 return getMemoryBufferForStream(FD, BufferName: Filename);
509
510 FileSize = Status.getSize();
511 }
512 MapSize = FileSize;
513 }
514
515 if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
516 PageSize, IsVolatile)) {
517 std::error_code EC;
518 std::unique_ptr<MB> Result(
519 new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile<MB>(
520 RequiresNullTerminator, FD, MapSize, Offset, EC));
521 if (!EC) {
522 // On at least Linux, and possibly on other systems, mmap may return pages
523 // from the page cache that are not properly filled with trailing zeroes,
524 // if some prior user of the page wrote non-zero bytes. Detect this and
525 // don't use mmap in that case.
526 if (!RequiresNullTerminator || *Result->getBufferEnd() == '\0')
527 return std::move(Result);
528 }
529 }
530
531#ifdef __MVS__
532 ErrorOr<bool> NeedsConversion = needConversion(Filename, FD);
533 if (std::error_code EC = NeedsConversion.getError())
534 return EC;
535 // File size may increase due to EBCDIC -> UTF-8 conversion, therefore we
536 // cannot trust the file size and we create the memory buffer by copying
537 // off the stream.
538 // Note: This only works with the assumption of reading a full file (i.e,
539 // Offset == 0 and MapSize == FileSize). Reading a file slice does not work.
540 if (*NeedsConversion && Offset == 0 && MapSize == FileSize)
541 return getMemoryBufferForStream(FD, Filename);
542#endif
543
544 auto Buf =
545 WritableMemoryBuffer::getNewUninitMemBuffer(Size: MapSize, BufferName: Filename, Alignment);
546 if (!Buf) {
547 // Failed to create a buffer. The only way it can fail is if
548 // new(std::nothrow) returns 0.
549 return make_error_code(E: errc::not_enough_memory);
550 }
551
552 // Read until EOF, zero-initialize the rest.
553 MutableArrayRef<char> ToRead = Buf->getBuffer();
554 while (!ToRead.empty()) {
555 Expected<size_t> ReadBytes =
556 sys::fs::readNativeFileSlice(FileHandle: FD, Buf: ToRead, Offset);
557 if (!ReadBytes)
558 return errorToErrorCode(Err: ReadBytes.takeError());
559 if (*ReadBytes == 0) {
560 std::memset(s: ToRead.data(), c: 0, n: ToRead.size());
561 break;
562 }
563 ToRead = ToRead.drop_front(N: *ReadBytes);
564 Offset += *ReadBytes;
565 }
566
567 return std::move(Buf);
568}
569
570ErrorOr<std::unique_ptr<MemoryBuffer>>
571MemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename,
572 uint64_t FileSize, bool RequiresNullTerminator,
573 bool IsVolatile, std::optional<Align> Alignment) {
574 sys::sandbox::violationIfEnabled();
575
576 return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, MapSize: FileSize, Offset: 0,
577 RequiresNullTerminator, IsVolatile,
578 Alignment);
579}
580
581ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getOpenFileSlice(
582 sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize, int64_t Offset,
583 bool IsVolatile, std::optional<Align> Alignment) {
584 assert(MapSize != uint64_t(-1));
585
586 sys::sandbox::violationIfEnabled();
587
588 return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize: -1, MapSize, Offset, RequiresNullTerminator: false,
589 IsVolatile, Alignment);
590}
591
592ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
593 sys::sandbox::violationIfEnabled();
594
595 // Read in all of the data from stdin, we cannot mmap stdin.
596 //
597 // FIXME: That isn't necessarily true, we should try to mmap stdin and
598 // fallback if it fails.
599 sys::ChangeStdinMode(Flags: sys::fs::OF_Text);
600
601 return getMemoryBufferForStream(FD: sys::fs::getStdinHandle(), BufferName: "<stdin>");
602}
603
604ErrorOr<std::unique_ptr<MemoryBuffer>>
605MemoryBuffer::getFileAsStream(const Twine &Filename) {
606 sys::sandbox::violationIfEnabled();
607
608 Expected<sys::fs::file_t> FDOrErr =
609 sys::fs::openNativeFileForRead(Name: Filename, Flags: sys::fs::OF_None);
610 if (!FDOrErr)
611 return errorToErrorCode(Err: FDOrErr.takeError());
612 sys::fs::file_t FD = *FDOrErr;
613 ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =
614 getMemoryBufferForStream(FD, BufferName: Filename);
615 sys::fs::closeFile(F&: FD);
616 return Ret;
617}
618
619MemoryBufferRef MemoryBuffer::getMemBufferRef() const {
620 StringRef Data = getBuffer();
621 StringRef Identifier = getBufferIdentifier();
622 return MemoryBufferRef(Data, Identifier);
623}
624
625SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() = default;
626