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/OwningPtr.h" 16#include "llvm/ADT/SmallString.h" 17#include "llvm/Config/config.h" 18#include "llvm/Support/MathExtras.h" 19#include "llvm/Support/Errno.h" 20#include "llvm/Support/FileSystem.h" 21#include "llvm/Support/Path.h" 22#include "llvm/Support/Process.h" 23#include "llvm/Support/Program.h" 24#include "llvm/Support/system_error.h" 25#include <cassert> 26#include <cstdio> 27#include <cstring> 28#include <cerrno> 29#include <new> 30#include <sys/types.h> 31#include <sys/stat.h> 32#if !defined(_MSC_VER) && !defined(__MINGW32__) 33#include <unistd.h> 34#else 35#include <io.h> 36#endif 37#include <fcntl.h> 38using namespace llvm; 39 40//===----------------------------------------------------------------------===// 41// MemoryBuffer implementation itself. 42//===----------------------------------------------------------------------===// 43 44MemoryBuffer::~MemoryBuffer() { } 45 46/// init - Initialize this MemoryBuffer as a reference to externally allocated 47/// memory, memory that we know is already null terminated. 48void MemoryBuffer::init(const char *BufStart, const char *BufEnd, 49 bool RequiresNullTerminator) { 50 assert((!RequiresNullTerminator || BufEnd[0] == 0) && 51 "Buffer is not null terminated!"); 52 BufferStart = BufStart; 53 BufferEnd = BufEnd; 54} 55 56//===----------------------------------------------------------------------===// 57// MemoryBufferMem implementation. 58//===----------------------------------------------------------------------===// 59 60/// CopyStringRef - Copies contents of a StringRef into a block of memory and 61/// null-terminates it. 62static void CopyStringRef(char *Memory, StringRef Data) { 63 memcpy(Memory, Data.data(), Data.size()); 64 Memory[Data.size()] = 0; // Null terminate string. 65} 66 67/// GetNamedBuffer - Allocates a new MemoryBuffer with Name copied after it. 68template <typename T> 69static T *GetNamedBuffer(StringRef Buffer, StringRef Name, 70 bool RequiresNullTerminator) { 71 char *Mem = static_cast<char*>(operator new(sizeof(T) + Name.size() + 1)); 72 CopyStringRef(Mem + sizeof(T), Name); 73 return new (Mem) T(Buffer, RequiresNullTerminator); 74} 75 76namespace { 77/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory. 78class MemoryBufferMem : public MemoryBuffer { 79public: 80 MemoryBufferMem(StringRef InputData, bool RequiresNullTerminator) { 81 init(InputData.begin(), InputData.end(), RequiresNullTerminator); 82 } 83 84 virtual const char *getBufferIdentifier() const { 85 // The name is stored after the class itself. 86 return reinterpret_cast<const char*>(this + 1); 87 } 88 89 virtual BufferKind getBufferKind() const { 90 return MemoryBuffer_Malloc; 91 } 92}; 93} 94 95/// getMemBuffer - Open the specified memory range as a MemoryBuffer. Note 96/// that InputData must be a null terminated if RequiresNullTerminator is true! 97MemoryBuffer *MemoryBuffer::getMemBuffer(StringRef InputData, 98 StringRef BufferName, 99 bool RequiresNullTerminator) { 100 return GetNamedBuffer<MemoryBufferMem>(InputData, BufferName, 101 RequiresNullTerminator); 102} 103 104/// getMemBufferCopy - Open the specified memory range as a MemoryBuffer, 105/// copying the contents and taking ownership of it. This has no requirements 106/// on EndPtr[0]. 107MemoryBuffer *MemoryBuffer::getMemBufferCopy(StringRef InputData, 108 StringRef BufferName) { 109 MemoryBuffer *Buf = getNewUninitMemBuffer(InputData.size(), BufferName); 110 if (!Buf) return 0; 111 memcpy(const_cast<char*>(Buf->getBufferStart()), InputData.data(), 112 InputData.size()); 113 return Buf; 114} 115 116/// getNewUninitMemBuffer - Allocate a new MemoryBuffer of the specified size 117/// that is not initialized. Note that the caller should initialize the 118/// memory allocated by this method. The memory is owned by the MemoryBuffer 119/// object. 120MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(size_t Size, 121 StringRef BufferName) { 122 // Allocate space for the MemoryBuffer, the data and the name. It is important 123 // that MemoryBuffer and data are aligned so PointerIntPair works with them. 124 size_t AlignedStringLen = 125 RoundUpToAlignment(sizeof(MemoryBufferMem) + BufferName.size() + 1, 126 sizeof(void*)); // TODO: Is sizeof(void*) enough? 127 size_t RealLen = AlignedStringLen + Size + 1; 128 char *Mem = static_cast<char*>(operator new(RealLen, std::nothrow)); 129 if (!Mem) return 0; 130 131 // The name is stored after the class itself. 132 CopyStringRef(Mem + sizeof(MemoryBufferMem), BufferName); 133 134 // The buffer begins after the name and must be aligned. 135 char *Buf = Mem + AlignedStringLen; 136 Buf[Size] = 0; // Null terminate buffer. 137 138 return new (Mem) MemoryBufferMem(StringRef(Buf, Size), true); 139} 140 141/// getNewMemBuffer - Allocate a new MemoryBuffer of the specified size that 142/// is completely initialized to zeros. Note that the caller should 143/// initialize the memory allocated by this method. The memory is owned by 144/// the MemoryBuffer object. 145MemoryBuffer *MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) { 146 MemoryBuffer *SB = getNewUninitMemBuffer(Size, BufferName); 147 if (!SB) return 0; 148 memset(const_cast<char*>(SB->getBufferStart()), 0, Size); 149 return SB; 150} 151 152 153/// getFileOrSTDIN - Open the specified file as a MemoryBuffer, or open stdin 154/// if the Filename is "-". If an error occurs, this returns null and fills 155/// in *ErrStr with a reason. If stdin is empty, this API (unlike getSTDIN) 156/// returns an empty buffer. 157error_code MemoryBuffer::getFileOrSTDIN(StringRef Filename, 158 OwningPtr<MemoryBuffer> &result, 159 int64_t FileSize) { 160 if (Filename == "-") 161 return getSTDIN(result); 162 return getFile(Filename, result, FileSize); 163} 164 165error_code MemoryBuffer::getFileOrSTDIN(const char *Filename, 166 OwningPtr<MemoryBuffer> &result, 167 int64_t FileSize) { 168 if (strcmp(Filename, "-") == 0) 169 return getSTDIN(result); 170 return getFile(Filename, result, FileSize); 171} 172 173//===----------------------------------------------------------------------===// 174// MemoryBuffer::getFile implementation. 175//===----------------------------------------------------------------------===// 176 177namespace { 178/// MemoryBufferMMapFile - This represents a file that was mapped in with the 179/// sys::Path::MapInFilePages method. When destroyed, it calls the 180/// sys::Path::UnMapFilePages method. 181class MemoryBufferMMapFile : public MemoryBufferMem { 182public: 183 MemoryBufferMMapFile(StringRef Buffer, bool RequiresNullTerminator) 184 : MemoryBufferMem(Buffer, RequiresNullTerminator) { } 185 186 ~MemoryBufferMMapFile() { 187 static int PageSize = sys::Process::GetPageSize(); 188 189 uintptr_t Start = reinterpret_cast<uintptr_t>(getBufferStart()); 190 size_t Size = getBufferSize(); 191 uintptr_t RealStart = Start & ~(PageSize - 1); 192 size_t RealSize = Size + (Start - RealStart); 193 194 sys::Path::UnMapFilePages(reinterpret_cast<const char*>(RealStart), 195 RealSize); 196 } 197 198 virtual BufferKind getBufferKind() const { 199 return MemoryBuffer_MMap; 200 } 201}; 202} 203 204error_code MemoryBuffer::getFile(StringRef Filename, 205 OwningPtr<MemoryBuffer> &result, 206 int64_t FileSize, 207 bool RequiresNullTerminator) { 208 // Ensure the path is null terminated. 209 SmallString<256> PathBuf(Filename.begin(), Filename.end()); 210 return MemoryBuffer::getFile(PathBuf.c_str(), result, FileSize, 211 RequiresNullTerminator); 212} 213 214error_code MemoryBuffer::getFile(const char *Filename, 215 OwningPtr<MemoryBuffer> &result, 216 int64_t FileSize, 217 bool RequiresNullTerminator) { 218 // First check that the "file" is not a directory 219 bool is_dir = false; 220 error_code err = sys::fs::is_directory(Filename, is_dir); 221 if (err) 222 return err; 223 if (is_dir) 224 return make_error_code(errc::is_a_directory); 225 226 int OpenFlags = O_RDONLY; 227#ifdef O_BINARY 228 OpenFlags |= O_BINARY; // Open input file in binary mode on win32. 229#endif 230 int FD = ::open(Filename, OpenFlags); 231 if (FD == -1) 232 return error_code(errno, posix_category()); 233 234 error_code ret = getOpenFile(FD, Filename, result, FileSize, FileSize, 235 0, RequiresNullTerminator); 236 close(FD); 237 return ret; 238} 239 240static bool shouldUseMmap(int FD, 241 size_t FileSize, 242 size_t MapSize, 243 off_t Offset, 244 bool RequiresNullTerminator, 245 int PageSize) { 246 // We don't use mmap for small files because this can severely fragment our 247 // address space. 248 if (MapSize < 4096*4) 249 return false; 250 251 if (!RequiresNullTerminator) 252 return true; 253 254 255 // If we don't know the file size, use fstat to find out. fstat on an open 256 // file descriptor is cheaper than stat on a random path. 257 // FIXME: this chunk of code is duplicated, but it avoids a fstat when 258 // RequiresNullTerminator = false and MapSize != -1. 259 if (FileSize == size_t(-1)) { 260 struct stat FileInfo; 261 // TODO: This should use fstat64 when available. 262 if (fstat(FD, &FileInfo) == -1) { 263 return error_code(errno, posix_category()); 264 } 265 FileSize = FileInfo.st_size; 266 } 267 268 // If we need a null terminator and the end of the map is inside the file, 269 // we cannot use mmap. 270 size_t End = Offset + MapSize; 271 assert(End <= FileSize); 272 if (End != FileSize) 273 return false; 274 275 // Don't try to map files that are exactly a multiple of the system page size 276 // if we need a null terminator. 277 if ((FileSize & (PageSize -1)) == 0) 278 return false; 279 280 return true; 281} 282 283error_code MemoryBuffer::getOpenFile(int FD, const char *Filename, 284 OwningPtr<MemoryBuffer> &result, 285 uint64_t FileSize, uint64_t MapSize, 286 int64_t Offset, 287 bool RequiresNullTerminator) { 288 static int PageSize = sys::Process::GetPageSize(); 289 290 // Default is to map the full file. 291 if (MapSize == uint64_t(-1)) { 292 // If we don't know the file size, use fstat to find out. fstat on an open 293 // file descriptor is cheaper than stat on a random path. 294 if (FileSize == uint64_t(-1)) { 295 struct stat FileInfo; 296 // TODO: This should use fstat64 when available. 297 if (fstat(FD, &FileInfo) == -1) { 298 return error_code(errno, posix_category()); 299 } 300 FileSize = FileInfo.st_size; 301 } 302 MapSize = FileSize; 303 } 304 305 if (shouldUseMmap(FD, FileSize, MapSize, Offset, RequiresNullTerminator, 306 PageSize)) { 307 off_t RealMapOffset = Offset & ~(PageSize - 1); 308 off_t Delta = Offset - RealMapOffset; 309 size_t RealMapSize = MapSize + Delta; 310 311 if (const char *Pages = sys::Path::MapInFilePages(FD, 312 RealMapSize, 313 RealMapOffset)) { 314 result.reset(GetNamedBuffer<MemoryBufferMMapFile>( 315 StringRef(Pages + Delta, MapSize), Filename, RequiresNullTerminator)); 316 return error_code::success(); 317 } 318 } 319 320 MemoryBuffer *Buf = MemoryBuffer::getNewUninitMemBuffer(MapSize, Filename); 321 if (!Buf) { 322 // Failed to create a buffer. The only way it can fail is if 323 // new(std::nothrow) returns 0. 324 return make_error_code(errc::not_enough_memory); 325 } 326 327 OwningPtr<MemoryBuffer> SB(Buf); 328 char *BufPtr = const_cast<char*>(SB->getBufferStart()); 329 330 size_t BytesLeft = MapSize; 331#ifndef HAVE_PREAD 332 if (lseek(FD, Offset, SEEK_SET) == -1) 333 return error_code(errno, posix_category()); 334#endif 335 336 while (BytesLeft) { 337#ifdef HAVE_PREAD 338 ssize_t NumRead = ::pread(FD, BufPtr, BytesLeft, MapSize-BytesLeft+Offset); 339#else 340 ssize_t NumRead = ::read(FD, BufPtr, BytesLeft); 341#endif 342 if (NumRead == -1) { 343 if (errno == EINTR) 344 continue; 345 // Error while reading. 346 return error_code(errno, posix_category()); 347 } 348 if (NumRead == 0) { 349 assert(0 && "We got inaccurate FileSize value or fstat reported an " 350 "invalid file size."); 351 *BufPtr = '\0'; // null-terminate at the actual size. 352 break; 353 } 354 BytesLeft -= NumRead; 355 BufPtr += NumRead; 356 } 357 358 result.swap(SB); 359 return error_code::success(); 360} 361 362//===----------------------------------------------------------------------===// 363// MemoryBuffer::getSTDIN implementation. 364//===----------------------------------------------------------------------===// 365 366error_code MemoryBuffer::getSTDIN(OwningPtr<MemoryBuffer> &result) { 367 // Read in all of the data from stdin, we cannot mmap stdin. 368 // 369 // FIXME: That isn't necessarily true, we should try to mmap stdin and 370 // fallback if it fails. 371 sys::Program::ChangeStdinToBinary(); 372 373 const ssize_t ChunkSize = 4096*4; 374 SmallString<ChunkSize> Buffer; 375 ssize_t ReadBytes; 376 // Read into Buffer until we hit EOF. 377 do { 378 Buffer.reserve(Buffer.size() + ChunkSize); 379 ReadBytes = read(0, Buffer.end(), ChunkSize); 380 if (ReadBytes == -1) { 381 if (errno == EINTR) continue; 382 return error_code(errno, posix_category()); 383 } 384 Buffer.set_size(Buffer.size() + ReadBytes); 385 } while (ReadBytes != 0); 386 387 result.reset(getMemBufferCopy(Buffer, "<stdin>")); 388 return error_code::success(); 389} 390