1 //===--- Tooling.cpp - Running clang standalone tools ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements functions to run clang tools standalone instead
11 // of running them as a plugin.
13 //===----------------------------------------------------------------------===//
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"
33 // For chdir, see the comment in ClangTool::run for more information.
43 ToolAction::~ToolAction() {}
45 FrontendActionFactory::~FrontendActionFactory() {}
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.
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;
62 /// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs.
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();
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);
88 return &Cmd->getArguments();
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(),
100 Invocation->getFrontendOpts().DisableFree = false;
101 Invocation->getCodeGenOpts().DisableFree = false;
105 bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
106 const Twine &FileName) {
107 return runToolOnCodeWithArgs(
108 ToolAction, Code, std::vector<std::string>(), FileName);
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());
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,
132 SmallString<1024> CodeStorage;
133 Invocation.mapVirtualFile(FileNameRef,
134 Code.toNullTerminatedStringRef(CodeStorage));
135 return Invocation.run();
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("./"));
145 SmallString<1024> AbsolutePath = RelativePath;
146 llvm::error_code EC = llvm::sys::fs::make_absolute(AbsolutePath);
149 llvm::sys::path::native(AbsolutePath);
150 return AbsolutePath.str();
155 class SingleFrontendActionFactory : public FrontendActionFactory {
156 FrontendAction *Action;
159 SingleFrontendActionFactory(FrontendAction *Action) : Action(Action) {}
161 FrontendAction *create() { return Action; }
166 ToolInvocation::ToolInvocation(ArrayRef<std::string> CommandLine,
167 ToolAction *Action, FileManager *Files)
168 : CommandLine(CommandLine.vec()),
172 DiagConsumer(NULL) {}
174 ToolInvocation::ToolInvocation(ArrayRef<std::string> CommandLine,
175 FrontendAction *FAction, FileManager *Files)
176 : CommandLine(CommandLine.vec()),
177 Action(new SingleFrontendActionFactory(FAction)),
180 DiagConsumer(NULL) {}
182 ToolInvocation::~ToolInvocation() {
187 void ToolInvocation::setDiagnosticConsumer(DiagnosticConsumer *D) {
191 void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
192 SmallString<1024> PathStorage;
193 llvm::sys::path::native(FilePath, PathStorage);
194 MappedFileContents[PathStorage] = Content;
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);
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) {
220 OwningPtr<clang::CompilerInvocation> Invocation(
221 newInvocation(&Diagnostics, *CC1Args));
222 for (llvm::StringMap<StringRef>::const_iterator
223 It = MappedFileContents.begin(), End = MappedFileContents.end();
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);
230 return runInvocation(BinaryName, Compilation.get(), Invocation.take());
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";
244 return Action->runInvocation(Invocation, Files, DiagConsumer);
247 bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation,
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);
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());
260 // Create the compilers actual diagnostics engine.
261 Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false);
262 if (!Compiler.hasDiagnostics())
265 Compiler.createSourceManager(*Files);
267 const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
269 Files->clearStatCaches();
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]));
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]));
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";
299 void ClangTool::setDiagnosticConsumer(DiagnosticConsumer *D) {
303 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
304 MappedFileContents.push_back(std::make_pair(FilePath, Content));
307 void ClangTool::setArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
308 clearArgumentsAdjusters();
309 appendArgumentsAdjuster(Adjuster);
312 void ClangTool::appendArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
313 ArgsAdjusters.push_back(Adjuster);
316 void ClangTool::clearArgumentsAdjusters() {
317 for (unsigned I = 0, E = ArgsAdjusters.size(); I != E; ++I)
318 delete ArgsAdjusters[I];
319 ArgsAdjusters.clear();
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
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);
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.
355 llvm::dbgs() << "Processing: " << File << ".\n";
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);
363 if (!Invocation.run()) {
364 // FIXME: Diagnostics should be used instead.
365 llvm::errs() << "Error while processing " << File << ".\n";
366 ProcessingFailed = true;
369 return ProcessingFailed ? 1 : 0;
374 class ASTBuilderAction : public ToolAction {
375 std::vector<ASTUnit *> &ASTs;
378 ASTBuilderAction(std::vector<ASTUnit *> &ASTs) : ASTs(ASTs) {}
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));
397 int ClangTool::buildASTs(std::vector<ASTUnit *> &ASTs) {
398 ASTBuilderAction Action(ASTs);
402 ASTUnit *buildASTFromCode(const Twine &Code, const Twine &FileName) {
403 return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName);
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);
412 std::vector<ASTUnit *> ASTs;
413 ASTBuilderAction Action(ASTs);
414 ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), &Action, 0);
416 SmallString<1024> CodeStorage;
417 Invocation.mapVirtualFile(FileNameRef,
418 Code.toNullTerminatedStringRef(CodeStorage));
419 if (!Invocation.run())
422 assert(ASTs.size() == 1);
426 } // end namespace tooling
427 } // end namespace clang