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     case driver::Action::PrecompileJobClass:
 160       CollectChildren = true;
 161       break;
 162
 163     case driver::Action::InputClass:
 164       if (Collect) {
 165         const auto *IA = cast<driver::InputAction>(A);
 166         Inputs.push_back(std::string(IA->getInputArg().getSpelling()));
 167       }
 168       break;
 169
 170     default:
 171       // Don't care about others
 172       break;
 173     }
 174
 175     for (const driver::Action *AI : A->inputs())
 176       runImpl(AI, CollectChildren);
 177   }
 178 };
 179
 180 // Special DiagnosticConsumer that looks for warn_drv_input_file_unused
 181 // diagnostics from the driver and collects the option strings for those unused
 182 // options.
 183 class UnusedInputDiagConsumer : public DiagnosticConsumer {
 184 public:
 185   UnusedInputDiagConsumer(DiagnosticConsumer &Other) : Other(Other) {}
 186
 187   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
 188                         const Diagnostic &Info) override {
 189     if (Info.getID() == diag::warn_drv_input_file_unused) {
 190       // Arg 1 for this diagnostic is the option that didn't get used.
 191       UnusedInputs.push_back(Info.getArgStdStr(0));
 192     } else if (DiagLevel >= DiagnosticsEngine::Error) {
 193       // If driver failed to create compilation object, show the diagnostics
 194       // to user.
 195       Other.HandleDiagnostic(DiagLevel, Info);
 196     }
 197   }
 198
 199   DiagnosticConsumer &Other;
 200   SmallVector<std::string, 2> UnusedInputs;
 201 };
 202
 203 // Filter of tools unused flags such as -no-integrated-as and -Wa,*.
 204 // They are not used for syntax checking, and could confuse targets
 205 // which don't support these options.
 206 struct FilterUnusedFlags {
 207   bool operator() (StringRef S) {
 208     return (S == "-no-integrated-as") || S.starts_with("-Wa,");
 209   }
 210 };
 211
 212 std::string GetClangToolCommand() {
 213   static int Dummy;
 214   std::string ClangExecutable =
 215       llvm::sys::fs::getMainExecutable("clang", (void *)&Dummy);
 216   SmallString<128> ClangToolPath;
 217   ClangToolPath = llvm::sys::path::parent_path(ClangExecutable);
 218   llvm::sys::path::append(ClangToolPath, "clang-tool");
 219   return std::string(ClangToolPath);
 220 }
 221
 222 } // namespace
 223
 224 /// Strips any positional args and possible argv[0] from a command-line
 225 /// provided by the user to construct a FixedCompilationDatabase.
 226 ///
 227 /// FixedCompilationDatabase requires a command line to be in this format as it
 228 /// constructs the command line for each file by appending the name of the file
 229 /// to be compiled. FixedCompilationDatabase also adds its own argv[0] to the
 230 /// start of the command line although its value is not important as it's just
 231 /// ignored by the Driver invoked by the ClangTool using the
 232 /// FixedCompilationDatabase.
 233 ///
 234 /// FIXME: This functionality should probably be made available by
 235 /// clang::driver::Driver although what the interface should look like is not
 236 /// clear.
 237 ///
 238 /// \param[in] Args Args as provided by the user.
 239 /// \return Resulting stripped command line.
 240 ///          \li true if successful.
 241 ///          \li false if \c Args cannot be used for compilation jobs (e.g.
 242 ///          contains an option like -E or -version).
 243 static bool stripPositionalArgs(std::vector<const char *> Args,
 244                                 std::vector<std::string> &Result,
 245                                 std::string &ErrorMsg) {
 246   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 247   llvm::raw_string_ostream Output(ErrorMsg);
 248   TextDiagnosticPrinter DiagnosticPrinter(Output, &*DiagOpts);
 249   UnusedInputDiagConsumer DiagClient(DiagnosticPrinter);
 250   DiagnosticsEngine Diagnostics(
 251       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
 252       &*DiagOpts, &DiagClient, false);
 253
 254   // The clang executable path isn't required since the jobs the driver builds
 255   // will not be executed.
 256   std::unique_ptr<driver::Driver> NewDriver(new driver::Driver(
 257       /* ClangExecutable= */ "", llvm::sys::getDefaultTargetTriple(),
 258       Diagnostics));
 259   NewDriver->setCheckInputsExist(false);
 260
 261   // This becomes the new argv[0]. The value is used to detect libc++ include
 262   // dirs on Mac, it isn't used for other platforms.
 263   std::string Argv0 = GetClangToolCommand();
 264   Args.insert(Args.begin(), Argv0.c_str());
 265
 266   // By adding -c, we force the driver to treat compilation as the last phase.
 267   // It will then issue warnings via Diagnostics about un-used options that
 268   // would have been used for linking. If the user provided a compiler name as
 269   // the original argv[0], this will be treated as a linker input thanks to
 270   // insertng a new argv[0] above. All un-used options get collected by
 271   // UnusedInputdiagConsumer and get stripped out later.
 272   Args.push_back("-c");
 273
 274   // Put a dummy C++ file on to ensure there's at least one compile job for the
 275   // driver to construct. If the user specified some other argument that
 276   // prevents compilation, e.g. -E or something like -version, we may still end
 277   // up with no jobs but then this is the user's fault.
 278   Args.push_back("placeholder.cpp");
 279
 280   llvm::erase_if(Args, FilterUnusedFlags());
 281
 282   const std::unique_ptr<driver::Compilation> Compilation(
 283       NewDriver->BuildCompilation(Args));
 284   if (!Compilation)
 285     return false;
 286
 287   const driver::JobList &Jobs = Compilation->getJobs();
 288
 289   CompileJobAnalyzer CompileAnalyzer;
 290
 291   for (const auto &Cmd : Jobs) {
 292     // Collect only for Assemble, Backend, and Compile jobs. If we do all jobs
 293     // we get duplicates since Link jobs point to Assemble jobs as inputs.
 294     // -flto* flags make the BackendJobClass, which still needs analyzer.
 295     if (Cmd.getSource().getKind() == driver::Action::AssembleJobClass ||
 296         Cmd.getSource().getKind() == driver::Action::BackendJobClass ||
 297         Cmd.getSource().getKind() == driver::Action::CompileJobClass ||
 298         Cmd.getSource().getKind() == driver::Action::PrecompileJobClass) {
 299       CompileAnalyzer.run(&Cmd.getSource());
 300     }
 301   }
 302
 303   if (CompileAnalyzer.Inputs.empty()) {
 304     ErrorMsg = "warning: no compile jobs found\n";
 305     return false;
 306   }
 307
 308   // Remove all compilation input files from the command line and inputs deemed
 309   // unused for compilation. This is necessary so that getCompileCommands() can
 310   // construct a command line for each file.
 311   std::vector<const char *>::iterator End =
 312       llvm::remove_if(Args, [&](StringRef S) {
 313         return llvm::is_contained(CompileAnalyzer.Inputs, S) ||
 314                llvm::is_contained(DiagClient.UnusedInputs, S);
 315       });
 316   // Remove the -c add above as well. It will be at the end right now.
 317   assert(strcmp(*(End - 1), "-c") == 0);
 318   --End;
 319
 320   Result = std::vector<std::string>(Args.begin() + 1, End);
 321   return true;
 322 }
 323
 324 std::unique_ptr<FixedCompilationDatabase>
 325 FixedCompilationDatabase::loadFromCommandLine(int &Argc,
 326                                               const char *const *Argv,
 327                                               std::string &ErrorMsg,
 328                                               const Twine &Directory) {
 329   ErrorMsg.clear();
 330   if (Argc == 0)
 331     return nullptr;
 332   const char *const *DoubleDash = std::find(Argv, Argv + Argc, StringRef("--"));
 333   if (DoubleDash == Argv + Argc)
 334     return nullptr;
 335   std::vector<const char *> CommandLine(DoubleDash + 1, Argv + Argc);
 336   Argc = DoubleDash - Argv;
 337
 338   std::vector<std::string> StrippedArgs;
 339   if (!stripPositionalArgs(CommandLine, StrippedArgs, ErrorMsg))
 340     return nullptr;
 341   return std::make_unique<FixedCompilationDatabase>(Directory, StrippedArgs);
 342 }
 343
 344 std::unique_ptr<FixedCompilationDatabase>
 345 FixedCompilationDatabase::loadFromFile(StringRef Path, std::string &ErrorMsg) {
 346   ErrorMsg.clear();
 347   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
 348       llvm::MemoryBuffer::getFile(Path);
 349   if (std::error_code Result = File.getError()) {
 350     ErrorMsg = "Error while opening fixed database: " + Result.message();
 351     return nullptr;
 352   }
 353   return loadFromBuffer(llvm::sys::path::parent_path(Path),
 354                         (*File)->getBuffer(), ErrorMsg);
 355 }
 356
 357 std::unique_ptr<FixedCompilationDatabase>
 358 FixedCompilationDatabase::loadFromBuffer(StringRef Directory, StringRef Data,
 359                                          std::string &ErrorMsg) {
 360   ErrorMsg.clear();
 361   std::vector<std::string> Args;
 362   StringRef Line;
 363   while (!Data.empty()) {
 364     std::tie(Line, Data) = Data.split('\n');
 365     // Stray whitespace is almost certainly unintended.
 366     Line = Line.trim();
 367     if (!Line.empty())
 368       Args.push_back(Line.str());
 369   }
 370   return std::make_unique<FixedCompilationDatabase>(Directory, std::move(Args));
 371 }
 372
 373 FixedCompilationDatabase::FixedCompilationDatabase(
 374     const Twine &Directory, ArrayRef<std::string> CommandLine) {
 375   std::vector<std::string> ToolCommandLine(1, GetClangToolCommand());
 376   ToolCommandLine.insert(ToolCommandLine.end(),
 377                          CommandLine.begin(), CommandLine.end());
 378   CompileCommands.emplace_back(Directory, StringRef(),
 379                                std::move(ToolCommandLine),
 380                                StringRef());
 381 }
 382
 383 std::vector<CompileCommand>
 384 FixedCompilationDatabase::getCompileCommands(StringRef FilePath) const {
 385   std::vector<CompileCommand> Result(CompileCommands);
 386   Result[0].CommandLine.push_back(std::string(FilePath));
 387   Result[0].Filename = std::string(FilePath);
 388   return Result;
 389 }
 390
 391 namespace {
 392
 393 class FixedCompilationDatabasePlugin : public CompilationDatabasePlugin {
 394   std::unique_ptr<CompilationDatabase>
 395   loadFromDirectory(StringRef Directory, std::string &ErrorMessage) override {
 396     SmallString<1024> DatabasePath(Directory);
 397     llvm::sys::path::append(DatabasePath, "compile_flags.txt");
 398     return FixedCompilationDatabase::loadFromFile(DatabasePath, ErrorMessage);
 399   }
 400 };
 401
 402 } // namespace
 403
 404 static CompilationDatabasePluginRegistry::Add<FixedCompilationDatabasePlugin>
 405 X("fixed-compilation-database", "Reads plain-text flags file");
 406
 407 namespace clang {
 408 namespace tooling {
 409
 410 // This anchor is used to force the linker to link in the generated object file
 411 // and thus register the JSONCompilationDatabasePlugin.
 412 extern volatile int JSONAnchorSource;
 413 static int LLVM_ATTRIBUTE_UNUSED JSONAnchorDest = JSONAnchorSource;
 414
 415 } // namespace tooling
 416 } // namespace clang