Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Basic/FileSystemStatCache.h
Line
Count
Source (jump to first uncovered line)
1
//===- FileSystemStatCache.h - Caching for 'stat' calls ---------*- C++ -*-===//
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
/// \file
11
/// Defines the FileSystemStatCache interface.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_BASIC_FILESYSTEMSTATCACHE_H
16
#define LLVM_CLANG_BASIC_FILESYSTEMSTATCACHE_H
17
18
#include "clang/Basic/LLVM.h"
19
#include "llvm/ADT/StringMap.h"
20
#include "llvm/ADT/StringRef.h"
21
#include "llvm/Support/Allocator.h"
22
#include "llvm/Support/FileSystem.h"
23
#include <cstdint>
24
#include <ctime>
25
#include <memory>
26
#include <string>
27
#include <utility>
28
29
namespace llvm {
30
31
namespace vfs {
32
33
class File;
34
class FileSystem;
35
36
} // namespace vfs
37
} // namespace llvm
38
39
namespace clang {
40
41
// FIXME: should probably replace this with vfs::Status
42
struct FileData {
43
  std::string Name;
44
  uint64_t Size = 0;
45
  time_t ModTime = 0;
46
  llvm::sys::fs::UniqueID UniqueID;
47
  bool IsDirectory = false;
48
  bool IsNamedPipe = false;
49
  bool InPCH = false;
50
51
  // FIXME: remove this when files support multiple names
52
  bool IsVFSMapped = false;
53
54
1.12M
  FileData() = default;
55
};
56
57
/// Abstract interface for introducing a FileManager cache for 'stat'
58
/// system calls, which is used by precompiled and pretokenized headers to
59
/// improve performance.
60
class FileSystemStatCache {
61
  virtual void anchor();
62
63
protected:
64
  std::unique_ptr<FileSystemStatCache> NextStatCache;
65
66
public:
67
19
  virtual ~FileSystemStatCache() = default;
68
69
  enum LookupResult {
70
    /// We know the file exists and its cached stat data.
71
    CacheExists,
72
73
    /// We know that the file doesn't exist.
74
    CacheMissing
75
  };
76
77
  /// Get the 'stat' information for the specified path, using the cache
78
  /// to accelerate it if possible.
79
  ///
80
  /// \returns \c true if the path does not exist or \c false if it exists.
81
  ///
82
  /// If isFile is true, then this lookup should only return success for files
83
  /// (not directories).  If it is false this lookup should only return
84
  /// success for directories (not files).  On a successful file lookup, the
85
  /// implementation can optionally fill in \p F with a valid \p File object and
86
  /// the client guarantees that it will close it.
87
  static bool get(StringRef Path, FileData &Data, bool isFile,
88
                  std::unique_ptr<llvm::vfs::File> *F,
89
                  FileSystemStatCache *Cache, llvm::vfs::FileSystem &FS);
90
91
  /// Sets the next stat call cache in the chain of stat caches.
92
  /// Takes ownership of the given stat cache.
93
20
  void setNextStatCache(std::unique_ptr<FileSystemStatCache> Cache) {
94
20
    NextStatCache = std::move(Cache);
95
20
  }
96
97
  /// Retrieve the next stat call cache in the chain.
98
15
  FileSystemStatCache *getNextStatCache() { return NextStatCache.get(); }
99
100
  /// Retrieve the next stat call cache in the chain, transferring
101
  /// ownership of this cache (and, transitively, all of the remaining caches)
102
  /// to the caller.
103
6
  std::unique_ptr<FileSystemStatCache> takeNextStatCache() {
104
6
    return std::move(NextStatCache);
105
6
  }
106
107
protected:
108
  // FIXME: The pointer here is a non-owning/optional reference to the
109
  // unique_ptr. Optional<unique_ptr<vfs::File>&> might be nicer, but
110
  // Optional needs some work to support references so this isn't possible yet.
111
  virtual LookupResult getStat(StringRef Path, FileData &Data, bool isFile,
112
                               std::unique_ptr<llvm::vfs::File> *F,
113
                               llvm::vfs::FileSystem &FS) = 0;
114
115
  LookupResult statChained(StringRef Path, FileData &Data, bool isFile,
116
                           std::unique_ptr<llvm::vfs::File> *F,
117
10
                           llvm::vfs::FileSystem &FS) {
118
10
    if (FileSystemStatCache *Next = getNextStatCache())
119
0
      return Next->getStat(Path, Data, isFile, F, FS);
120
10
121
10
    // If we hit the end of the list of stat caches to try, just compute and
122
10
    // return it without a cache.
123
10
    return get(Path, Data, isFile, F, nullptr, FS) ? 
CacheMissing0
: CacheExists;
124
10
  }
125
};
126
127
/// A stat "cache" that can be used by FileManager to keep
128
/// track of the results of stat() calls that occur throughout the
129
/// execution of the front end.
130
class MemorizeStatCalls : public FileSystemStatCache {
131
public:
132
  /// The set of stat() calls that have been seen.
133
  llvm::StringMap<FileData, llvm::BumpPtrAllocator> StatCalls;
134
135
  using iterator =
136
      llvm::StringMap<FileData, llvm::BumpPtrAllocator>::const_iterator;
137
138
0
  iterator begin() const { return StatCalls.begin(); }
139
0
  iterator end() const { return StatCalls.end(); }
140
141
  LookupResult getStat(StringRef Path, FileData &Data, bool isFile,
142
                       std::unique_ptr<llvm::vfs::File> *F,
143
                       llvm::vfs::FileSystem &FS) override;
144
};
145
146
} // namespace clang
147
148
#endif // LLVM_CLANG_BASIC_FILESYSTEMSTATCACHE_H