1///===--- FileManager.cpp - File System Probing and Caching ----------------===//
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//===----------------------------------------------------------------------===//

--- 133 unchanged lines hidden (view full) ---

142 DirEntries(64), FileEntries(64), NextFileUID(0) {
143 NumDirLookups = NumFileLookups = 0;
144 NumDirCacheMisses = NumFileCacheMisses = 0;
145}
146
147FileManager::~FileManager() {
148 delete &UniqueDirs;
149 delete &UniqueFiles;
150 for (llvm::SmallVectorImpl<FileEntry *>::iterator
151 V = VirtualFileEntries.begin(),
152 VEnd = VirtualFileEntries.end();
153 V != VEnd;
154 ++V)
155 delete *V;
156}
157
158void FileManager::addStatCache(StatSysCallCache *statCache, bool AtBeginning) {
159 assert(statCache && "No stat cache provided?");
160 if (AtBeginning || StatCache.get() == 0) {
161 statCache->setNextStatCache(StatCache.take());
162 StatCache.reset(statCache);
163 return;

--- 21 unchanged lines hidden (view full) ---

185 while (PrevCache && PrevCache->getNextStatCache() != statCache)
186 PrevCache = PrevCache->getNextStatCache();
187 if (PrevCache)
188 PrevCache->setNextStatCache(statCache->getNextStatCache());
189 else
190 assert(false && "Stat cache not found for removal");
191}
192
193/// \brief Retrieve the directory that the given file name resides in.
194static const DirectoryEntry *getDirectoryFromFile(FileManager &FileMgr,
195 const char *NameStart,
196 const char *NameEnd) {
197 // Figure out what directory it is in. If the string contains a / in it,
198 // strip off everything after it.
199 // FIXME: this logic should be in sys::Path.
200 const char *SlashPos = NameEnd-1;
201 while (SlashPos >= NameStart && !IS_DIR_SEPARATOR_CHAR(SlashPos[0]))
202 --SlashPos;
203 // Ignore duplicate //'s.
204 while (SlashPos > NameStart && IS_DIR_SEPARATOR_CHAR(SlashPos[-1]))
205 --SlashPos;
206
207 if (SlashPos < NameStart) {
208 // Use the current directory if file has no path component.
209 const char *Name = ".";
210 return FileMgr.getDirectory(Name, Name+1);
211 } else if (SlashPos == NameEnd-1)
212 return 0; // If filename ends with a /, it's a directory.
213 else
214 return FileMgr.getDirectory(NameStart, SlashPos);
215}
216
217/// getDirectory - Lookup, cache, and verify the specified directory. This
218/// returns null if the directory doesn't exist.
219///
220const DirectoryEntry *FileManager::getDirectory(const char *NameStart,
221 const char *NameEnd) {
222 ++NumDirLookups;
223 llvm::StringMapEntry<DirectoryEntry *> &NamedDirEnt =
224 DirEntries.GetOrCreateValue(NameStart, NameEnd);

--- 52 unchanged lines hidden (view full) ---

277 return NamedFileEnt.getValue() == NON_EXISTENT_FILE
278 ? 0 : NamedFileEnt.getValue();
279
280 ++NumFileCacheMisses;
281
282 // By default, initialize it to invalid.
283 NamedFileEnt.setValue(NON_EXISTENT_FILE);
284
285
286 // Get the null-terminated file name as stored as the key of the
287 // FileEntries map.
288 const char *InterndFileName = NamedFileEnt.getKeyData();
289
290 const DirectoryEntry *DirInfo
291 = getDirectoryFromFile(*this, NameStart, NameEnd);
292 if (DirInfo == 0) // Directory doesn't exist, file can't exist.
293 return 0;
294
295 // FIXME: Use the directory info to prune this, before doing the stat syscall.
296 // FIXME: This will reduce the # syscalls.
297
298 // Nope, there isn't. Check to see if the file exists.
299 struct stat StatBuf;
300 //llvm::errs() << "STATING: " << Filename;
301 if (stat_cached(InterndFileName, &StatBuf) || // Error stat'ing.
302 S_ISDIR(StatBuf.st_mode)) { // A directory?

--- 17 unchanged lines hidden (view full) ---

320 UFE.Name = InterndFileName;
321 UFE.Size = StatBuf.st_size;
322 UFE.ModTime = StatBuf.st_mtime;
323 UFE.Dir = DirInfo;
324 UFE.UID = NextFileUID++;
325 return &UFE;
326}
327
328const FileEntry *
329FileManager::getVirtualFile(const llvm::StringRef &Filename,
330 off_t Size, time_t ModificationTime) {
331 const char *NameStart = Filename.begin(), *NameEnd = Filename.end();
332
333 ++NumFileLookups;
334
335 // See if there is already an entry in the map.
336 llvm::StringMapEntry<FileEntry *> &NamedFileEnt =
337 FileEntries.GetOrCreateValue(NameStart, NameEnd);
338
339 // See if there is already an entry in the map.
340 if (NamedFileEnt.getValue())
341 return NamedFileEnt.getValue() == NON_EXISTENT_FILE
342 ? 0 : NamedFileEnt.getValue();
343
344 ++NumFileCacheMisses;
345
346 // By default, initialize it to invalid.
347 NamedFileEnt.setValue(NON_EXISTENT_FILE);
348
349 const DirectoryEntry *DirInfo
350 = getDirectoryFromFile(*this, NameStart, NameEnd);
351 if (DirInfo == 0) // Directory doesn't exist, file can't exist.
352 return 0;
353
354 FileEntry *UFE = new FileEntry();
355 VirtualFileEntries.push_back(UFE);
356 NamedFileEnt.setValue(UFE);
357
358 UFE->Name = NamedFileEnt.getKeyData();
359 UFE->Size = Size;
360 UFE->ModTime = ModificationTime;
361 UFE->Dir = DirInfo;
362 UFE->UID = NextFileUID++;
363 return UFE;
364}
365
366void FileManager::PrintStats() const {
367 llvm::errs() << "\n*** File Manager Stats:\n";
368 llvm::errs() << UniqueFiles.size() << " files found, "
369 << UniqueDirs.size() << " dirs found.\n";
370 llvm::errs() << NumDirLookups << " dir lookups, "
371 << NumDirCacheMisses << " dir cache misses.\n";
372 llvm::errs() << NumFileLookups << " file lookups, "
373 << NumFileCacheMisses << " file cache misses.\n";
374
375 //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups;
376}
377
378int MemorizeStatCalls::stat(const char *path, struct stat *buf) {
379 int result = StatSysCallCache::stat(path, buf);
380
381 // Do not cache failed stats, it is easy to construct common inconsistent
382 // situations if we do, and they are not important for PCH performance (which
383 // currently only needs the stats to construct the initial FileManager
384 // entries).
385 if (result != 0)
386 return result;
387
388 // Cache file 'stat' results and directories with absolutely paths.
389 if (!S_ISDIR(buf->st_mode) || llvm::sys::Path(path).isAbsolute())
390 StatCalls[path] = StatResult(result, *buf);
391
392 return result;
393}