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