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 
17 #include "clang/Tooling/CompilationDatabase.h"
18 #include "clang/Basic/Diagnostic.h"
19 #include "clang/Basic/DiagnosticIDs.h"
20 #include "clang/Basic/DiagnosticOptions.h"
21 #include "clang/Basic/LLVM.h"
22 #include "clang/Driver/Action.h"
23 #include "clang/Driver/Compilation.h"
24 #include "clang/Driver/Driver.h"
25 #include "clang/Driver/DriverDiagnostic.h"
26 #include "clang/Driver/Job.h"
27 #include "clang/Frontend/TextDiagnosticPrinter.h"
28 #include "clang/Tooling/CompilationDatabasePluginRegistry.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 
61 CompilationDatabase::~CompilationDatabase() = default;
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>
80 findCompilationDatabaseFromDirectory(StringRef Directory,
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>
104 CompilationDatabase::autoDetectFromSource(StringRef SourceFile,
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>
119 CompilationDatabase::autoDetectFromDirectory(StringRef SourceDir,
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 
141 CompilationDatabasePlugin::~CompilationDatabasePlugin() = default;
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 {
148   SmallVector<std::string, 2> Inputs;
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()) {
158     case driver::Action::CompileJobClass:
159       CollectChildren = true;
160       break;
161 
162     case driver::Action::InputClass:
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) {
245   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
246   llvm::raw_string_ostream Output(ErrorMsg);
247   TextDiagnosticPrinter DiagnosticPrinter(Output, &*DiagOpts);
248   UnusedInputDiagConsumer DiagClient(DiagnosticPrinter);
249   DiagnosticsEngine Diagnostics(
250       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
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>
323 FixedCompilationDatabase::loadFromCommandLine(int &Argc,
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>
343 FixedCompilationDatabase::loadFromFile(StringRef Path, std::string &ErrorMsg) {
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 
371 FixedCompilationDatabase::FixedCompilationDatabase(
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>
382 FixedCompilationDatabase::getCompileCommands(StringRef FilePath) const {
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
415