clang  14.0.0git
CompilationDatabase.cpp
Go to the documentation of this file.
1 //===- CompilationDatabase.cpp --------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains implementations of the CompilationDatabase base class
10 // and the FixedCompilationDatabase.
11 //
12 // FIXME: Various functions that take a string &ErrorMessage should be upgraded
13 // to Expected.
14 //
15 //===----------------------------------------------------------------------===//
16 
18 #include "clang/Basic/Diagnostic.h"
21 #include "clang/Basic/LLVM.h"
22 #include "clang/Driver/Action.h"
24 #include "clang/Driver/Driver.h"
26 #include "clang/Driver/Job.h"
29 #include "clang/Tooling/Tooling.h"
30 #include "llvm/ADT/ArrayRef.h"
31 #include "llvm/ADT/IntrusiveRefCntPtr.h"
32 #include "llvm/ADT/STLExtras.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/ADT/SmallVector.h"
35 #include "llvm/ADT/StringRef.h"
36 #include "llvm/Option/Arg.h"
37 #include "llvm/Support/Casting.h"
38 #include "llvm/Support/Compiler.h"
39 #include "llvm/Support/ErrorOr.h"
40 #include "llvm/Support/Host.h"
41 #include "llvm/Support/LineIterator.h"
42 #include "llvm/Support/MemoryBuffer.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/raw_ostream.h"
45 #include <algorithm>
46 #include <cassert>
47 #include <cstring>
48 #include <iterator>
49 #include <memory>
50 #include <sstream>
51 #include <string>
52 #include <system_error>
53 #include <utility>
54 #include <vector>
55 
56 using namespace clang;
57 using namespace tooling;
58 
59 LLVM_INSTANTIATE_REGISTRY(CompilationDatabasePluginRegistry)
60 
62 
63 std::unique_ptr<CompilationDatabase>
64 CompilationDatabase::loadFromDirectory(StringRef BuildDirectory,
65  std::string &ErrorMessage) {
66  llvm::raw_string_ostream ErrorStream(ErrorMessage);
67  for (const CompilationDatabasePluginRegistry::entry &Database :
68  CompilationDatabasePluginRegistry::entries()) {
69  std::string DatabaseErrorMessage;
70  std::unique_ptr<CompilationDatabasePlugin> Plugin(Database.instantiate());
71  if (std::unique_ptr<CompilationDatabase> DB =
72  Plugin->loadFromDirectory(BuildDirectory, DatabaseErrorMessage))
73  return DB;
74  ErrorStream << Database.getName() << ": " << DatabaseErrorMessage << "\n";
75  }
76  return nullptr;
77 }
78 
79 static std::unique_ptr<CompilationDatabase>
81  std::string &ErrorMessage) {
82  std::stringstream ErrorStream;
83  bool HasErrorMessage = false;
84  while (!Directory.empty()) {
85  std::string LoadErrorMessage;
86 
87  if (std::unique_ptr<CompilationDatabase> DB =
88  CompilationDatabase::loadFromDirectory(Directory, LoadErrorMessage))
89  return DB;
90 
91  if (!HasErrorMessage) {
92  ErrorStream << "No compilation database found in " << Directory.str()
93  << " or any parent directory\n" << LoadErrorMessage;
94  HasErrorMessage = true;
95  }
96 
97  Directory = llvm::sys::path::parent_path(Directory);
98  }
99  ErrorMessage = ErrorStream.str();
100  return nullptr;
101 }
102 
103 std::unique_ptr<CompilationDatabase>
105  std::string &ErrorMessage) {
106  SmallString<1024> AbsolutePath(getAbsolutePath(SourceFile));
107  StringRef Directory = llvm::sys::path::parent_path(AbsolutePath);
108 
109  std::unique_ptr<CompilationDatabase> DB =
110  findCompilationDatabaseFromDirectory(Directory, ErrorMessage);
111 
112  if (!DB)
113  ErrorMessage = ("Could not auto-detect compilation database for file \"" +
114  SourceFile + "\"\n" + ErrorMessage).str();
115  return DB;
116 }
117 
118 std::unique_ptr<CompilationDatabase>
120  std::string &ErrorMessage) {
121  SmallString<1024> AbsolutePath(getAbsolutePath(SourceDir));
122 
123  std::unique_ptr<CompilationDatabase> DB =
124  findCompilationDatabaseFromDirectory(AbsolutePath, ErrorMessage);
125 
126  if (!DB)
127  ErrorMessage = ("Could not auto-detect compilation database from directory \"" +
128  SourceDir + "\"\n" + ErrorMessage).str();
129  return DB;
130 }
131 
132 std::vector<CompileCommand> CompilationDatabase::getAllCompileCommands() const {
133  std::vector<CompileCommand> Result;
134  for (const auto &File : getAllFiles()) {
135  auto C = getCompileCommands(File);
136  std::move(C.begin(), C.end(), std::back_inserter(Result));
137  }
138  return Result;
139 }
140 
142 
143 namespace {
144 
145 // Helper for recursively searching through a chain of actions and collecting
146 // all inputs, direct and indirect, of compile jobs.
147 struct CompileJobAnalyzer {
149 
150  void run(const driver::Action *A) {
151  runImpl(A, false);
152  }
153 
154 private:
155  void runImpl(const driver::Action *A, bool Collect) {
156  bool CollectChildren = Collect;
157  switch (A->getKind()) {
159  CollectChildren = true;
160  break;
161 
163  if (Collect) {
164  const auto *IA = cast<driver::InputAction>(A);
165  Inputs.push_back(std::string(IA->getInputArg().getSpelling()));
166  }
167  break;
168 
169  default:
170  // Don't care about others
171  break;
172  }
173 
174  for (const driver::Action *AI : A->inputs())
175  runImpl(AI, CollectChildren);
176  }
177 };
178 
179 // Special DiagnosticConsumer that looks for warn_drv_input_file_unused
180 // diagnostics from the driver and collects the option strings for those unused
181 // options.
182 class UnusedInputDiagConsumer : public DiagnosticConsumer {
183 public:
184  UnusedInputDiagConsumer(DiagnosticConsumer &Other) : Other(Other) {}
185 
186  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
187  const Diagnostic &Info) override {
188  if (Info.getID() == diag::warn_drv_input_file_unused) {
189  // Arg 1 for this diagnostic is the option that didn't get used.
190  UnusedInputs.push_back(Info.getArgStdStr(0));
191  } else if (DiagLevel >= DiagnosticsEngine::Error) {
192  // If driver failed to create compilation object, show the diagnostics
193  // to user.
194  Other.HandleDiagnostic(DiagLevel, Info);
195  }
196  }
197 
198  DiagnosticConsumer &Other;
199  SmallVector<std::string, 2> UnusedInputs;
200 };
201 
202 // Filter of tools unused flags such as -no-integrated-as and -Wa,*.
203 // They are not used for syntax checking, and could confuse targets
204 // which don't support these options.
205 struct FilterUnusedFlags {
206  bool operator() (StringRef S) {
207  return (S == "-no-integrated-as") || S.startswith("-Wa,");
208  }
209 };
210 
211 std::string GetClangToolCommand() {
212  static int Dummy;
213  std::string ClangExecutable =
214  llvm::sys::fs::getMainExecutable("clang", (void *)&Dummy);
215  SmallString<128> ClangToolPath;
216  ClangToolPath = llvm::sys::path::parent_path(ClangExecutable);
217  llvm::sys::path::append(ClangToolPath, "clang-tool");
218  return std::string(ClangToolPath.str());
219 }
220 
221 } // namespace
222 
223 /// Strips any positional args and possible argv[0] from a command-line
224 /// provided by the user to construct a FixedCompilationDatabase.
225 ///
226 /// FixedCompilationDatabase requires a command line to be in this format as it
227 /// constructs the command line for each file by appending the name of the file
228 /// to be compiled. FixedCompilationDatabase also adds its own argv[0] to the
229 /// start of the command line although its value is not important as it's just
230 /// ignored by the Driver invoked by the ClangTool using the
231 /// FixedCompilationDatabase.
232 ///
233 /// FIXME: This functionality should probably be made available by
234 /// clang::driver::Driver although what the interface should look like is not
235 /// clear.
236 ///
237 /// \param[in] Args Args as provided by the user.
238 /// \return Resulting stripped command line.
239 /// \li true if successful.
240 /// \li false if \c Args cannot be used for compilation jobs (e.g.
241 /// contains an option like -E or -version).
242 static bool stripPositionalArgs(std::vector<const char *> Args,
243  std::vector<std::string> &Result,
244  std::string &ErrorMsg) {
246  llvm::raw_string_ostream Output(ErrorMsg);
247  TextDiagnosticPrinter DiagnosticPrinter(Output, &*DiagOpts);
248  UnusedInputDiagConsumer DiagClient(DiagnosticPrinter);
249  DiagnosticsEngine Diagnostics(
251  &*DiagOpts, &DiagClient, false);
252 
253  // The clang executable path isn't required since the jobs the driver builds
254  // will not be executed.
255  std::unique_ptr<driver::Driver> NewDriver(new driver::Driver(
256  /* ClangExecutable= */ "", llvm::sys::getDefaultTargetTriple(),
257  Diagnostics));
258  NewDriver->setCheckInputsExist(false);
259 
260  // This becomes the new argv[0]. The value is used to detect libc++ include
261  // dirs on Mac, it isn't used for other platforms.
262  std::string Argv0 = GetClangToolCommand();
263  Args.insert(Args.begin(), Argv0.c_str());
264 
265  // By adding -c, we force the driver to treat compilation as the last phase.
266  // It will then issue warnings via Diagnostics about un-used options that
267  // would have been used for linking. If the user provided a compiler name as
268  // the original argv[0], this will be treated as a linker input thanks to
269  // insertng a new argv[0] above. All un-used options get collected by
270  // UnusedInputdiagConsumer and get stripped out later.
271  Args.push_back("-c");
272 
273  // Put a dummy C++ file on to ensure there's at least one compile job for the
274  // driver to construct. If the user specified some other argument that
275  // prevents compilation, e.g. -E or something like -version, we may still end
276  // up with no jobs but then this is the user's fault.
277  Args.push_back("placeholder.cpp");
278 
279  llvm::erase_if(Args, FilterUnusedFlags());
280 
281  const std::unique_ptr<driver::Compilation> Compilation(
282  NewDriver->BuildCompilation(Args));
283  if (!Compilation)
284  return false;
285 
286  const driver::JobList &Jobs = Compilation->getJobs();
287 
288  CompileJobAnalyzer CompileAnalyzer;
289 
290  for (const auto &Cmd : Jobs) {
291  // Collect only for Assemble, Backend, and Compile jobs. If we do all jobs
292  // we get duplicates since Link jobs point to Assemble jobs as inputs.
293  // -flto* flags make the BackendJobClass, which still needs analyzer.
294  if (Cmd.getSource().getKind() == driver::Action::AssembleJobClass ||
295  Cmd.getSource().getKind() == driver::Action::BackendJobClass ||
296  Cmd.getSource().getKind() == driver::Action::CompileJobClass) {
297  CompileAnalyzer.run(&Cmd.getSource());
298  }
299  }
300 
301  if (CompileAnalyzer.Inputs.empty()) {
302  ErrorMsg = "warning: no compile jobs found\n";
303  return false;
304  }
305 
306  // Remove all compilation input files from the command line and inputs deemed
307  // unused for compilation. This is necessary so that getCompileCommands() can
308  // construct a command line for each file.
309  std::vector<const char *>::iterator End =
310  llvm::remove_if(Args, [&](StringRef S) {
311  return llvm::is_contained(CompileAnalyzer.Inputs, S) ||
312  llvm::is_contained(DiagClient.UnusedInputs, S);
313  });
314  // Remove the -c add above as well. It will be at the end right now.
315  assert(strcmp(*(End - 1), "-c") == 0);
316  --End;
317 
318  Result = std::vector<std::string>(Args.begin() + 1, End);
319  return true;
320 }
321 
322 std::unique_ptr<FixedCompilationDatabase>
324  const char *const *Argv,
325  std::string &ErrorMsg,
326  const Twine &Directory) {
327  ErrorMsg.clear();
328  if (Argc == 0)
329  return nullptr;
330  const char *const *DoubleDash = std::find(Argv, Argv + Argc, StringRef("--"));
331  if (DoubleDash == Argv + Argc)
332  return nullptr;
333  std::vector<const char *> CommandLine(DoubleDash + 1, Argv + Argc);
334  Argc = DoubleDash - Argv;
335 
336  std::vector<std::string> StrippedArgs;
337  if (!stripPositionalArgs(CommandLine, StrippedArgs, ErrorMsg))
338  return nullptr;
339  return std::make_unique<FixedCompilationDatabase>(Directory, StrippedArgs);
340 }
341 
342 std::unique_ptr<FixedCompilationDatabase>
344  ErrorMsg.clear();
345  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
346  llvm::MemoryBuffer::getFile(Path);
347  if (std::error_code Result = File.getError()) {
348  ErrorMsg = "Error while opening fixed database: " + Result.message();
349  return nullptr;
350  }
351  return loadFromBuffer(llvm::sys::path::parent_path(Path),
352  (*File)->getBuffer(), ErrorMsg);
353 }
354 
355 std::unique_ptr<FixedCompilationDatabase>
356 FixedCompilationDatabase::loadFromBuffer(StringRef Directory, StringRef Data,
357  std::string &ErrorMsg) {
358  ErrorMsg.clear();
359  std::vector<std::string> Args;
360  StringRef Line;
361  while (!Data.empty()) {
362  std::tie(Line, Data) = Data.split('\n');
363  // Stray whitespace is almost certainly unintended.
364  Line = Line.trim();
365  if (!Line.empty())
366  Args.push_back(Line.str());
367  }
368  return std::make_unique<FixedCompilationDatabase>(Directory, std::move(Args));
369 }
370 
372  const Twine &Directory, ArrayRef<std::string> CommandLine) {
373  std::vector<std::string> ToolCommandLine(1, GetClangToolCommand());
374  ToolCommandLine.insert(ToolCommandLine.end(),
375  CommandLine.begin(), CommandLine.end());
376  CompileCommands.emplace_back(Directory, StringRef(),
377  std::move(ToolCommandLine),
378  StringRef());
379 }
380 
381 std::vector<CompileCommand>
383  std::vector<CompileCommand> Result(CompileCommands);
384  Result[0].CommandLine.push_back(std::string(FilePath));
385  Result[0].Filename = std::string(FilePath);
386  return Result;
387 }
388 
389 namespace {
390 
391 class FixedCompilationDatabasePlugin : public CompilationDatabasePlugin {
392  std::unique_ptr<CompilationDatabase>
393  loadFromDirectory(StringRef Directory, std::string &ErrorMessage) override {
394  SmallString<1024> DatabasePath(Directory);
395  llvm::sys::path::append(DatabasePath, "compile_flags.txt");
396  return FixedCompilationDatabase::loadFromFile(DatabasePath, ErrorMessage);
397  }
398 };
399 
400 } // namespace
401 
402 static CompilationDatabasePluginRegistry::Add<FixedCompilationDatabasePlugin>
403 X("fixed-compilation-database", "Reads plain-text flags file");
404 
405 namespace clang {
406 namespace tooling {
407 
408 // This anchor is used to force the linker to link in the generated object file
409 // and thus register the JSONCompilationDatabasePlugin.
410 extern volatile int JSONAnchorSource;
411 static int LLVM_ATTRIBUTE_UNUSED JSONAnchorDest = JSONAnchorSource;
412 
413 } // namespace tooling
414 } // namespace clang
clang::tooling::CompilationDatabasePluginRegistry
llvm::Registry< CompilationDatabasePlugin > CompilationDatabasePluginRegistry
Definition: CompilationDatabasePluginRegistry.h:40
clang::DiagnosticsEngine::Level
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:194
clang::DeclaratorContext::File
@ File
Driver.h
clang::tooling::FixedCompilationDatabase::getCompileCommands
std::vector< CompileCommand > getCompileCommands(StringRef FilePath) const override
Returns the given compile command.
Definition: CompilationDatabase.cpp:382
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::Diagnostic::getArgStdStr
const std::string & getArgStdStr(unsigned Idx) const
Return the provided argument string specified by Idx.
Definition: Diagnostic.h:1578
clang::tooling::JSONAnchorSource
volatile int JSONAnchorSource
Definition: JSONCompilationDatabase.cpp:187
llvm::SmallVector< std::string, 2 >
clang::driver::Action
Action - Represent an abstract compilation step to perform.
Definition: Action.h:47
clang::driver::Action::getKind
ActionClass getKind() const
Definition: Action.h:142
clang::tooling::getAbsolutePath
std::string getAbsolutePath(StringRef File)
Returns the absolute path of File, by prepending it with the current directory if File is not absolut...
Definition: Tooling.cpp:261
clang::DiagnosticConsumer
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1722
clang::driver::Action::inputs
input_range inputs()
Definition: Action.h:152
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
Job.h
clang::transformer::run
Stencil run(MatchConsumer< std::string > C)
Wraps a MatchConsumer in a Stencil, so that it can be used in a Stencil.
Definition: Stencil.cpp:540
clang::driver::JobList::getJobs
const list_type & getJobs() const
Definition: Job.h:281
clang::driver::Action::AssembleJobClass
@ AssembleJobClass
Definition: Action.h:66
clang::tooling::X
static ToolExecutorPluginRegistry::Add< AllTUsToolExecutorPlugin > X("all-TUs", "Runs FrontendActions on all TUs in the compilation database. " "Tool results are stored in memory.")
DiagnosticIDs.h
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::Diagnostic
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1547
Action.h
findCompilationDatabaseFromDirectory
static std::unique_ptr< CompilationDatabase > findCompilationDatabaseFromDirectory(StringRef Directory, std::string &ErrorMessage)
Definition: CompilationDatabase.cpp:80
clang::tooling::CompilationDatabase::getCompileCommands
virtual std::vector< CompileCommand > getCompileCommands(StringRef FilePath) const =0
Returns all compile commands in which the specified file was compiled.
clang::DiagnosticConsumer::HandleDiagnostic
virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info)
Handle this diagnostic, reporting it to the user or capturing it to a log as needed.
Definition: Diagnostic.cpp:555
clang::tooling::CompilationDatabase::autoDetectFromDirectory
static std::unique_ptr< CompilationDatabase > autoDetectFromDirectory(StringRef SourceDir, std::string &ErrorMessage)
Tries to detect a compilation database location and load it.
Definition: CompilationDatabase.cpp:119
clang::tooling::CompilationDatabase::autoDetectFromSource
static std::unique_ptr< CompilationDatabase > autoDetectFromSource(StringRef SourceFile, std::string &ErrorMessage)
Tries to detect a compilation database location and load it.
Definition: CompilationDatabase.cpp:104
Diagnostic.h
DriverDiagnostic.h
clang::DiagnosticsEngine::Error
@ Error
Definition: Diagnostic.h:199
clang::driver::JobList
JobList - A sequence of jobs to perform.
Definition: Job.h:261
llvm::SmallString
Definition: LLVM.h:37
CompilationDatabasePluginRegistry.h
clang::tooling::FixedCompilationDatabase::loadFromBuffer
static std::unique_ptr< FixedCompilationDatabase > loadFromBuffer(StringRef Directory, StringRef Data, std::string &ErrorMsg)
Reads flags from the given buffer, one-per-line.
Definition: CompilationDatabase.cpp:356
clang::tooling::FixedCompilationDatabase::FixedCompilationDatabase
FixedCompilationDatabase(const Twine &Directory, ArrayRef< std::string > CommandLine)
Constructs a compilation data base from a specified directory and command line.
Definition: CompilationDatabase.cpp:371
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:68
Cmd
CompileCommand Cmd
Definition: InterpolatingCompilationDatabase.cpp:130
clang::tooling::CompilationDatabase::getAllFiles
virtual std::vector< std::string > getAllFiles() const
Returns the list of all files available in the compilation database.
Definition: CompilationDatabase.h:136
Tooling.h
clang::driver::Action::BackendJobClass
@ BackendJobClass
Definition: Action.h:65
Compilation.h
TextDiagnosticPrinter.h
stripPositionalArgs
static bool stripPositionalArgs(std::vector< const char * > Args, std::vector< std::string > &Result, std::string &ErrorMsg)
Strips any positional args and possible argv[0] from a command-line provided by the user to construct...
Definition: CompilationDatabase.cpp:242
llvm::ArrayRef< std::string >
LLVM.h
clang::DiagnosticIDs
Used for handling and querying diagnostic IDs.
Definition: DiagnosticIDs.h:166
clang::tooling::CompilationDatabase::~CompilationDatabase
virtual ~CompilationDatabase()
clang::tooling::FixedCompilationDatabase::loadFromCommandLine
static std::unique_ptr< FixedCompilationDatabase > loadFromCommandLine(int &Argc, const char *const *Argv, std::string &ErrorMsg, const Twine &Directory=".")
Creates a FixedCompilationDatabase from the arguments after "--".
Definition: CompilationDatabase.cpp:323
clang::driver::Action::CompileJobClass
@ CompileJobClass
Definition: Action.h:64
clang
Definition: CalledOnceCheck.h:17
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
clang::tooling::CompilationDatabase::loadFromDirectory
static std::unique_ptr< CompilationDatabase > loadFromDirectory(StringRef BuildDirectory, std::string &ErrorMessage)
Loads a compilation database from a build directory.
Definition: CompilationDatabase.cpp:64
clang::tooling::CompilationDatabasePlugin
Interface for compilation database plugins.
Definition: CompilationDatabasePluginRegistry.h:28
clang::tooling::CompilationDatabase::getAllCompileCommands
virtual std::vector< CompileCommand > getAllCompileCommands() const
Returns all compile commands for all the files in the compilation database.
Definition: CompilationDatabase.cpp:132
clang::TextDiagnosticPrinter
Definition: TextDiagnosticPrinter.h:27
DiagnosticOptions.h
clang::tooling::JSONAnchorDest
static int LLVM_ATTRIBUTE_UNUSED JSONAnchorDest
Definition: CompilationDatabase.cpp:411
CompilationDatabase.h
clang::Diagnostic::getID
unsigned getID() const
Definition: Diagnostic.h:1557
clang::driver::Action::InputClass
@ InputClass
Definition: Action.h:56
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:47
clang::tooling::FixedCompilationDatabase::loadFromFile
static std::unique_ptr< FixedCompilationDatabase > loadFromFile(StringRef Path, std::string &ErrorMsg)
Reads flags from the given file, one-per-line.
Definition: CompilationDatabase.cpp:343
clang::DiagnosticOptions
Options for controlling the compiler diagnostics engine.
Definition: DiagnosticOptions.h:70
clang::tooling::CompilationDatabasePlugin::~CompilationDatabasePlugin
virtual ~CompilationDatabasePlugin()