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