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