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//===----------------------------------------------------------------------===//
9//
10// This file implements the FileManager interface.
11//
12//===----------------------------------------------------------------------===//
13//
14// TODO: This should index all interesting directories with dirent calls.
15// getdirentries ?
16// opendir/readdir_r/closedir ?
17//
18//===----------------------------------------------------------------------===//
19
20#include "clang/Basic/FileManager.h"
21#include "llvm/ADT/SmallString.h"
22#include "llvm/Support/raw_ostream.h"
23#include "llvm/System/Path.h"
24#include "llvm/Config/config.h"
25#include <map>
26#include <set>
27#include <string>
28using namespace clang;
29
30// FIXME: Enhance libsystem to support inode and other fields.
31#include <sys/stat.h>
32
33#if defined(_MSC_VER)
34#define S_ISDIR(s) (_S_IFDIR & s)
35#endif
36
37/// NON_EXISTENT_DIR - A special value distinct from null that is used to
38/// represent a dir name that doesn't exist on the disk.
39#define NON_EXISTENT_DIR reinterpret_cast<DirectoryEntry*>((intptr_t)-1)
40
41//===----------------------------------------------------------------------===//
42// Windows.
43//===----------------------------------------------------------------------===//
44
45#ifdef LLVM_ON_WIN32
46
47#define IS_DIR_SEPARATOR_CHAR(x) ((x) == '/' || (x) == '\\')
48
49namespace {
50 static std::string GetFullPath(const char *relPath) {
51 char *absPathStrPtr = _fullpath(NULL, relPath, 0);
52 assert(absPathStrPtr && "_fullpath() returned NULL!");
53
54 std::string absPath(absPathStrPtr);
55
56 free(absPathStrPtr);
57 return absPath;
58 }
59}
60
61class FileManager::UniqueDirContainer {
62 /// UniqueDirs - Cache from full path to existing directories/files.
63 ///
64 llvm::StringMap<DirectoryEntry> UniqueDirs;
65
66public:
67 DirectoryEntry &getDirectory(const char *Name, struct stat &StatBuf) {
68 std::string FullPath(GetFullPath(Name));
69 return UniqueDirs.GetOrCreateValue(
70 FullPath.c_str(),
71 FullPath.c_str() + FullPath.size()
72 ).getValue();
73 }
74
75 size_t size() { return UniqueDirs.size(); }
76};
77
78class FileManager::UniqueFileContainer {
79 /// UniqueFiles - Cache from full path to existing directories/files.
80 ///
81 llvm::StringMap<FileEntry, llvm::BumpPtrAllocator> UniqueFiles;
82
83public:
84 FileEntry &getFile(const char *Name, struct stat &StatBuf) {
85 std::string FullPath(GetFullPath(Name));
86 return UniqueFiles.GetOrCreateValue(
87 FullPath.c_str(),
88 FullPath.c_str() + FullPath.size()
89 ).getValue();
90 }
91
92 size_t size() { return UniqueFiles.size(); }
93};
94
95//===----------------------------------------------------------------------===//
96// Unix-like Systems.
97//===----------------------------------------------------------------------===//
98
99#else
100
101#define IS_DIR_SEPARATOR_CHAR(x) ((x) == '/')
102
103class FileManager::UniqueDirContainer {
104 /// UniqueDirs - Cache from ID's to existing directories/files.
105 ///
106 std::map<std::pair<dev_t, ino_t>, DirectoryEntry> UniqueDirs;
107
108public:
109 DirectoryEntry &getDirectory(const char *Name, struct stat &StatBuf) {
110 return UniqueDirs[std::make_pair(StatBuf.st_dev, StatBuf.st_ino)];
111 }
112
113 size_t size() { return UniqueDirs.size(); }
114};
115
116class FileManager::UniqueFileContainer {
117 /// UniqueFiles - Cache from ID's to existing directories/files.
118 ///
119 std::set<FileEntry> UniqueFiles;
120
121public:
122 FileEntry &getFile(const char *Name, struct stat &StatBuf) {
123 return
124 const_cast<FileEntry&>(
125 *UniqueFiles.insert(FileEntry(StatBuf.st_dev,
126 StatBuf.st_ino,
127 StatBuf.st_mode)).first);
128 }
129
130 size_t size() { return UniqueFiles.size(); }
131};
132
133#endif
134
135//===----------------------------------------------------------------------===//
136// Common logic.
137//===----------------------------------------------------------------------===//
138
139FileManager::FileManager()
140 : UniqueDirs(*new UniqueDirContainer),
141 UniqueFiles(*new UniqueFileContainer),
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;
| 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//===----------------------------------------------------------------------===//
9//
10// This file implements the FileManager interface.
11//
12//===----------------------------------------------------------------------===//
13//
14// TODO: This should index all interesting directories with dirent calls.
15// getdirentries ?
16// opendir/readdir_r/closedir ?
17//
18//===----------------------------------------------------------------------===//
19
20#include "clang/Basic/FileManager.h"
21#include "llvm/ADT/SmallString.h"
22#include "llvm/Support/raw_ostream.h"
23#include "llvm/System/Path.h"
24#include "llvm/Config/config.h"
25#include <map>
26#include <set>
27#include <string>
28using namespace clang;
29
30// FIXME: Enhance libsystem to support inode and other fields.
31#include <sys/stat.h>
32
33#if defined(_MSC_VER)
34#define S_ISDIR(s) (_S_IFDIR & s)
35#endif
36
37/// NON_EXISTENT_DIR - A special value distinct from null that is used to
38/// represent a dir name that doesn't exist on the disk.
39#define NON_EXISTENT_DIR reinterpret_cast<DirectoryEntry*>((intptr_t)-1)
40
41//===----------------------------------------------------------------------===//
42// Windows.
43//===----------------------------------------------------------------------===//
44
45#ifdef LLVM_ON_WIN32
46
47#define IS_DIR_SEPARATOR_CHAR(x) ((x) == '/' || (x) == '\\')
48
49namespace {
50 static std::string GetFullPath(const char *relPath) {
51 char *absPathStrPtr = _fullpath(NULL, relPath, 0);
52 assert(absPathStrPtr && "_fullpath() returned NULL!");
53
54 std::string absPath(absPathStrPtr);
55
56 free(absPathStrPtr);
57 return absPath;
58 }
59}
60
61class FileManager::UniqueDirContainer {
62 /// UniqueDirs - Cache from full path to existing directories/files.
63 ///
64 llvm::StringMap<DirectoryEntry> UniqueDirs;
65
66public:
67 DirectoryEntry &getDirectory(const char *Name, struct stat &StatBuf) {
68 std::string FullPath(GetFullPath(Name));
69 return UniqueDirs.GetOrCreateValue(
70 FullPath.c_str(),
71 FullPath.c_str() + FullPath.size()
72 ).getValue();
73 }
74
75 size_t size() { return UniqueDirs.size(); }
76};
77
78class FileManager::UniqueFileContainer {
79 /// UniqueFiles - Cache from full path to existing directories/files.
80 ///
81 llvm::StringMap<FileEntry, llvm::BumpPtrAllocator> UniqueFiles;
82
83public:
84 FileEntry &getFile(const char *Name, struct stat &StatBuf) {
85 std::string FullPath(GetFullPath(Name));
86 return UniqueFiles.GetOrCreateValue(
87 FullPath.c_str(),
88 FullPath.c_str() + FullPath.size()
89 ).getValue();
90 }
91
92 size_t size() { return UniqueFiles.size(); }
93};
94
95//===----------------------------------------------------------------------===//
96// Unix-like Systems.
97//===----------------------------------------------------------------------===//
98
99#else
100
101#define IS_DIR_SEPARATOR_CHAR(x) ((x) == '/')
102
103class FileManager::UniqueDirContainer {
104 /// UniqueDirs - Cache from ID's to existing directories/files.
105 ///
106 std::map<std::pair<dev_t, ino_t>, DirectoryEntry> UniqueDirs;
107
108public:
109 DirectoryEntry &getDirectory(const char *Name, struct stat &StatBuf) {
110 return UniqueDirs[std::make_pair(StatBuf.st_dev, StatBuf.st_ino)];
111 }
112
113 size_t size() { return UniqueDirs.size(); }
114};
115
116class FileManager::UniqueFileContainer {
117 /// UniqueFiles - Cache from ID's to existing directories/files.
118 ///
119 std::set<FileEntry> UniqueFiles;
120
121public:
122 FileEntry &getFile(const char *Name, struct stat &StatBuf) {
123 return
124 const_cast<FileEntry&>(
125 *UniqueFiles.insert(FileEntry(StatBuf.st_dev,
126 StatBuf.st_ino,
127 StatBuf.st_mode)).first);
128 }
129
130 size_t size() { return UniqueFiles.size(); }
131};
132
133#endif
134
135//===----------------------------------------------------------------------===//
136// Common logic.
137//===----------------------------------------------------------------------===//
138
139FileManager::FileManager()
140 : UniqueDirs(*new UniqueDirContainer),
141 UniqueFiles(*new UniqueFileContainer),
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;
|
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;
158 }
159
160 StatSysCallCache *LastCache = StatCache.get();
161 while (LastCache->getNextStatCache())
162 LastCache = LastCache->getNextStatCache();
163
164 LastCache->setNextStatCache(statCache);
165}
166
167void FileManager::removeStatCache(StatSysCallCache *statCache) {
168 if (!statCache)
169 return;
170
171 if (StatCache.get() == statCache) {
172 // This is the first stat cache.
173 StatCache.reset(StatCache->takeNextStatCache());
174 return;
175 }
176
177 // Find the stat cache in the list.
178 StatSysCallCache *PrevCache = StatCache.get();
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
| 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;
164 }
165
166 StatSysCallCache *LastCache = StatCache.get();
167 while (LastCache->getNextStatCache())
168 LastCache = LastCache->getNextStatCache();
169
170 LastCache->setNextStatCache(statCache);
171}
172
173void FileManager::removeStatCache(StatSysCallCache *statCache) {
174 if (!statCache)
175 return;
176
177 if (StatCache.get() == statCache) {
178 // This is the first stat cache.
179 StatCache.reset(StatCache->takeNextStatCache());
180 return;
181 }
182
183 // Find the stat cache in the list.
184 StatSysCallCache *PrevCache = StatCache.get();
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
|
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);
195
196 // See if there is already an entry in the map.
197 if (NamedDirEnt.getValue())
198 return NamedDirEnt.getValue() == NON_EXISTENT_DIR
199 ? 0 : NamedDirEnt.getValue();
200
201 ++NumDirCacheMisses;
202
203 // By default, initialize it to invalid.
204 NamedDirEnt.setValue(NON_EXISTENT_DIR);
205
206 // Get the null-terminated directory name as stored as the key of the
207 // DirEntries map.
208 const char *InterndDirName = NamedDirEnt.getKeyData();
209
210 // Check to see if the directory exists.
211 struct stat StatBuf;
212 if (stat_cached(InterndDirName, &StatBuf) || // Error stat'ing.
213 !S_ISDIR(StatBuf.st_mode)) // Not a directory?
214 return 0;
215
216 // It exists. See if we have already opened a directory with the same inode.
217 // This occurs when one dir is symlinked to another, for example.
218 DirectoryEntry &UDE = UniqueDirs.getDirectory(InterndDirName, StatBuf);
219
220 NamedDirEnt.setValue(&UDE);
221 if (UDE.getName()) // Already have an entry with this inode, return it.
222 return &UDE;
223
224 // Otherwise, we don't have this directory yet, add it. We use the string
225 // key from the DirEntries map as the string.
226 UDE.Name = InterndDirName;
227 return &UDE;
228}
229
230/// NON_EXISTENT_FILE - A special value distinct from null that is used to
231/// represent a filename that doesn't exist on the disk.
232#define NON_EXISTENT_FILE reinterpret_cast<FileEntry*>((intptr_t)-1)
233
234/// getFile - Lookup, cache, and verify the specified file. This returns null
235/// if the file doesn't exist.
236///
237const FileEntry *FileManager::getFile(const char *NameStart,
238 const char *NameEnd) {
239 ++NumFileLookups;
240
241 // See if there is already an entry in the map.
242 llvm::StringMapEntry<FileEntry *> &NamedFileEnt =
243 FileEntries.GetOrCreateValue(NameStart, NameEnd);
244
245 // See if there is already an entry in the map.
246 if (NamedFileEnt.getValue())
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
| 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);
225
226 // See if there is already an entry in the map.
227 if (NamedDirEnt.getValue())
228 return NamedDirEnt.getValue() == NON_EXISTENT_DIR
229 ? 0 : NamedDirEnt.getValue();
230
231 ++NumDirCacheMisses;
232
233 // By default, initialize it to invalid.
234 NamedDirEnt.setValue(NON_EXISTENT_DIR);
235
236 // Get the null-terminated directory name as stored as the key of the
237 // DirEntries map.
238 const char *InterndDirName = NamedDirEnt.getKeyData();
239
240 // Check to see if the directory exists.
241 struct stat StatBuf;
242 if (stat_cached(InterndDirName, &StatBuf) || // Error stat'ing.
243 !S_ISDIR(StatBuf.st_mode)) // Not a directory?
244 return 0;
245
246 // It exists. See if we have already opened a directory with the same inode.
247 // This occurs when one dir is symlinked to another, for example.
248 DirectoryEntry &UDE = UniqueDirs.getDirectory(InterndDirName, StatBuf);
249
250 NamedDirEnt.setValue(&UDE);
251 if (UDE.getName()) // Already have an entry with this inode, return it.
252 return &UDE;
253
254 // Otherwise, we don't have this directory yet, add it. We use the string
255 // key from the DirEntries map as the string.
256 UDE.Name = InterndDirName;
257 return &UDE;
258}
259
260/// NON_EXISTENT_FILE - A special value distinct from null that is used to
261/// represent a filename that doesn't exist on the disk.
262#define NON_EXISTENT_FILE reinterpret_cast<FileEntry*>((intptr_t)-1)
263
264/// getFile - Lookup, cache, and verify the specified file. This returns null
265/// if the file doesn't exist.
266///
267const FileEntry *FileManager::getFile(const char *NameStart,
268 const char *NameEnd) {
269 ++NumFileLookups;
270
271 // See if there is already an entry in the map.
272 llvm::StringMapEntry<FileEntry *> &NamedFileEnt =
273 FileEntries.GetOrCreateValue(NameStart, NameEnd);
274
275 // See if there is already an entry in the map.
276 if (NamedFileEnt.getValue())
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
|
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
| 285
|
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
| 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
|
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?
290 // If this file doesn't exist, we leave a null in FileEntries for this path.
291 //llvm::errs() << ": Not existing\n";
292 return 0;
293 }
294 //llvm::errs() << ": exists\n";
295
296 // It exists. See if we have already opened a file with the same inode.
297 // This occurs when one dir is symlinked to another, for example.
298 FileEntry &UFE = UniqueFiles.getFile(InterndFileName, StatBuf);
299
300 NamedFileEnt.setValue(&UFE);
301 if (UFE.getName()) // Already have an entry with this inode, return it.
302 return &UFE;
303
304 // Otherwise, we don't have this directory yet, add it.
305 // FIXME: Change the name to be a char* that points back to the 'FileEntries'
306 // key.
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
| 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?
303 // If this file doesn't exist, we leave a null in FileEntries for this path.
304 //llvm::errs() << ": Not existing\n";
305 return 0;
306 }
307 //llvm::errs() << ": exists\n";
308
309 // It exists. See if we have already opened a file with the same inode.
310 // This occurs when one dir is symlinked to another, for example.
311 FileEntry &UFE = UniqueFiles.getFile(InterndFileName, StatBuf);
312
313 NamedFileEnt.setValue(&UFE);
314 if (UFE.getName()) // Already have an entry with this inode, return it.
315 return &UFE;
316
317 // Otherwise, we don't have this directory yet, add it.
318 // FIXME: Change the name to be a char* that points back to the 'FileEntries'
319 // key.
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
|
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
| 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
|
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.
| 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())
|
339 StatCalls[path] = StatResult(result, *buf);
| 390 StatCalls[path] = StatResult(result, *buf);
|
340 }
| |
341
342 return result;
343}
| 391
392 return result;
393}
|