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