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 <cassert>
25 #include <cerrno>
26 #include <cstring>
27 #include <new>
28 #include <sys/types.h>
29 #include <system_error>
30 #if !defined(_MSC_VER) && !defined(__MINGW32__)
31 #include <unistd.h>
32 #else
33 #include <io.h>
34 #endif
35 using namespace llvm;
36 
37 //===----------------------------------------------------------------------===//
38 // MemoryBuffer implementation itself.
39 //===----------------------------------------------------------------------===//
40 
41 MemoryBuffer::~MemoryBuffer() { }
42 
43 /// init - Initialize this MemoryBuffer as a reference to externally allocated
44 /// memory, memory that we know is already null terminated.
45 void MemoryBuffer::init(const char *BufStart, const char *BufEnd,
46                         bool RequiresNullTerminator) {
47   assert((!RequiresNullTerminator || BufEnd[0] == 0) &&
48          "Buffer is not null terminated!");
49   BufferStart = BufStart;
50   BufferEnd = BufEnd;
51 }
52 
53 //===----------------------------------------------------------------------===//
54 // MemoryBufferMem implementation.
55 //===----------------------------------------------------------------------===//
56 
57 /// CopyStringRef - Copies contents of a StringRef into a block of memory and
58 /// null-terminates it.
59 static void CopyStringRef(char *Memory, StringRef Data) {
60   if (!Data.empty())
61     memcpy(Memory, Data.data(), Data.size());
62   Memory[Data.size()] = 0; // Null terminate string.
63 }
64 
65 namespace {
66 struct NamedBufferAlloc {
67   const Twine &Name;
68   NamedBufferAlloc(const Twine &Name) : Name(Name) {}
69 };
70 }
71 
72 void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
73   SmallString<256> NameBuf;
74   StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
75 
76   char *Mem = static_cast<char *>(operator new(N + NameRef.size() + 1));
77   CopyStringRef(Mem + N, NameRef);
78   return Mem;
79 }
80 
81 namespace {
82 /// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.
83 template<typename MB>
84 class MemoryBufferMem : public MB {
85 public:
86   MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) {
87     MemoryBuffer::init(InputData.begin(), InputData.end(),
88                        RequiresNullTerminator);
89   }
90 
91   /// Disable sized deallocation for MemoryBufferMem, because it has
92   /// tail-allocated data.
93   void operator delete(void *p) { ::operator delete(p); }
94 
95   StringRef getBufferIdentifier() const override {
96     // The name is stored after the class itself.
97     return StringRef(reinterpret_cast<const char *>(this + 1));
98   }
99 
100   MemoryBuffer::BufferKind getBufferKind() const override {
101     return MemoryBuffer::MemoryBuffer_Malloc;
102   }
103 };
104 }
105 
106 template <typename MB>
107 static ErrorOr<std::unique_ptr<MB>>
108 getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
109            uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile);
110 
111 std::unique_ptr<MemoryBuffer>
112 MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
113                            bool RequiresNullTerminator) {
114   auto *Ret = new (NamedBufferAlloc(BufferName))
115       MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
116   return std::unique_ptr<MemoryBuffer>(Ret);
117 }
118 
119 std::unique_ptr<MemoryBuffer>
120 MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
121   return std::unique_ptr<MemoryBuffer>(getMemBuffer(
122       Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator));
123 }
124 
125 static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
126 getMemBufferCopyImpl(StringRef InputData, const Twine &BufferName) {
127   auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
128   if (!Buf)
129     return make_error_code(errc::not_enough_memory);
130   memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
131   return std::move(Buf);
132 }
133 
134 std::unique_ptr<MemoryBuffer>
135 MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
136   auto Buf = getMemBufferCopyImpl(InputData, BufferName);
137   if (Buf)
138     return std::move(*Buf);
139   return nullptr;
140 }
141 
142 std::unique_ptr<MemoryBuffer>
143 MemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName) {
144   return WritableMemoryBuffer::getNewUninitMemBuffer(Size, BufferName);
145 }
146 
147 std::unique_ptr<MemoryBuffer>
148 MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) {
149   std::unique_ptr<MemoryBuffer> SB = getNewUninitMemBuffer(Size, BufferName);
150   if (!SB)
151     return nullptr;
152   memset(const_cast<char*>(SB->getBufferStart()), 0, Size);
153   return SB;
154 }
155 
156 ErrorOr<std::unique_ptr<MemoryBuffer>>
157 MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize,
158                              bool RequiresNullTerminator) {
159   SmallString<256> NameBuf;
160   StringRef NameRef = Filename.toStringRef(NameBuf);
161 
162   if (NameRef == "-")
163     return getSTDIN();
164   return getFile(Filename, FileSize, RequiresNullTerminator);
165 }
166 
167 ErrorOr<std::unique_ptr<MemoryBuffer>>
168 MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
169                            uint64_t Offset, bool IsVolatile) {
170   return getFileAux<MemoryBuffer>(FilePath, -1, MapSize, Offset, false,
171                                   IsVolatile);
172 }
173 
174 //===----------------------------------------------------------------------===//
175 // MemoryBuffer::getFile implementation.
176 //===----------------------------------------------------------------------===//
177 
178 namespace {
179 /// \brief Memory maps a file descriptor using sys::fs::mapped_file_region.
180 ///
181 /// This handles converting the offset into a legal offset on the platform.
182 template<typename MB>
183 class MemoryBufferMMapFile : public MB {
184   sys::fs::mapped_file_region MFR;
185 
186   static uint64_t getLegalMapOffset(uint64_t Offset) {
187     return Offset & ~(sys::fs::mapped_file_region::alignment() - 1);
188   }
189 
190   static uint64_t getLegalMapSize(uint64_t Len, uint64_t Offset) {
191     return Len + (Offset - getLegalMapOffset(Offset));
192   }
193 
194   const char *getStart(uint64_t Len, uint64_t Offset) {
195     return MFR.const_data() + (Offset - getLegalMapOffset(Offset));
196   }
197 
198 public:
199   MemoryBufferMMapFile(bool RequiresNullTerminator, int FD, uint64_t Len,
200                        uint64_t Offset, std::error_code &EC)
201       : MFR(FD,
202             MB::Writable ? sys::fs::mapped_file_region::priv
203                          : sys::fs::mapped_file_region::readonly,
204             getLegalMapSize(Len, Offset), getLegalMapOffset(Offset), EC) {
205     if (!EC) {
206       const char *Start = getStart(Len, Offset);
207       MemoryBuffer::init(Start, Start + Len, RequiresNullTerminator);
208     }
209   }
210 
211   /// Disable sized deallocation for MemoryBufferMMapFile, because it has
212   /// tail-allocated data.
213   void operator delete(void *p) { ::operator delete(p); }
214 
215   StringRef getBufferIdentifier() const override {
216     // The name is stored after the class itself.
217     return StringRef(reinterpret_cast<const char *>(this + 1));
218   }
219 
220   MemoryBuffer::BufferKind getBufferKind() const override {
221     return MemoryBuffer::MemoryBuffer_MMap;
222   }
223 };
224 }
225 
226 static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
227 getMemoryBufferForStream(int FD, const Twine &BufferName) {
228   const ssize_t ChunkSize = 4096*4;
229   SmallString<ChunkSize> Buffer;
230   ssize_t ReadBytes;
231   // Read into Buffer until we hit EOF.
232   do {
233     Buffer.reserve(Buffer.size() + ChunkSize);
234     ReadBytes = sys::RetryAfterSignal(-1, read, FD, Buffer.end(), ChunkSize);
235     if (ReadBytes == -1)
236       return std::error_code(errno, std::generic_category());
237     Buffer.set_size(Buffer.size() + ReadBytes);
238   } while (ReadBytes != 0);
239 
240   return getMemBufferCopyImpl(Buffer, BufferName);
241 }
242 
243 
244 ErrorOr<std::unique_ptr<MemoryBuffer>>
245 MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
246                       bool RequiresNullTerminator, bool IsVolatile) {
247   return getFileAux<MemoryBuffer>(Filename, FileSize, FileSize, 0,
248                                   RequiresNullTerminator, IsVolatile);
249 }
250 
251 template <typename MB>
252 static ErrorOr<std::unique_ptr<MB>>
253 getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
254                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
255                 bool IsVolatile);
256 
257 template <typename MB>
258 static ErrorOr<std::unique_ptr<MB>>
259 getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
260            uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile) {
261   int FD;
262   std::error_code EC = sys::fs::openFileForRead(Filename, FD);
263 
264   if (EC)
265     return EC;
266 
267   auto Ret = getOpenFileImpl<MB>(FD, Filename, FileSize, MapSize, Offset,
268                                  RequiresNullTerminator, IsVolatile);
269   close(FD);
270   return Ret;
271 }
272 
273 ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
274 WritableMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
275                               bool IsVolatile) {
276   return getFileAux<WritableMemoryBuffer>(Filename, FileSize, FileSize, 0,
277                                           /*RequiresNullTerminator*/ false,
278                                           IsVolatile);
279 }
280 
281 ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
282 WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
283                                    uint64_t Offset, bool IsVolatile) {
284   return getFileAux<WritableMemoryBuffer>(Filename, -1, MapSize, Offset, false,
285                                           IsVolatile);
286 }
287 
288 std::unique_ptr<WritableMemoryBuffer>
289 WritableMemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName) {
290   using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
291   // Allocate space for the MemoryBuffer, the data and the name. It is important
292   // that MemoryBuffer and data are aligned so PointerIntPair works with them.
293   // TODO: Is 16-byte alignment enough?  We copy small object files with large
294   // alignment expectations into this buffer.
295   SmallString<256> NameBuf;
296   StringRef NameRef = BufferName.toStringRef(NameBuf);
297   size_t AlignedStringLen = alignTo(sizeof(MemBuffer) + NameRef.size() + 1, 16);
298   size_t RealLen = AlignedStringLen + Size + 1;
299   char *Mem = static_cast<char*>(operator new(RealLen, std::nothrow));
300   if (!Mem)
301     return nullptr;
302 
303   // The name is stored after the class itself.
304   CopyStringRef(Mem + sizeof(MemBuffer), NameRef);
305 
306   // The buffer begins after the name and must be aligned.
307   char *Buf = Mem + AlignedStringLen;
308   Buf[Size] = 0; // Null terminate buffer.
309 
310   auto *Ret = new (Mem) MemBuffer(StringRef(Buf, Size), true);
311   return std::unique_ptr<WritableMemoryBuffer>(Ret);
312 }
313 
314 static bool shouldUseMmap(int FD,
315                           size_t FileSize,
316                           size_t MapSize,
317                           off_t Offset,
318                           bool RequiresNullTerminator,
319                           int PageSize,
320                           bool IsVolatile) {
321   // mmap may leave the buffer without null terminator if the file size changed
322   // by the time the last page is mapped in, so avoid it if the file size is
323   // likely to change.
324   if (IsVolatile)
325     return false;
326 
327   // We don't use mmap for small files because this can severely fragment our
328   // address space.
329   if (MapSize < 4 * 4096 || MapSize < (unsigned)PageSize)
330     return false;
331 
332   if (!RequiresNullTerminator)
333     return true;
334 
335   // If we don't know the file size, use fstat to find out.  fstat on an open
336   // file descriptor is cheaper than stat on a random path.
337   // FIXME: this chunk of code is duplicated, but it avoids a fstat when
338   // RequiresNullTerminator = false and MapSize != -1.
339   if (FileSize == size_t(-1)) {
340     sys::fs::file_status Status;
341     if (sys::fs::status(FD, Status))
342       return false;
343     FileSize = Status.getSize();
344   }
345 
346   // If we need a null terminator and the end of the map is inside the file,
347   // we cannot use mmap.
348   size_t End = Offset + MapSize;
349   assert(End <= FileSize);
350   if (End != FileSize)
351     return false;
352 
353   // Don't try to map files that are exactly a multiple of the system page size
354   // if we need a null terminator.
355   if ((FileSize & (PageSize -1)) == 0)
356     return false;
357 
358 #if defined(__CYGWIN__)
359   // Don't try to map files that are exactly a multiple of the physical page size
360   // if we need a null terminator.
361   // FIXME: We should reorganize again getPageSize() on Win32.
362   if ((FileSize & (4096 - 1)) == 0)
363     return false;
364 #endif
365 
366   return true;
367 }
368 
369 template <typename MB>
370 static ErrorOr<std::unique_ptr<MB>>
371 getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
372                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
373                 bool IsVolatile) {
374   static int PageSize = sys::Process::getPageSize();
375 
376   // Default is to map the full file.
377   if (MapSize == uint64_t(-1)) {
378     // If we don't know the file size, use fstat to find out.  fstat on an open
379     // file descriptor is cheaper than stat on a random path.
380     if (FileSize == uint64_t(-1)) {
381       sys::fs::file_status Status;
382       std::error_code EC = sys::fs::status(FD, Status);
383       if (EC)
384         return EC;
385 
386       // If this not a file or a block device (e.g. it's a named pipe
387       // or character device), we can't trust the size. Create the memory
388       // buffer by copying off the stream.
389       sys::fs::file_type Type = Status.type();
390       if (Type != sys::fs::file_type::regular_file &&
391           Type != sys::fs::file_type::block_file)
392         return getMemoryBufferForStream(FD, Filename);
393 
394       FileSize = Status.getSize();
395     }
396     MapSize = FileSize;
397   }
398 
399   if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator,
400                     PageSize, IsVolatile)) {
401     std::error_code EC;
402     std::unique_ptr<MB> Result(
403         new (NamedBufferAlloc(Filename)) MemoryBufferMMapFile<MB>(
404             RequiresNullTerminator, FD, MapSize, Offset, EC));
405     if (!EC)
406       return std::move(Result);
407   }
408 
409   auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(MapSize, Filename);
410   if (!Buf) {
411     // Failed to create a buffer. The only way it can fail is if
412     // new(std::nothrow) returns 0.
413     return make_error_code(errc::not_enough_memory);
414   }
415 
416   char *BufPtr = Buf.get()->getBufferStart();
417 
418   size_t BytesLeft = MapSize;
419 #ifndef HAVE_PREAD
420   if (lseek(FD, Offset, SEEK_SET) == -1)
421     return std::error_code(errno, std::generic_category());
422 #endif
423 
424   while (BytesLeft) {
425 #ifdef HAVE_PREAD
426     ssize_t NumRead = sys::RetryAfterSignal(-1, ::pread, FD, BufPtr, BytesLeft,
427                                             MapSize - BytesLeft + Offset);
428 #else
429     ssize_t NumRead = sys::RetryAfterSignal(-1, ::read, FD, BufPtr, BytesLeft);
430 #endif
431     if (NumRead == -1) {
432       // Error while reading.
433       return std::error_code(errno, std::generic_category());
434     }
435     if (NumRead == 0) {
436       memset(BufPtr, 0, BytesLeft); // zero-initialize rest of the buffer.
437       break;
438     }
439     BytesLeft -= NumRead;
440     BufPtr += NumRead;
441   }
442 
443   return std::move(Buf);
444 }
445 
446 ErrorOr<std::unique_ptr<MemoryBuffer>>
447 MemoryBuffer::getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,
448                           bool RequiresNullTerminator, bool IsVolatile) {
449   return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0,
450                          RequiresNullTerminator, IsVolatile);
451 }
452 
453 ErrorOr<std::unique_ptr<MemoryBuffer>>
454 MemoryBuffer::getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize,
455                                int64_t Offset, bool IsVolatile) {
456   assert(MapSize != uint64_t(-1));
457   return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false,
458                                        IsVolatile);
459 }
460 
461 ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getSTDIN() {
462   // Read in all of the data from stdin, we cannot mmap stdin.
463   //
464   // FIXME: That isn't necessarily true, we should try to mmap stdin and
465   // fallback if it fails.
466   sys::ChangeStdinToBinary();
467 
468   return getMemoryBufferForStream(0, "<stdin>");
469 }
470 
471 ErrorOr<std::unique_ptr<MemoryBuffer>>
472 MemoryBuffer::getFileAsStream(const Twine &Filename) {
473   int FD;
474   std::error_code EC = sys::fs::openFileForRead(Filename, FD);
475   if (EC)
476     return EC;
477   ErrorOr<std::unique_ptr<MemoryBuffer>> Ret =
478       getMemoryBufferForStream(FD, Filename);
479   close(FD);
480   return Ret;
481 }
482 
483 MemoryBufferRef MemoryBuffer::getMemBufferRef() const {
484   StringRef Data = getBuffer();
485   StringRef Identifier = getBufferIdentifier();
486   return MemoryBufferRef(Data, Identifier);
487 }
488