clang/lib/Tooling/CompilationDatabase.cpp

   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/LineIterator.h"
  41 #include "llvm/Support/MemoryBuffer.h"
  42 #include "llvm/Support/Path.h"
  43 #include "llvm/Support/raw_ostream.h"
  44 #include "llvm/TargetParser/Host.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.starts_with("-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