contrib/llvm/tools/clang/lib/Tooling/Tooling.cpp

   1 //===--- Tooling.cpp - Running clang standalone tools ---------------------===//
   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 //
  10 //  This file implements functions to run clang tools standalone instead
  11 //  of running them as a plugin.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Tooling/Tooling.h"
  16 #include "clang/AST/ASTConsumer.h"
  17 #include "clang/Driver/Compilation.h"
  18 #include "clang/Driver/Driver.h"
  19 #include "clang/Driver/Tool.h"
  20 #include "clang/Frontend/ASTUnit.h"
  21 #include "clang/Frontend/CompilerInstance.h"
  22 #include "clang/Frontend/FrontendDiagnostic.h"
  23 #include "clang/Frontend/TextDiagnosticPrinter.h"
  24 #include "clang/Tooling/ArgumentsAdjusters.h"
  25 #include "clang/Tooling/CompilationDatabase.h"
  26 #include "llvm/ADT/STLExtras.h"
  27 #include "llvm/Config/llvm-config.h"
  28 #include "llvm/Option/Option.h"
  29 #include "llvm/Support/Debug.h"
  30 #include "llvm/Support/FileSystem.h"
  31 #include "llvm/Support/Host.h"
  32 #include "llvm/Support/raw_ostream.h"
  33
  34 // For chdir, see the comment in ClangTool::run for more information.
  35 #ifdef LLVM_ON_WIN32
  36 #  include <direct.h>
  37 #else
  38 #  include <unistd.h>
  39 #endif
  40
  41 #define DEBUG_TYPE "clang-tooling"
  42
  43 namespace clang {
  44 namespace tooling {
  45
  46 ToolAction::~ToolAction() {}
  47
  48 FrontendActionFactory::~FrontendActionFactory() {}
  49
  50 // FIXME: This file contains structural duplication with other parts of the
  51 // code that sets up a compiler to run tools on it, and we should refactor
  52 // it to be based on the same framework.
  53
  54 /// \brief Builds a clang driver initialized for running clang tools.
  55 static clang::driver::Driver *newDriver(clang::DiagnosticsEngine *Diagnostics,
  56                                         const char *BinaryName) {
  57   clang::driver::Driver *CompilerDriver = new clang::driver::Driver(
  58       BinaryName, llvm::sys::getDefaultTargetTriple(), *Diagnostics);
  59   CompilerDriver->setTitle("clang_based_tool");
  60   return CompilerDriver;
  61 }
  62
  63 /// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs.
  64 ///
  65 /// Returns NULL on error.
  66 static const llvm::opt::ArgStringList *getCC1Arguments(
  67     clang::DiagnosticsEngine *Diagnostics,
  68     clang::driver::Compilation *Compilation) {
  69   // We expect to get back exactly one Command job, if we didn't something
  70   // failed. Extract that job from the Compilation.
  71   const clang::driver::JobList &Jobs = Compilation->getJobs();
  72   if (Jobs.size() != 1 || !isa<clang::driver::Command>(*Jobs.begin())) {
  73     SmallString<256> error_msg;
  74     llvm::raw_svector_ostream error_stream(error_msg);
  75     Jobs.Print(error_stream, "; ", true);
  76     Diagnostics->Report(clang::diag::err_fe_expected_compiler_job)
  77         << error_stream.str();
  78     return nullptr;
  79   }
  80
  81   // The one job we find should be to invoke clang again.
  82   const clang::driver::Command *Cmd =
  83       cast<clang::driver::Command>(*Jobs.begin());
  84   if (StringRef(Cmd->getCreator().getName()) != "clang") {
  85     Diagnostics->Report(clang::diag::err_fe_expected_clang_command);
  86     return nullptr;
  87   }
  88
  89   return &Cmd->getArguments();
  90 }
  91
  92 /// \brief Returns a clang build invocation initialized from the CC1 flags.
  93 static clang::CompilerInvocation *newInvocation(
  94     clang::DiagnosticsEngine *Diagnostics,
  95     const llvm::opt::ArgStringList &CC1Args) {
  96   assert(!CC1Args.empty() && "Must at least contain the program name!");
  97   clang::CompilerInvocation *Invocation = new clang::CompilerInvocation;
  98   clang::CompilerInvocation::CreateFromArgs(
  99       *Invocation, CC1Args.data() + 1, CC1Args.data() + CC1Args.size(),
 100       *Diagnostics);
 101   Invocation->getFrontendOpts().DisableFree = false;
 102   Invocation->getCodeGenOpts().DisableFree = false;
 103   Invocation->getDependencyOutputOpts() = DependencyOutputOptions();
 104   return Invocation;
 105 }
 106
 107 bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
 108                    const Twine &FileName) {
 109   return runToolOnCodeWithArgs(
 110       ToolAction, Code, std::vector<std::string>(), FileName);
 111 }
 112
 113 static std::vector<std::string>
 114 getSyntaxOnlyToolArgs(const std::vector<std::string> &ExtraArgs,
 115                       StringRef FileName) {
 116   std::vector<std::string> Args;
 117   Args.push_back("clang-tool");
 118   Args.push_back("-fsyntax-only");
 119   Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());
 120   Args.push_back(FileName.str());
 121   return Args;
 122 }
 123
 124 bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code,
 125                            const std::vector<std::string> &Args,
 126                            const Twine &FileName) {
 127   SmallString<16> FileNameStorage;
 128   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
 129   llvm::IntrusiveRefCntPtr<FileManager> Files(
 130       new FileManager(FileSystemOptions()));
 131   ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), ToolAction,
 132                             Files.get());
 133
 134   SmallString<1024> CodeStorage;
 135   Invocation.mapVirtualFile(FileNameRef,
 136                             Code.toNullTerminatedStringRef(CodeStorage));
 137   return Invocation.run();
 138 }
 139
 140 std::string getAbsolutePath(StringRef File) {
 141   StringRef RelativePath(File);
 142   // FIXME: Should '.\\' be accepted on Win32?
 143   if (RelativePath.startswith("./")) {
 144     RelativePath = RelativePath.substr(strlen("./"));
 145   }
 146
 147   SmallString<1024> AbsolutePath = RelativePath;
 148   std::error_code EC = llvm::sys::fs::make_absolute(AbsolutePath);
 149   assert(!EC);
 150   (void)EC;
 151   llvm::sys::path::native(AbsolutePath);
 152   return AbsolutePath.str();
 153 }
 154
 155 namespace {
 156
 157 class SingleFrontendActionFactory : public FrontendActionFactory {
 158   FrontendAction *Action;
 159
 160 public:
 161   SingleFrontendActionFactory(FrontendAction *Action) : Action(Action) {}
 162
 163   FrontendAction *create() override { return Action; }
 164 };
 165
 166 }
 167
 168 ToolInvocation::ToolInvocation(std::vector<std::string> CommandLine,
 169                                ToolAction *Action, FileManager *Files)
 170     : CommandLine(std::move(CommandLine)),
 171       Action(Action),
 172       OwnsAction(false),
 173       Files(Files),
 174       DiagConsumer(nullptr) {}
 175
 176 ToolInvocation::ToolInvocation(std::vector<std::string> CommandLine,
 177                                FrontendAction *FAction, FileManager *Files)
 178     : CommandLine(std::move(CommandLine)),
 179       Action(new SingleFrontendActionFactory(FAction)),
 180       OwnsAction(true),
 181       Files(Files),
 182       DiagConsumer(nullptr) {}
 183
 184 ToolInvocation::~ToolInvocation() {
 185   if (OwnsAction)
 186     delete Action;
 187 }
 188
 189 void ToolInvocation::setDiagnosticConsumer(DiagnosticConsumer *D) {
 190   DiagConsumer = D;
 191 }
 192
 193 void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
 194   SmallString<1024> PathStorage;
 195   llvm::sys::path::native(FilePath, PathStorage);
 196   MappedFileContents[PathStorage] = Content;
 197 }
 198
 199 bool ToolInvocation::run() {
 200   std::vector<const char*> Argv;
 201   for (const std::string &Str : CommandLine)
 202     Argv.push_back(Str.c_str());
 203   const char *const BinaryName = Argv[0];
 204   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 205   TextDiagnosticPrinter DiagnosticPrinter(
 206       llvm::errs(), &*DiagOpts);
 207   DiagnosticsEngine Diagnostics(
 208       IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
 209       DiagConsumer ? DiagConsumer : &DiagnosticPrinter, false);
 210
 211   const std::unique_ptr<clang::driver::Driver> Driver(
 212       newDriver(&Diagnostics, BinaryName));
 213   // Since the input might only be virtual, don't check whether it exists.
 214   Driver->setCheckInputsExist(false);
 215   const std::unique_ptr<clang::driver::Compilation> Compilation(
 216       Driver->BuildCompilation(llvm::makeArrayRef(Argv)));
 217   const llvm::opt::ArgStringList *const CC1Args = getCC1Arguments(
 218       &Diagnostics, Compilation.get());
 219   if (!CC1Args) {
 220     return false;
 221   }
 222   std::unique_ptr<clang::CompilerInvocation> Invocation(
 223       newInvocation(&Diagnostics, *CC1Args));
 224   for (const auto &It : MappedFileContents) {
 225     // Inject the code as the given file name into the preprocessor options.
 226     auto *Input = llvm::MemoryBuffer::getMemBuffer(It.getValue());
 227     Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(), Input);
 228   }
 229   return runInvocation(BinaryName, Compilation.get(), Invocation.release());
 230 }
 231
 232 bool ToolInvocation::runInvocation(
 233     const char *BinaryName,
 234     clang::driver::Compilation *Compilation,
 235     clang::CompilerInvocation *Invocation) {
 236   // Show the invocation, with -v.
 237   if (Invocation->getHeaderSearchOpts().Verbose) {
 238     llvm::errs() << "clang Invocation:\n";
 239     Compilation->getJobs().Print(llvm::errs(), "\n", true);
 240     llvm::errs() << "\n";
 241   }
 242
 243   return Action->runInvocation(Invocation, Files, DiagConsumer);
 244 }
 245
 246 bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation,
 247                                           FileManager *Files,
 248                                           DiagnosticConsumer *DiagConsumer) {
 249   // Create a compiler instance to handle the actual work.
 250   clang::CompilerInstance Compiler;
 251   Compiler.setInvocation(Invocation);
 252   Compiler.setFileManager(Files);
 253
 254   // The FrontendAction can have lifetime requirements for Compiler or its
 255   // members, and we need to ensure it's deleted earlier than Compiler. So we
 256   // pass it to an std::unique_ptr declared after the Compiler variable.
 257   std::unique_ptr<FrontendAction> ScopedToolAction(create());
 258
 259   // Create the compiler's actual diagnostics engine.
 260   Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false);
 261   if (!Compiler.hasDiagnostics())
 262     return false;
 263
 264   Compiler.createSourceManager(*Files);
 265
 266   const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
 267
 268   Files->clearStatCaches();
 269   return Success;
 270 }
 271
 272 ClangTool::ClangTool(const CompilationDatabase &Compilations,
 273                      ArrayRef<std::string> SourcePaths)
 274     : Files(new FileManager(FileSystemOptions())), DiagConsumer(nullptr) {
 275   ArgsAdjusters.push_back(new ClangStripOutputAdjuster());
 276   ArgsAdjusters.push_back(new ClangSyntaxOnlyAdjuster());
 277   for (const auto &SourcePath : SourcePaths) {
 278     std::string File(getAbsolutePath(SourcePath));
 279
 280     std::vector<CompileCommand> CompileCommandsForFile =
 281       Compilations.getCompileCommands(File);
 282     if (!CompileCommandsForFile.empty()) {
 283       for (CompileCommand &CompileCommand : CompileCommandsForFile) {
 284         CompileCommands.push_back(
 285             std::make_pair(File, std::move(CompileCommand)));
 286       }
 287     } else {
 288       // FIXME: There are two use cases here: doing a fuzzy
 289       // "find . -name '*.cc' |xargs tool" match, where as a user I don't care
 290       // about the .cc files that were not found, and the use case where I
 291       // specify all files I want to run over explicitly, where this should
 292       // be an error. We'll want to add an option for this.
 293       llvm::errs() << "Skipping " << File << ". Compile command not found.\n";
 294     }
 295   }
 296 }
 297
 298 void ClangTool::setDiagnosticConsumer(DiagnosticConsumer *D) {
 299   DiagConsumer = D;
 300 }
 301
 302 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
 303   MappedFileContents.push_back(std::make_pair(FilePath, Content));
 304 }
 305
 306 void ClangTool::setArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
 307   clearArgumentsAdjusters();
 308   appendArgumentsAdjuster(Adjuster);
 309 }
 310
 311 void ClangTool::appendArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
 312   ArgsAdjusters.push_back(Adjuster);
 313 }
 314
 315 void ClangTool::clearArgumentsAdjusters() {
 316   for (unsigned I = 0, E = ArgsAdjusters.size(); I != E; ++I)
 317     delete ArgsAdjusters[I];
 318   ArgsAdjusters.clear();
 319 }
 320
 321 int ClangTool::run(ToolAction *Action) {
 322   // Exists solely for the purpose of lookup of the resource path.
 323   // This just needs to be some symbol in the binary.
 324   static int StaticSymbol;
 325   // The driver detects the builtin header path based on the path of the
 326   // executable.
 327   // FIXME: On linux, GetMainExecutable is independent of the value of the
 328   // first argument, thus allowing ClangTool and runToolOnCode to just
 329   // pass in made-up names here. Make sure this works on other platforms.
 330   std::string MainExecutable =
 331       llvm::sys::fs::getMainExecutable("clang_tool", &StaticSymbol);
 332
 333   bool ProcessingFailed = false;
 334   for (const auto &Command : CompileCommands) {
 335     // FIXME: chdir is thread hostile; on the other hand, creating the same
 336     // behavior as chdir is complex: chdir resolves the path once, thus
 337     // guaranteeing that all subsequent relative path operations work
 338     // on the same path the original chdir resulted in. This makes a difference
 339     // for example on network filesystems, where symlinks might be switched
 340     // during runtime of the tool. Fixing this depends on having a file system
 341     // abstraction that allows openat() style interactions.
 342     if (chdir(Command.second.Directory.c_str()))
 343       llvm::report_fatal_error("Cannot chdir into \"" +
 344                                Twine(Command.second.Directory) + "\n!");
 345     std::vector<std::string> CommandLine = Command.second.CommandLine;
 346     for (ArgumentsAdjuster *Adjuster : ArgsAdjusters)
 347       CommandLine = Adjuster->Adjust(CommandLine);
 348     assert(!CommandLine.empty());
 349     CommandLine[0] = MainExecutable;
 350     // FIXME: We need a callback mechanism for the tool writer to output a
 351     // customized message for each file.
 352     DEBUG({
 353       llvm::dbgs() << "Processing: " << Command.first << ".\n";
 354     });
 355     ToolInvocation Invocation(std::move(CommandLine), Action, Files.get());
 356     Invocation.setDiagnosticConsumer(DiagConsumer);
 357     for (const auto &MappedFile : MappedFileContents) {
 358       Invocation.mapVirtualFile(MappedFile.first, MappedFile.second);
 359     }
 360     if (!Invocation.run()) {
 361       // FIXME: Diagnostics should be used instead.
 362       llvm::errs() << "Error while processing " << Command.first << ".\n";
 363       ProcessingFailed = true;
 364     }
 365   }
 366   return ProcessingFailed ? 1 : 0;
 367 }
 368
 369 namespace {
 370
 371 class ASTBuilderAction : public ToolAction {
 372   std::vector<std::unique_ptr<ASTUnit>> &ASTs;
 373
 374 public:
 375   ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}
 376
 377   bool runInvocation(CompilerInvocation *Invocation, FileManager *Files,
 378                      DiagnosticConsumer *DiagConsumer) override {
 379     // FIXME: This should use the provided FileManager.
 380     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
 381         Invocation, CompilerInstance::createDiagnostics(
 382                         &Invocation->getDiagnosticOpts(), DiagConsumer,
 383                         /*ShouldOwnClient=*/false));
 384     if (!AST)
 385       return false;
 386
 387     ASTs.push_back(std::move(AST));
 388     return true;
 389   }
 390 };
 391
 392 }
 393
 394 int ClangTool::buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs) {
 395   ASTBuilderAction Action(ASTs);
 396   return run(&Action);
 397 }
 398
 399 std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code,
 400                                           const Twine &FileName) {
 401   return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName);
 402 }
 403
 404 std::unique_ptr<ASTUnit>
 405 buildASTFromCodeWithArgs(const Twine &Code,
 406                          const std::vector<std::string> &Args,
 407                          const Twine &FileName) {
 408   SmallString<16> FileNameStorage;
 409   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
 410
 411   std::vector<std::unique_ptr<ASTUnit>> ASTs;
 412   ASTBuilderAction Action(ASTs);
 413   ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), &Action,
 414                             nullptr);
 415
 416   SmallString<1024> CodeStorage;
 417   Invocation.mapVirtualFile(FileNameRef,
 418                             Code.toNullTerminatedStringRef(CodeStorage));
 419   if (!Invocation.run())
 420     return nullptr;
 421
 422   assert(ASTs.size() == 1);
 423   return std::move(ASTs[0]);
 424 }
 425
 426 } // end namespace tooling
 427 } // end namespace clang