1 //===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Chris Lattner and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the MemoryBuffer interface.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Support/MemoryBuffer.h"
15 #include "llvm/System/MappedFile.h"
16 #include "llvm/System/Process.h"
23 //===----------------------------------------------------------------------===//
24 // MemoryBuffer implementation itself.
25 //===----------------------------------------------------------------------===//
27 MemoryBuffer::~MemoryBuffer() {
29 delete [] BufferStart;
32 /// initCopyOf - Initialize this source buffer with a copy of the specified
33 /// memory range. We make the copy so that we can null terminate it
35 void MemoryBuffer::initCopyOf(const char *BufStart, const char *BufEnd) {
36 size_t Size = BufEnd-BufStart;
37 BufferStart = new char[Size+1];
38 BufferEnd = BufferStart+Size;
39 memcpy(const_cast<char*>(BufferStart), BufStart, Size);
40 *const_cast<char*>(BufferEnd) = 0; // Null terminate buffer.
41 MustDeleteBuffer = false;
44 /// init - Initialize this MemoryBuffer as a reference to externally allocated
45 /// memory, memory that we know is already null terminated.
46 void MemoryBuffer::init(const char *BufStart, const char *BufEnd) {
47 assert(BufEnd[0] == 0 && "Buffer is not null terminated!");
48 BufferStart = BufStart;
50 MustDeleteBuffer = false;
53 //===----------------------------------------------------------------------===//
54 // MemoryBufferMem implementation.
55 //===----------------------------------------------------------------------===//
58 class MemoryBufferMem : public MemoryBuffer {
61 MemoryBufferMem(const char *Start, const char *End, const char *FID)
66 virtual const char *getBufferIdentifier() const {
67 return FileID.c_str();
72 /// getMemBuffer - Open the specified memory range as a MemoryBuffer. Note
73 /// that EndPtr[0] must be a null byte and be accessible!
74 MemoryBuffer *MemoryBuffer::getMemBuffer(const char *StartPtr,
76 const char *BufferName) {
77 return new MemoryBufferMem(StartPtr, EndPtr, BufferName);
80 /// getNewUninitMemBuffer - Allocate a new MemoryBuffer of the specified size
81 /// that is completely initialized to zeros. Note that the caller should
82 /// initialize the memory allocated by this method. The memory is owned by
83 /// the MemoryBuffer object.
84 MemoryBuffer *MemoryBuffer::getNewUninitMemBuffer(unsigned Size,
85 const char *BufferName) {
86 char *Buf = new char[Size+1];
88 MemoryBufferMem *SB = new MemoryBufferMem(Buf, Buf+Size, BufferName);
89 // The memory for this buffer is owned by the MemoryBuffer.
90 SB->MustDeleteBuffer = true;
94 /// getNewMemBuffer - Allocate a new MemoryBuffer of the specified size that
95 /// is completely initialized to zeros. Note that the caller should
96 /// initialize the memory allocated by this method. The memory is owned by
97 /// the MemoryBuffer object.
98 MemoryBuffer *MemoryBuffer::getNewMemBuffer(unsigned Size,
99 const char *BufferName) {
100 MemoryBuffer *SB = getNewUninitMemBuffer(Size, BufferName);
101 memset(const_cast<char*>(SB->getBufferStart()), 0, Size+1);
106 //===----------------------------------------------------------------------===//
107 // MemoryBufferMMapFile implementation.
108 //===----------------------------------------------------------------------===//
111 class MemoryBufferMMapFile : public MemoryBuffer {
112 sys::MappedFile File;
114 MemoryBufferMMapFile() {}
116 bool open(const sys::Path &Filename);
118 virtual const char *getBufferIdentifier() const {
119 return File.path().c_str();
122 ~MemoryBufferMMapFile();
126 bool MemoryBufferMMapFile::open(const sys::Path &Filename) {
127 // FIXME: This does an extra stat syscall to figure out the size, but we
128 // already know the size!
129 bool Failure = File.open(Filename);
130 if (Failure) return true;
134 size_t Size = File.size();
136 static unsigned PageSize = sys::Process::GetPageSize();
137 assert(((PageSize & (PageSize-1)) == 0) && PageSize &&
138 "Page size is not a power of 2!");
140 // If this file is not an exact multiple of the system page size (common
141 // case), then the OS has zero terminated the buffer for us.
142 if ((Size & (PageSize-1))) {
143 init(File.charBase(), File.charBase()+Size);
145 // Otherwise, we allocate a new memory buffer and copy the data over
146 initCopyOf(File.charBase(), File.charBase()+Size);
148 // No need to keep the file mapped any longer.
154 MemoryBufferMMapFile::~MemoryBufferMMapFile() {
159 //===----------------------------------------------------------------------===//
160 // MemoryBuffer::getFile implementation.
161 //===----------------------------------------------------------------------===//
163 MemoryBuffer *MemoryBuffer::getFile(const char *FilenameStart, unsigned FnSize,
165 sys::PathWithStatus P(FilenameStart, FnSize);
167 MemoryBufferMMapFile *M = new MemoryBufferMMapFile();
173 // FIXME: We need an efficient and portable method to open a file and then use
174 // 'read' to copy the bits out. The unix implementation is below. This is
175 // an important optimization for clients that want to open large numbers of
176 // small files (using mmap on everything can easily exhaust address space!).
178 // If the user didn't specify a filesize, do a stat to find it.
179 if (FileSize == -1) {
180 const sys::FileStatus *FS = P.getFileStatus();
181 if (FS == 0) return 0; // Error stat'ing file.
183 FileSize = FS->fileSize;
186 // If the file is larger than some threshold, use mmap, otherwise use 'read'.
187 if (FileSize >= 4096*4) {
188 MemoryBufferMMapFile *M = new MemoryBufferMMapFile();
195 MemoryBuffer *SB = getNewUninitMemBuffer(FileSize, FilenameStart);
196 char *BufPtr = const_cast<char*>(SB->getBufferStart());
198 int FD = ::open(FilenameStart, O_RDONLY);
204 unsigned BytesLeft = FileSize;
206 ssize_t NumRead = ::read(FD, BufPtr, BytesLeft);
208 BytesLeft -= NumRead;
210 } else if (errno == EINTR) {
226 //===----------------------------------------------------------------------===//
227 // MemoryBuffer::getSTDIN implementation.
228 //===----------------------------------------------------------------------===//
231 class STDINBufferFile : public MemoryBuffer {
233 virtual const char *getBufferIdentifier() const {
239 MemoryBuffer *MemoryBuffer::getSTDIN() {
242 std::vector<char> FileData;
244 // Read in all of the data from stdin, we cannot mmap stdin.
245 while (size_t ReadBytes = fread(Buffer, 1, 4096*4, stdin))
246 FileData.insert(FileData.end(), Buffer, Buffer+ReadBytes);
248 size_t Size = FileData.size();
249 MemoryBuffer *B = new STDINBufferFile();
250 B->initCopyOf(&FileData[0], &FileData[Size]);