lib/Support/MemoryBuffer.cpp

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