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> 38 using namespace llvm; 39 40 //===----------------------------------------------------------------------===// 41 // MemoryBuffer implementation itself. 42 //===----------------------------------------------------------------------===// 43 44 MemoryBuffer::~MemoryBuffer() { } 45 46 /// init - Initialize this MemoryBuffer as a reference to externally allocated 47 /// memory, memory that we know is already null terminated. 48 void 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. 62 static 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. 68 template <typename T> 69 static 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 76 namespace { 77 /// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory. 78 class MemoryBufferMem : public MemoryBuffer { 79 public: 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! 97 MemoryBuffer *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]. 107 MemoryBuffer *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. 120 MemoryBuffer *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. 145 MemoryBuffer *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. 157 error_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 165 error_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 177 namespace { 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. 181 class MemoryBufferMMapFile : public MemoryBufferMem { 182 public: 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 204 error_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 214 error_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 240 static 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 283 error_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 366 error_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
