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/Driver/Compilation.h"
  17 #include "clang/Driver/Driver.h"
  18 #include "clang/Driver/Tool.h"
  19 #include "clang/Frontend/CompilerInstance.h"
  20 #include "clang/Frontend/FrontendDiagnostic.h"
  21 #include "clang/Frontend/TextDiagnosticPrinter.h"
  22 #include "clang/Tooling/ArgumentsAdjusters.h"
  23 #include "clang/Tooling/CompilationDatabase.h"
  24 #include "llvm/ADT/STLExtras.h"
  25 #include "llvm/Support/Debug.h"
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/Host.h"
  28 #include "llvm/Support/raw_ostream.h"
  29
  30 // For chdir, see the comment in ClangTool::run for more information.
  31 #ifdef _WIN32
  32 #  include <direct.h>
  33 #else
  34 #  include <unistd.h>
  35 #endif
  36
  37 namespace clang {
  38 namespace tooling {
  39
  40 FrontendActionFactory::~FrontendActionFactory() {}
  41
  42 // FIXME: This file contains structural duplication with other parts of the
  43 // code that sets up a compiler to run tools on it, and we should refactor
  44 // it to be based on the same framework.
  45
  46 /// \brief Builds a clang driver initialized for running clang tools.
  47 static clang::driver::Driver *newDriver(clang::DiagnosticsEngine *Diagnostics,
  48                                         const char *BinaryName) {
  49   const std::string DefaultOutputName = "a.out";
  50   clang::driver::Driver *CompilerDriver = new clang::driver::Driver(
  51     BinaryName, llvm::sys::getDefaultTargetTriple(),
  52     DefaultOutputName, *Diagnostics);
  53   CompilerDriver->setTitle("clang_based_tool");
  54   return CompilerDriver;
  55 }
  56
  57 /// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs.
  58 ///
  59 /// Returns NULL on error.
  60 static const clang::driver::ArgStringList *getCC1Arguments(
  61     clang::DiagnosticsEngine *Diagnostics,
  62     clang::driver::Compilation *Compilation) {
  63   // We expect to get back exactly one Command job, if we didn't something
  64   // failed. Extract that job from the Compilation.
  65   const clang::driver::JobList &Jobs = Compilation->getJobs();
  66   if (Jobs.size() != 1 || !isa<clang::driver::Command>(*Jobs.begin())) {
  67     SmallString<256> error_msg;
  68     llvm::raw_svector_ostream error_stream(error_msg);
  69     Compilation->PrintJob(error_stream, Compilation->getJobs(), "; ", true);
  70     Diagnostics->Report(clang::diag::err_fe_expected_compiler_job)
  71         << error_stream.str();
  72     return NULL;
  73   }
  74
  75   // The one job we find should be to invoke clang again.
  76   const clang::driver::Command *Cmd =
  77       cast<clang::driver::Command>(*Jobs.begin());
  78   if (StringRef(Cmd->getCreator().getName()) != "clang") {
  79     Diagnostics->Report(clang::diag::err_fe_expected_clang_command);
  80     return NULL;
  81   }
  82
  83   return &Cmd->getArguments();
  84 }
  85
  86 /// \brief Returns a clang build invocation initialized from the CC1 flags.
  87 static clang::CompilerInvocation *newInvocation(
  88     clang::DiagnosticsEngine *Diagnostics,
  89     const clang::driver::ArgStringList &CC1Args) {
  90   assert(!CC1Args.empty() && "Must at least contain the program name!");
  91   clang::CompilerInvocation *Invocation = new clang::CompilerInvocation;
  92   clang::CompilerInvocation::CreateFromArgs(
  93       *Invocation, CC1Args.data() + 1, CC1Args.data() + CC1Args.size(),
  94       *Diagnostics);
  95   Invocation->getFrontendOpts().DisableFree = false;
  96   return Invocation;
  97 }
  98
  99 bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
 100                    const Twine &FileName) {
 101   return runToolOnCodeWithArgs(
 102       ToolAction, Code, std::vector<std::string>(), FileName);
 103 }
 104
 105 bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code,
 106                            const std::vector<std::string> &Args,
 107                            const Twine &FileName) {
 108   SmallString<16> FileNameStorage;
 109   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
 110   std::vector<std::string> Commands;
 111   Commands.push_back("clang-tool");
 112   Commands.push_back("-fsyntax-only");
 113   Commands.insert(Commands.end(), Args.begin(), Args.end());
 114   Commands.push_back(FileNameRef.data());
 115   FileManager Files((FileSystemOptions()));
 116   ToolInvocation Invocation(Commands, ToolAction, &Files);
 117
 118   SmallString<1024> CodeStorage;
 119   Invocation.mapVirtualFile(FileNameRef,
 120                             Code.toNullTerminatedStringRef(CodeStorage));
 121   return Invocation.run();
 122 }
 123
 124 std::string getAbsolutePath(StringRef File) {
 125   SmallString<1024> BaseDirectory;
 126   if (const char *PWD = ::getenv("PWD"))
 127     BaseDirectory = PWD;
 128   else
 129     llvm::sys::fs::current_path(BaseDirectory);
 130   SmallString<1024> PathStorage;
 131   if (llvm::sys::path::is_absolute(File)) {
 132     llvm::sys::path::native(File, PathStorage);
 133     return PathStorage.str();
 134   }
 135   StringRef RelativePath(File);
 136   // FIXME: Should '.\\' be accepted on Win32?
 137   if (RelativePath.startswith("./")) {
 138     RelativePath = RelativePath.substr(strlen("./"));
 139   }
 140   SmallString<1024> AbsolutePath(BaseDirectory);
 141   llvm::sys::path::append(AbsolutePath, RelativePath);
 142   llvm::sys::path::native(Twine(AbsolutePath), PathStorage);
 143   return PathStorage.str();
 144 }
 145
 146 ToolInvocation::ToolInvocation(
 147     ArrayRef<std::string> CommandLine, FrontendAction *ToolAction,
 148     FileManager *Files)
 149     : CommandLine(CommandLine.vec()), ToolAction(ToolAction), Files(Files) {
 150 }
 151
 152 void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
 153   SmallString<1024> PathStorage;
 154   llvm::sys::path::native(FilePath, PathStorage);
 155   MappedFileContents[PathStorage] = Content;
 156 }
 157
 158 bool ToolInvocation::run() {
 159   std::vector<const char*> Argv;
 160   for (int I = 0, E = CommandLine.size(); I != E; ++I)
 161     Argv.push_back(CommandLine[I].c_str());
 162   const char *const BinaryName = Argv[0];
 163   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 164   TextDiagnosticPrinter DiagnosticPrinter(
 165       llvm::errs(), &*DiagOpts);
 166   DiagnosticsEngine Diagnostics(
 167     IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()),
 168     &*DiagOpts, &DiagnosticPrinter, false);
 169
 170   const OwningPtr<clang::driver::Driver> Driver(
 171       newDriver(&Diagnostics, BinaryName));
 172   // Since the input might only be virtual, don't check whether it exists.
 173   Driver->setCheckInputsExist(false);
 174   const OwningPtr<clang::driver::Compilation> Compilation(
 175       Driver->BuildCompilation(llvm::makeArrayRef(Argv)));
 176   const clang::driver::ArgStringList *const CC1Args = getCC1Arguments(
 177       &Diagnostics, Compilation.get());
 178   if (CC1Args == NULL) {
 179     return false;
 180   }
 181   OwningPtr<clang::CompilerInvocation> Invocation(
 182       newInvocation(&Diagnostics, *CC1Args));
 183   return runInvocation(BinaryName, Compilation.get(), Invocation.take());
 184 }
 185
 186 bool ToolInvocation::runInvocation(
 187     const char *BinaryName,
 188     clang::driver::Compilation *Compilation,
 189     clang::CompilerInvocation *Invocation) {
 190   // Show the invocation, with -v.
 191   if (Invocation->getHeaderSearchOpts().Verbose) {
 192     llvm::errs() << "clang Invocation:\n";
 193     Compilation->PrintJob(llvm::errs(), Compilation->getJobs(), "\n", true);
 194     llvm::errs() << "\n";
 195   }
 196
 197   // Create a compiler instance to handle the actual work.
 198   clang::CompilerInstance Compiler;
 199   Compiler.setInvocation(Invocation);
 200   Compiler.setFileManager(Files);
 201   // FIXME: What about LangOpts?
 202
 203   // ToolAction can have lifetime requirements for Compiler or its members, and
 204   // we need to ensure it's deleted earlier than Compiler. So we pass it to an
 205   // OwningPtr declared after the Compiler variable.
 206   OwningPtr<FrontendAction> ScopedToolAction(ToolAction.take());
 207
 208   // Create the compilers actual diagnostics engine.
 209   Compiler.createDiagnostics();
 210   if (!Compiler.hasDiagnostics())
 211     return false;
 212
 213   Compiler.createSourceManager(*Files);
 214   addFileMappingsTo(Compiler.getSourceManager());
 215
 216   const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
 217
 218   Compiler.resetAndLeakFileManager();
 219   Files->clearStatCaches();
 220   return Success;
 221 }
 222
 223 void ToolInvocation::addFileMappingsTo(SourceManager &Sources) {
 224   for (llvm::StringMap<StringRef>::const_iterator
 225            It = MappedFileContents.begin(), End = MappedFileContents.end();
 226        It != End; ++It) {
 227     // Inject the code as the given file name into the preprocessor options.
 228     const llvm::MemoryBuffer *Input =
 229         llvm::MemoryBuffer::getMemBuffer(It->getValue());
 230     // FIXME: figure out what '0' stands for.
 231     const FileEntry *FromFile = Files->getVirtualFile(
 232         It->getKey(), Input->getBufferSize(), 0);
 233     Sources.overrideFileContents(FromFile, Input);
 234   }
 235 }
 236
 237 ClangTool::ClangTool(const CompilationDatabase &Compilations,
 238                      ArrayRef<std::string> SourcePaths)
 239     : Files((FileSystemOptions())),
 240       ArgsAdjuster(new ClangSyntaxOnlyAdjuster()) {
 241   for (unsigned I = 0, E = SourcePaths.size(); I != E; ++I) {
 242     SmallString<1024> File(getAbsolutePath(SourcePaths[I]));
 243
 244     std::vector<CompileCommand> CompileCommandsForFile =
 245       Compilations.getCompileCommands(File.str());
 246     if (!CompileCommandsForFile.empty()) {
 247       for (int I = 0, E = CompileCommandsForFile.size(); I != E; ++I) {
 248         CompileCommands.push_back(std::make_pair(File.str(),
 249                                   CompileCommandsForFile[I]));
 250       }
 251     } else {
 252       // FIXME: There are two use cases here: doing a fuzzy
 253       // "find . -name '*.cc' |xargs tool" match, where as a user I don't care
 254       // about the .cc files that were not found, and the use case where I
 255       // specify all files I want to run over explicitly, where this should
 256       // be an error. We'll want to add an option for this.
 257       llvm::outs() << "Skipping " << File << ". Command line not found.\n";
 258     }
 259   }
 260 }
 261
 262 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
 263   MappedFileContents.push_back(std::make_pair(FilePath, Content));
 264 }
 265
 266 void ClangTool::setArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
 267   ArgsAdjuster.reset(Adjuster);
 268 }
 269
 270 int ClangTool::run(FrontendActionFactory *ActionFactory) {
 271   // Exists solely for the purpose of lookup of the resource path.
 272   // This just needs to be some symbol in the binary.
 273   static int StaticSymbol;
 274   // The driver detects the builtin header path based on the path of the
 275   // executable.
 276   // FIXME: On linux, GetMainExecutable is independent of the value of the
 277   // first argument, thus allowing ClangTool and runToolOnCode to just
 278   // pass in made-up names here. Make sure this works on other platforms.
 279   std::string MainExecutable =
 280     llvm::sys::Path::GetMainExecutable("clang_tool", &StaticSymbol).str();
 281
 282   bool ProcessingFailed = false;
 283   for (unsigned I = 0; I < CompileCommands.size(); ++I) {
 284     std::string File = CompileCommands[I].first;
 285     // FIXME: chdir is thread hostile; on the other hand, creating the same
 286     // behavior as chdir is complex: chdir resolves the path once, thus
 287     // guaranteeing that all subsequent relative path operations work
 288     // on the same path the original chdir resulted in. This makes a difference
 289     // for example on network filesystems, where symlinks might be switched
 290     // during runtime of the tool. Fixing this depends on having a file system
 291     // abstraction that allows openat() style interactions.
 292     if (chdir(CompileCommands[I].second.Directory.c_str()))
 293       llvm::report_fatal_error("Cannot chdir into \"" +
 294                                CompileCommands[I].second.Directory + "\n!");
 295     std::vector<std::string> CommandLine =
 296       ArgsAdjuster->Adjust(CompileCommands[I].second.CommandLine);
 297     assert(!CommandLine.empty());
 298     CommandLine[0] = MainExecutable;
 299     // FIXME: We need a callback mechanism for the tool writer to output a
 300     // customized message for each file.
 301     DEBUG({
 302       llvm::dbgs() << "Processing: " << File << ".\n";
 303     });
 304     ToolInvocation Invocation(CommandLine, ActionFactory->create(), &Files);
 305     for (int I = 0, E = MappedFileContents.size(); I != E; ++I) {
 306       Invocation.mapVirtualFile(MappedFileContents[I].first,
 307                                 MappedFileContents[I].second);
 308     }
 309     if (!Invocation.run()) {
 310       // FIXME: Diagnostics should be used instead.
 311       llvm::errs() << "Error while processing " << File << ".\n";
 312       ProcessingFailed = true;
 313     }
 314   }
 315   return ProcessingFailed ? 1 : 0;
 316 }
 317
 318 } // end namespace tooling
 319 } // end namespace clang