Tooling.cpp revision 256281
1124861Sharti//===--- Tooling.cpp - Running clang standalone tools ---------------------===// 2122394Sharti// 3122394Sharti// The LLVM Compiler Infrastructure 4122394Sharti// 5122394Sharti// This file is distributed under the University of Illinois Open Source 6122394Sharti// License. See LICENSE.TXT for details. 7122394Sharti// 8122394Sharti//===----------------------------------------------------------------------===// 9122394Sharti// 10122394Sharti// This file implements functions to run clang tools standalone instead 11122394Sharti// of running them as a plugin. 12122394Sharti// 13122394Sharti//===----------------------------------------------------------------------===// 14122394Sharti 15122394Sharti#include "clang/Tooling/Tooling.h" 16122394Sharti#include "clang/Driver/Compilation.h" 17122394Sharti#include "clang/Driver/Driver.h" 18124861Sharti#include "clang/Driver/Tool.h" 19124861Sharti#include "clang/Frontend/CompilerInstance.h" 20124861Sharti#include "clang/Frontend/FrontendDiagnostic.h" 21122394Sharti#include "clang/Frontend/TextDiagnosticPrinter.h" 22122394Sharti#include "clang/Tooling/ArgumentsAdjusters.h" 23122394Sharti#include "clang/Tooling/CompilationDatabase.h" 24124861Sharti#include "llvm/ADT/STLExtras.h" 25124861Sharti#include "llvm/Support/Debug.h" 26122394Sharti#include "llvm/Support/FileSystem.h" 27122394Sharti#include "llvm/Support/Host.h" 28122394Sharti#include "llvm/Support/raw_ostream.h" 29122394Sharti 30122394Sharti// For chdir, see the comment in ClangTool::run for more information. 31122394Sharti#ifdef _WIN32 32122394Sharti# include <direct.h> 33122394Sharti#else 34122394Sharti# include <unistd.h> 35122394Sharti#endif 36122394Sharti 37122394Shartinamespace clang { 38122394Shartinamespace tooling { 39122394Sharti 40122394ShartiFrontendActionFactory::~FrontendActionFactory() {} 41122394Sharti 42122394Sharti// FIXME: This file contains structural duplication with other parts of the 43122394Sharti// code that sets up a compiler to run tools on it, and we should refactor 44122394Sharti// it to be based on the same framework. 45122394Sharti 46122394Sharti/// \brief Builds a clang driver initialized for running clang tools. 47122394Shartistatic clang::driver::Driver *newDriver(clang::DiagnosticsEngine *Diagnostics, 48122394Sharti const char *BinaryName) { 49122394Sharti const std::string DefaultOutputName = "a.out"; 50122394Sharti clang::driver::Driver *CompilerDriver = new clang::driver::Driver( 51122394Sharti BinaryName, llvm::sys::getDefaultTargetTriple(), 52122394Sharti DefaultOutputName, *Diagnostics); 53122394Sharti CompilerDriver->setTitle("clang_based_tool"); 54122394Sharti return CompilerDriver; 55122394Sharti} 56122394Sharti 57122394Sharti/// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs. 58122394Sharti/// 59122394Sharti/// Returns NULL on error. 60122394Shartistatic const clang::driver::ArgStringList *getCC1Arguments( 61122394Sharti clang::DiagnosticsEngine *Diagnostics, 62122394Sharti clang::driver::Compilation *Compilation) { 63122394Sharti // We expect to get back exactly one Command job, if we didn't something 64122394Sharti // failed. Extract that job from the Compilation. 65122394Sharti 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. 87static 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 99bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code, 100 const Twine &FileName) { 101 return runToolOnCodeWithArgs( 102 ToolAction, Code, std::vector<std::string>(), FileName); 103} 104 105bool 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 124std::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 146ToolInvocation::ToolInvocation( 147 ArrayRef<std::string> CommandLine, FrontendAction *ToolAction, 148 FileManager *Files) 149 : CommandLine(CommandLine.vec()), ToolAction(ToolAction), Files(Files) { 150} 151 152void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) { 153 SmallString<1024> PathStorage; 154 llvm::sys::path::native(FilePath, PathStorage); 155 MappedFileContents[PathStorage] = Content; 156} 157 158bool 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 186bool 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 223void 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 237ClangTool::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 262void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) { 263 MappedFileContents.push_back(std::make_pair(FilePath, Content)); 264} 265 266void ClangTool::setArgumentsAdjuster(ArgumentsAdjuster *Adjuster) { 267 ArgsAdjuster.reset(Adjuster); 268} 269 270int 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 320