Tooling.cpp revision 263508 
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
40namespace clang {
41namespace tooling {
42
43ToolAction::~ToolAction() {}
44
45FrontendActionFactory::~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.
52static 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.
65static 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.
92static 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
105bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
106                   const Twine &FileName) {
107  return runToolOnCodeWithArgs(
108      ToolAction, Code, std::vector<std::string>(), FileName);
109}
110
111static std::vector<std::string>
112getSyntaxOnlyToolArgs(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
122bool 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
138std::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
153namespace {
154
155class SingleFrontendActionFactory : public FrontendActionFactory {
156  FrontendAction *Action;
157
158public:
159  SingleFrontendActionFactory(FrontendAction *Action) : Action(Action) {}
160
161  FrontendAction *create() { return Action; }
162};
163
164}
165
166ToolInvocation::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
174ToolInvocation::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
182ToolInvocation::~ToolInvocation() {
183  if (OwnsAction)
184    delete Action;
185}
186
187void ToolInvocation::setDiagnosticConsumer(DiagnosticConsumer *D) {
188  DiagConsumer = D;
189}
190
191void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
192  SmallString<1024> PathStorage;
193  llvm::sys::path::native(FilePath, PathStorage);
194  MappedFileContents[PathStorage] = Content;
195}
196
197bool 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
233bool 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
247bool 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
273ClangTool::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
299void ClangTool::setDiagnosticConsumer(DiagnosticConsumer *D) {
300  DiagConsumer = D;
301}
302
303void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
304  MappedFileContents.push_back(std::make_pair(FilePath, Content));
305}
306
307void ClangTool::setArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
308  clearArgumentsAdjusters();
309  appendArgumentsAdjuster(Adjuster);
310}
311
312void ClangTool::appendArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
313  ArgsAdjusters.push_back(Adjuster);
314}
315
316void ClangTool::clearArgumentsAdjusters() {
317  for (unsigned I = 0, E = ArgsAdjusters.size(); I != E; ++I)
318    delete ArgsAdjusters[I];
319  ArgsAdjusters.clear();
320}
321
322int 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
372namespace {
373
374class ASTBuilderAction : public ToolAction {
375  std::vector<ASTUnit *> &ASTs;
376
377public:
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
397int ClangTool::buildASTs(std::vector<ASTUnit *> &ASTs) {
398  ASTBuilderAction Action(ASTs);
399  return run(&Action);
400}
401
402ASTUnit *buildASTFromCode(const Twine &Code, const Twine &FileName) {
403  return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName);
404}
405
406ASTUnit *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
428