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}
151
152void FileManager::addStatCache(StatSysCallCache *statCache, bool AtBeginning) {
153 assert(statCache && "No stat cache provided?");
154 if (AtBeginning || StatCache.get() == 0) {
155 statCache->setNextStatCache(StatCache.take());
156 StatCache.reset(statCache);
157 return;

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

179 while (PrevCache && PrevCache->getNextStatCache() != statCache)
180 PrevCache = PrevCache->getNextStatCache();
181 if (PrevCache)
182 PrevCache->setNextStatCache(statCache->getNextStatCache());
183 else
184 assert(false && "Stat cache not found for removal");
185}
186
187/// getDirectory - Lookup, cache, and verify the specified directory. This
188/// returns null if the directory doesn't exist.
189///
190const DirectoryEntry *FileManager::getDirectory(const char *NameStart,
191 const char *NameEnd) {
192 ++NumDirLookups;
193 llvm::StringMapEntry<DirectoryEntry *> &NamedDirEnt =
194 DirEntries.GetOrCreateValue(NameStart, NameEnd);

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

247 return NamedFileEnt.getValue() == NON_EXISTENT_FILE
248 ? 0 : NamedFileEnt.getValue();
249
250 ++NumFileCacheMisses;
251
252 // By default, initialize it to invalid.
253 NamedFileEnt.setValue(NON_EXISTENT_FILE);
254
255 // Figure out what directory it is in. If the string contains a / in it,
256 // strip off everything after it.
257 // FIXME: this logic should be in sys::Path.
258 const char *SlashPos = NameEnd-1;
259 while (SlashPos >= NameStart && !IS_DIR_SEPARATOR_CHAR(SlashPos[0]))
260 --SlashPos;
261 // Ignore duplicate //'s.
262 while (SlashPos > NameStart && IS_DIR_SEPARATOR_CHAR(SlashPos[-1]))
263 --SlashPos;
264
265 const DirectoryEntry *DirInfo;
266 if (SlashPos < NameStart) {
267 // Use the current directory if file has no path component.
268 const char *Name = ".";
269 DirInfo = getDirectory(Name, Name+1);
270 } else if (SlashPos == NameEnd-1)
271 return 0; // If filename ends with a /, it's a directory.
272 else
273 DirInfo = getDirectory(NameStart, SlashPos);
274
275 if (DirInfo == 0) // Directory doesn't exist, file can't exist.
276 return 0;
277
278 // Get the null-terminated file name as stored as the key of the
279 // FileEntries map.
280 const char *InterndFileName = NamedFileEnt.getKeyData();
281
282 // FIXME: Use the directory info to prune this, before doing the stat syscall.
283 // FIXME: This will reduce the # syscalls.
284
285 // Nope, there isn't. Check to see if the file exists.
286 struct stat StatBuf;
287 //llvm::errs() << "STATING: " << Filename;
288 if (stat_cached(InterndFileName, &StatBuf) || // Error stat'ing.
289 S_ISDIR(StatBuf.st_mode)) { // A directory?

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

307 UFE.Name = InterndFileName;
308 UFE.Size = StatBuf.st_size;
309 UFE.ModTime = StatBuf.st_mtime;
310 UFE.Dir = DirInfo;
311 UFE.UID = NextFileUID++;
312 return &UFE;
313}
314
315void FileManager::PrintStats() const {
316 llvm::errs() << "\n*** File Manager Stats:\n";
317 llvm::errs() << UniqueFiles.size() << " files found, "
318 << UniqueDirs.size() << " dirs found.\n";
319 llvm::errs() << NumDirLookups << " dir lookups, "
320 << NumDirCacheMisses << " dir cache misses.\n";
321 llvm::errs() << NumFileLookups << " file lookups, "
322 << NumFileCacheMisses << " file cache misses.\n";
323
324 //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups;
325}
326
327int MemorizeStatCalls::stat(const char *path, struct stat *buf) {
328 int result = StatSysCallCache::stat(path, buf);
329
330 if (result != 0) {
331 // Cache failed 'stat' results.
332 struct stat empty;
333 memset(&empty, 0, sizeof(empty));
334 StatCalls[path] = StatResult(result, empty);
335 }
336 else if (!S_ISDIR(buf->st_mode) || llvm::sys::Path(path).isAbsolute()) {
337 // Cache file 'stat' results and directories with absolutely
338 // paths.
339 StatCalls[path] = StatResult(result, *buf);
340 }
341
342 return result;
343}