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