clang-tools  7.0.0
GlobalCompilationDatabase.cpp
Go to the documentation of this file.
1 //===--- GlobalCompilationDatabase.cpp --------------------------*- 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 
11 #include "Logger.h"
12 #include "clang/Tooling/CompilationDatabase.h"
13 #include "llvm/Support/FileSystem.h"
14 #include "llvm/Support/Path.h"
15 
16 namespace clang {
17 namespace clangd {
18 
19 tooling::CompileCommand
21  std::vector<std::string> Argv = {"clang"};
22  // Clang treats .h files as C by default, resulting in unhelpful diagnostics.
23  // Parsing as Objective C++ is friendly to more cases.
24  if (llvm::sys::path::extension(File) == ".h")
25  Argv.push_back("-xobjective-c++-header");
26  Argv.push_back(File);
27  return tooling::CompileCommand(llvm::sys::path::parent_path(File),
28  llvm::sys::path::filename(File),
29  std::move(Argv),
30  /*Output=*/"");
31 }
32 
35  llvm::Optional<Path> CompileCommandsDir)
36  : CompileCommandsDir(std::move(CompileCommandsDir)) {}
37 
40 
41 llvm::Optional<tooling::CompileCommand>
43  if (auto CDB = getCDBForFile(File)) {
44  auto Candidates = CDB->getCompileCommands(File);
45  if (!Candidates.empty()) {
46  addExtraFlags(File, Candidates.front());
47  return std::move(Candidates.front());
48  }
49  } else {
50  log("Failed to find compilation database for {0}", File);
51  }
52  return llvm::None;
53 }
54 
55 tooling::CompileCommand
57  PathRef File) const {
59  addExtraFlags(File, C);
60  return C;
61 }
62 
64  std::lock_guard<std::mutex> Lock(Mutex);
65  CompileCommandsDir = P;
66  CompilationDatabases.clear();
67 }
68 
70  PathRef File, std::vector<std::string> ExtraFlags) {
71  std::lock_guard<std::mutex> Lock(Mutex);
72  ExtraFlagsForFile[File] = std::move(ExtraFlags);
73 }
74 
75 void DirectoryBasedGlobalCompilationDatabase::addExtraFlags(
76  PathRef File, tooling::CompileCommand &C) const {
77  std::lock_guard<std::mutex> Lock(Mutex);
78 
79  auto It = ExtraFlagsForFile.find(File);
80  if (It == ExtraFlagsForFile.end())
81  return;
82 
83  auto &Args = C.CommandLine;
84  assert(Args.size() >= 2 && "Expected at least [compiler, source file]");
85  // The last argument of CommandLine is the name of the input file.
86  // Add ExtraFlags before it.
87  Args.insert(Args.end() - 1, It->second.begin(), It->second.end());
88 }
89 
90 tooling::CompilationDatabase *
91 DirectoryBasedGlobalCompilationDatabase::getCDBInDirLocked(PathRef Dir) const {
92  // FIXME(ibiryukov): Invalidate cached compilation databases on changes
93  auto CachedIt = CompilationDatabases.find(Dir);
94  if (CachedIt != CompilationDatabases.end())
95  return CachedIt->second.get();
96  std::string Error = "";
97  auto CDB = tooling::CompilationDatabase::loadFromDirectory(Dir, Error);
98  if (CDB)
99  CDB = tooling::inferMissingCompileCommands(std::move(CDB));
100  auto Result = CDB.get();
101  CompilationDatabases.insert(std::make_pair(Dir, std::move(CDB)));
102  return Result;
103 }
104 
105 tooling::CompilationDatabase *
106 DirectoryBasedGlobalCompilationDatabase::getCDBForFile(PathRef File) const {
107  namespace path = llvm::sys::path;
108  assert((path::is_absolute(File, path::Style::posix) ||
109  path::is_absolute(File, path::Style::windows)) &&
110  "path must be absolute");
111 
112  std::lock_guard<std::mutex> Lock(Mutex);
113  if (CompileCommandsDir)
114  return getCDBInDirLocked(*CompileCommandsDir);
115  for (auto Path = path::parent_path(File); !Path.empty();
116  Path = path::parent_path(Path))
117  if (auto CDB = getCDBInDirLocked(Path))
118  return CDB;
119  return nullptr;
120 }
121 
123  const GlobalCompilationDatabase &InnerCDB)
124  : InnerCDB(InnerCDB) {}
125 
126 llvm::Optional<tooling::CompileCommand>
128  std::unique_lock<std::mutex> Lock(Mut);
129  auto It = Cached.find(File);
130  if (It != Cached.end())
131  return It->second;
132 
133  Lock.unlock();
134  llvm::Optional<tooling::CompileCommand> Command =
135  InnerCDB.getCompileCommand(File);
136  Lock.lock();
137  return Cached.try_emplace(File, std::move(Command)).first->getValue();
138 }
139 
140 tooling::CompileCommand
142  return InnerCDB.getFallbackCommand(File);
143 }
144 
146  std::unique_lock<std::mutex> Lock(Mut);
147  Cached.erase(File);
148 }
149 
151  std::unique_lock<std::mutex> Lock(Mut);
152  Cached.clear();
153 }
154 
155 } // namespace clangd
156 } // namespace clang
void invalidate(PathRef File)
Removes an entry for File if it&#39;s present in the cache.
CachingCompilationDb(const GlobalCompilationDatabase &InnerCDB)
void setExtraFlagsForFile(PathRef File, std::vector< std::string > ExtraFlags)
Sets the extra flags that should be added to a file.
virtual llvm::Optional< tooling::CompileCommand > getCompileCommand(PathRef File) const =0
If there are any known-good commands for building this file, returns one.
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:24
Documents should not be synced at all.
llvm::Optional< tooling::CompileCommand > getCompileCommand(PathRef File) const override
Gets compile command for File from cache or CDB if it&#39;s not in the cache.
Provides compilation arguments used for parsing C and C++ files.
void setCompileCommandsDir(Path P)
Set the compile commands directory to P.
void log(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:62
std::string Path
A typedef to represent a file path.
Definition: Path.h:21
tooling::CompileCommand getFallbackCommand(PathRef File) const override
Uses the default fallback command, adding any extra flags.
static llvm::cl::opt< Path > CompileCommandsDir("compile-commands-dir", llvm::cl::desc("Specify a path to look for compile_commands.json. If path " "is invalid, clangd will look in the current directory and " "parent paths of each source file."))
DirectoryBasedGlobalCompilationDatabase(llvm::Optional< Path > CompileCommandsDir)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
tooling::CompileCommand getFallbackCommand(PathRef File) const override
Forwards to the inner CDB. Results of this function are not cached.
void clear()
Removes all cached compile commands.
llvm::Optional< tooling::CompileCommand > getCompileCommand(PathRef File) const override
Scans File&#39;s parents looking for compilation databases.
virtual tooling::CompileCommand getFallbackCommand(PathRef File) const
Makes a guess at how to build a file.