Line data Source code
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 :
14 : #include "llvm/Support/MemoryBuffer.h"
15 : #include "llvm/ADT/SmallString.h"
16 : #include "llvm/Config/config.h"
17 : #include "llvm/Support/Errc.h"
18 : #include "llvm/Support/Errno.h"
19 : #include "llvm/Support/FileSystem.h"
20 : #include "llvm/Support/MathExtras.h"
21 : #include "llvm/Support/Path.h"
22 : #include "llvm/Support/Process.h"
23 : #include "llvm/Support/Program.h"
24 : #include "llvm/Support/SmallVectorMemoryBuffer.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 :
42 962637 : MemoryBuffer::~MemoryBuffer() { }
43 :
44 : /// init - Initialize this MemoryBuffer as a reference to externally allocated
45 : /// memory, memory that we know is already null terminated.
46 1687373 : 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 1687373 : BufferStart = BufStart;
51 1687373 : BufferEnd = BufEnd;
52 1687373 : }
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 1229135 : if (!Data.empty())
62 1227455 : memcpy(Memory, Data.data(), Data.size());
63 0 : 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 0 : void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
74 : SmallString<256> NameBuf;
75 0 : StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
76 :
77 0 : char *Mem = static_cast<char *>(operator new(N + NameRef.size() + 1));
78 0 : CopyStringRef(Mem + N, NameRef);
79 0 : 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 1522826 : MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {
88 293691 : 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 3025418 : StringRef getBufferIdentifier() const override {
97 : // The name is stored after the class itself.
98 3025418 : return StringRef(reinterpret_cast<const char *>(this + 1));
99 : }
100 56417 :
101 : MemoryBuffer::BufferKind getBufferKind() const override {
102 56417 : return MemoryBuffer::MemoryBuffer_Malloc;
103 : }
104 2969001 : };
105 : }
106 2969001 :
107 : template <typename MB>
108 : static ErrorOr<std::unique_ptr<MB>>
109 2 : getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
110 2 : uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile);
111 :
112 0 : std::unique_ptr<MemoryBuffer>
113 0 : MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
114 : bool RequiresNullTerminator) {
115 2 : auto *Ret = new (NamedBufferAlloc(BufferName))
116 2 : 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 :
126 : static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
127 293676 : getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
128 : auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
129 293691 : if (!Buf)
130 587352 : return make_error_code(errc::not_enough_memory);
131 293691 : memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
132 : return std::move(Buf);
133 : }
134 :
135 39821 : std::unique_ptr<MemoryBuffer>
136 : MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
137 39821 : auto Buf = getMemBufferCopyImpl(InputData, BufferName);
138 : if (Buf)
139 : return std::move(*Buf);
140 : return nullptr;
141 468599 : }
142 468599 :
143 468599 : ErrorOr<std::unique_ptr<MemoryBuffer>>
144 0 : MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize,
145 468599 : bool RequiresNullTerminator) {
146 : SmallString<256> NameBuf;
147 : StringRef NameRef = Filename.toStringRef(NameBuf);
148 :
149 : if (NameRef == "-")
150 259164 : return getSTDIN();
151 259164 : return getFile(Filename, FileSize, RequiresNullTerminator);
152 259164 : }
153 :
154 : ErrorOr<std::unique_ptr<MemoryBuffer>>
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 178282 : IsVolatile);
159 : }
160 :
161 178282 : //===----------------------------------------------------------------------===//
162 : // MemoryBuffer::getFile implementation.
163 : //===----------------------------------------------------------------------===//
164 94914 :
165 83368 : 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 9 : template<typename MB>
170 : class MemoryBufferMMapFile : public MB {
171 : sys::fs::mapped_file_region MFR;
172 9 :
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 328418 : : MFR(FD, MB::Mapmode, getLegalMapSize(Len, Offset),
189 : getLegalMapOffset(Offset), EC) {
190 : if (!EC) {
191 : const char *Start = getStart(Len, Offset);
192 164209 : MemoryBuffer::init(Start, Start + Len, RequiresNullTerminator);
193 : }
194 : }
195 0 :
196 164209 : /// Disable sized deallocation for MemoryBufferMMapFile, because it has
197 : /// tail-allocated data.
198 0 : void operator delete(void *p) { ::operator delete(p); }
199 0 :
200 : StringRef getBufferIdentifier() const override {
201 0 : // The name is stored after the class itself.
202 0 : return StringRef(reinterpret_cast<const char *>(this + 1));
203 : }
204 0 :
205 0 : MemoryBuffer::BufferKind getBufferKind() const override {
206 : return MemoryBuffer::MemoryBuffer_MMap;
207 : }
208 : };
209 164209 : }
210 :
211 : static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
212 328418 : getMemoryBufferForStream(int FD, const Twine &BufferName) {
213 164209 : const ssize_t ChunkSize = 4096*4;
214 : SmallString<ChunkSize> Buffer;
215 164209 : ssize_t ReadBytes;
216 : // Read into Buffer until we hit EOF.
217 164209 : do {
218 1 : Buffer.reserve(Buffer.size() + ChunkSize);
219 : ReadBytes = sys::RetryAfterSignal(-1, ::read, FD, Buffer.end(), ChunkSize);
220 : if (ReadBytes == -1)
221 2 : return std::error_code(errno, std::generic_category());
222 1 : Buffer.set_size(Buffer.size() + ReadBytes);
223 : } while (ReadBytes != 0);
224 1 :
225 : return getMemBufferCopyImpl(Buffer, BufferName);
226 1 : }
227 164207 :
228 :
229 : ErrorOr<std::unique_ptr<MemoryBuffer>>
230 328414 : MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
231 164207 : bool RequiresNullTerminator, bool IsVolatile) {
232 : return getFileAux<MemoryBuffer>(Filename, FileSize, FileSize, 0,
233 164207 : RequiresNullTerminator, IsVolatile);
234 : }
235 164207 :
236 1 : template <typename MB>
237 : static ErrorOr<std::unique_ptr<MB>>
238 : getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
239 2 : uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
240 1 : bool IsVolatile);
241 :
242 1 : template <typename MB>
243 : static ErrorOr<std::unique_ptr<MB>>
244 1 : 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 4407973 : return EC;
251 :
252 4407973 : auto Ret = getOpenFileImpl<MB>(FD, Filename, FileSize, MapSize, Offset,
253 : RequiresNullTerminator, IsVolatile);
254 0 : close(FD);
255 : return Ret;
256 0 : }
257 :
258 4407973 : ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
259 : WritableMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
260 4407973 : bool IsVolatile) {
261 : return getFileAux<WritableMemoryBuffer>(Filename, FileSize, FileSize, 0,
262 0 : /*RequiresNullTerminator*/ false,
263 : IsVolatile);
264 0 : }
265 :
266 : ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
267 0 : WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
268 0 : uint64_t Offset, bool IsVolatile) {
269 : return getFileAux<WritableMemoryBuffer>(Filename, -1, MapSize, Offset, false,
270 0 : IsVolatile);
271 0 : }
272 :
273 0 : std::unique_ptr<WritableMemoryBuffer>
274 0 : WritableMemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName) {
275 : using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
276 0 : // Allocate space for the MemoryBuffer, the data and the name. It is important
277 0 : // 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 209435 : size_t RealLen = AlignedStringLen + Size + 1;
284 209435 : 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 29601732 : CopyStringRef(Mem + sizeof(MemBuffer), NameRef);
290 14800866 :
291 14800866 : // The buffer begins after the name and must be aligned.
292 0 : char *Buf = Mem + AlignedStringLen;
293 29601732 : Buf[Size] = 0; // Null terminate buffer.
294 14800866 :
295 : auto *Ret = new (Mem) MemBuffer(StringRef(Buf, Size), true);
296 209435 : return std::unique_ptr<WritableMemoryBuffer>(Ret);
297 : }
298 :
299 : std::unique_ptr<WritableMemoryBuffer>
300 : WritableMemoryBuffer::getNewMemBuffer(size_t Size, const Twine &BufferName) {
301 116915 : auto SB = WritableMemoryBuffer::getNewUninitMemBuffer(Size, BufferName);
302 : if (!SB)
303 : return nullptr;
304 116915 : 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 116925 : // 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 116925 : if (IsVolatile)
319 : return false;
320 116925 :
321 16447 : // We don't use mmap for small files because this can severely fragment our
322 : // address space.
323 100478 : if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize)
324 : return false;
325 100477 :
326 : if (!RequiresNullTerminator)
327 : return true;
328 1 :
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 1 : // FIXME: this chunk of code is duplicated, but it avoids a fstat when
332 : // RequiresNullTerminator = false and MapSize != -1.
333 1 : if (FileSize == size_t(-1)) {
334 0 : sys::fs::file_status Status;
335 : if (sys::fs::status(FD, Status))
336 1 : return false;
337 : FileSize = Status.getSize();
338 1 : }
339 :
340 : // If we need a null terminator and the end of the map is inside the file,
341 116924 : // we cannot use mmap.
342 : size_t End = Offset + MapSize;
343 : assert(End <= FileSize);
344 116924 : if (End != FileSize)
345 : return false;
346 116924 :
347 16447 : // Don't try to map files that are exactly a multiple of the system page size
348 : // if we need a null terminator.
349 100477 : if ((FileSize & (PageSize -1)) == 0)
350 : return false;
351 100476 :
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 0 : if ((FileSize & (4096 - 1)) == 0)
357 : return false;
358 : #endif
359 :
360 0 : return true;
361 : }
362 :
363 : static ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
364 1 : getReadWriteFile(const Twine &Filename, uint64_t FileSize, uint64_t MapSize,
365 : uint64_t Offset) {
366 : int FD;
367 1 : std::error_code EC = sys::fs::openFileForReadWrite(
368 : Filename, FD, sys::fs::CD_OpenExisting, sys::fs::OF_None);
369 :
370 : if (EC)
371 1229135 : 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 1229135 : sys::fs::file_status Status;
379 : std::error_code EC = sys::fs::status(FD, Status);
380 1229135 : if (EC)
381 1229135 : return EC;
382 1229135 :
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 1229135 : if (Type != sys::fs::file_type::regular_file &&
387 : Type != sys::fs::file_type::block_file)
388 : return make_error_code(errc::invalid_argument);
389 1229135 :
390 1229135 : FileSize = Status.getSize();
391 : }
392 : MapSize = FileSize;
393 : }
394 :
395 : std::unique_ptr<WriteThroughMemoryBuffer> Result(
396 : new (NamedBufferAlloc(Filename))
397 23632 : MemoryBufferMMapFile<WriteThroughMemoryBuffer>(false, FD, MapSize,
398 23632 : Offset, EC));
399 23632 : if (EC)
400 : return EC;
401 23632 : return std::move(Result);
402 : }
403 :
404 : ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
405 900229 : 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.
410 : ErrorOr<std::unique_ptr<WriteThroughMemoryBuffer>>
411 : WriteThroughMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
412 : uint64_t Offset) {
413 : return getReadWriteFile(Filename, -1, MapSize, Offset);
414 : }
415 900229 :
416 : template <typename MB>
417 : static ErrorOr<std::unique_ptr<MB>>
418 : getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
419 : uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
420 896545 : bool IsVolatile) {
421 : static int PageSize = sys::Process::getPageSize();
422 :
423 164263 : // 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 163925 : if (EC)
431 0 : return EC;
432 0 :
433 0 : // If this not a file or a block device (e.g. it's a named pipe
434 0 : // 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 &&
438 : Type != sys::fs::file_type::block_file)
439 163925 : return getMemoryBufferForStream(FD, Filename);
440 :
441 163925 : FileSize = Status.getSize();
442 : }
443 : MapSize = FileSize;
444 : }
445 :
446 163925 : if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
447 55 : 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.
460 : return make_error_code(errc::not_enough_memory);
461 1 : }
462 :
463 : char *BufPtr = Buf.get()->getBufferStart();
464 :
465 1 : size_t BytesLeft = MapSize;
466 : #ifndef HAVE_PREAD
467 1 : if (lseek(FD, Offset, SEEK_SET) == -1)
468 0 : return std::error_code(errno, std::generic_category());
469 : #endif
470 :
471 1 : while (BytesLeft) {
472 : #ifdef HAVE_PREAD
473 : ssize_t NumRead = sys::RetryAfterSignal(-1, ::pread, FD, BufPtr, BytesLeft,
474 1 : MapSize - BytesLeft + Offset);
475 1 : #else
476 1 : ssize_t NumRead = sys::RetryAfterSignal(-1, ::read, FD, BufPtr, BytesLeft);
477 1 : #endif
478 0 : if (NumRead == -1) {
479 : // Error while reading.
480 : return std::error_code(errno, std::generic_category());
481 : }
482 1 : if (NumRead == 0) {
483 2 : memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer.
484 1 : break;
485 0 : }
486 : BytesLeft -= NumRead;
487 1 : BufPtr += NumRead;
488 : }
489 :
490 : return std::move(Buf);
491 : }
492 :
493 : ErrorOr<std::unique_ptr<MemoryBuffer>>
494 : MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,
495 1 : bool RequiresNullTerminator, bool IsVolatile) {
496 1 : return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
497 0 : RequiresNullTerminator, IsVolatile);
498 : }
499 :
500 : ErrorOr<std::unique_ptr<MemoryBuffer>>
501 : MemoryBuffer::getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize,
502 1 : int64_t Offset, bool IsVolatile) {
503 1 : assert(MapSize != uint64_t(-1));
504 : return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
505 : IsVolatile);
506 : }
507 :
508 0 : ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
509 : // Read in all of the data from stdin, we cannot mmap stdin.
510 0 : //
511 : // FIXME: That isn't necessarily true, we should try to mmap stdin and
512 : // fallback if it fails.
513 : sys::ChangeStdinToBinary();
514 :
515 900291 : return getMemoryBufferForStream(0, "<stdin>");
516 : }
517 :
518 900291 : ErrorOr<std::unique_ptr<MemoryBuffer>>
519 : MemoryBuffer::getFileAsStream(const Twine &Filename) {
520 : int FD;
521 900291 : std::error_code EC = sys::fs::openFileForRead(Filename, FD, sys::fs::OF_None);
522 : if (EC)
523 : return EC;
524 161036 : ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =
525 161036 : getMemoryBufferForStream(FD, Filename);
526 161036 : close(FD);
527 161036 : return Ret;
528 62 : }
529 :
530 : MemoryBufferRef MemoryBuffer::getMemBufferRef() const {
531 : StringRef Data = getBuffer();
532 : StringRef Identifier = getBufferIdentifier();
533 161036 : return MemoryBufferRef(Data, Identifier);
534 322072 : }
535 161036 :
536 124 : SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() {}
|
