Home | History | Annotate | Download | only in Tooling 
      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
    428