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