1 //===- Tooling.cpp - Running clang standalone tools -----------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements functions to run clang tools standalone instead 10 // of running them as a plugin. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Tooling/Tooling.h" 15 #include "clang/Basic/Diagnostic.h" 16 #include "clang/Basic/DiagnosticIDs.h" 17 #include "clang/Basic/DiagnosticOptions.h" 18 #include "clang/Basic/FileManager.h" 19 #include "clang/Basic/FileSystemOptions.h" 20 #include "clang/Basic/LLVM.h" 21 #include "clang/Driver/Compilation.h" 22 #include "clang/Driver/Driver.h" 23 #include "clang/Driver/Job.h" 24 #include "clang/Driver/Options.h" 25 #include "clang/Driver/Tool.h" 26 #include "clang/Driver/ToolChain.h" 27 #include "clang/Frontend/ASTUnit.h" 28 #include "clang/Frontend/CompilerInstance.h" 29 #include "clang/Frontend/CompilerInvocation.h" 30 #include "clang/Frontend/FrontendDiagnostic.h" 31 #include "clang/Frontend/FrontendOptions.h" 32 #include "clang/Frontend/TextDiagnosticPrinter.h" 33 #include "clang/Lex/HeaderSearchOptions.h" 34 #include "clang/Lex/PreprocessorOptions.h" 35 #include "clang/Tooling/ArgumentsAdjusters.h" 36 #include "clang/Tooling/CompilationDatabase.h" 37 #include "llvm/ADT/ArrayRef.h" 38 #include "llvm/ADT/IntrusiveRefCntPtr.h" 39 #include "llvm/ADT/SmallString.h" 40 #include "llvm/ADT/StringRef.h" 41 #include "llvm/ADT/Twine.h" 42 #include "llvm/Option/ArgList.h" 43 #include "llvm/Option/OptTable.h" 44 #include "llvm/Option/Option.h" 45 #include "llvm/Support/Casting.h" 46 #include "llvm/Support/Debug.h" 47 #include "llvm/Support/ErrorHandling.h" 48 #include "llvm/Support/FileSystem.h" 49 #include "llvm/Support/Host.h" 50 #include "llvm/Support/MemoryBuffer.h" 51 #include "llvm/Support/Path.h" 52 #include "llvm/Support/VirtualFileSystem.h" 53 #include "llvm/Support/raw_ostream.h" 54 #include <cassert> 55 #include <cstring> 56 #include <memory> 57 #include <string> 58 #include <system_error> 59 #include <utility> 60 #include <vector> 61 62 #define DEBUG_TYPE "clang-tooling" 63 64 using namespace clang; 65 using namespace tooling; 66 67 ToolAction::~ToolAction() = default; 68 69 FrontendActionFactory::~FrontendActionFactory() = default; 70 71 // FIXME: This file contains structural duplication with other parts of the 72 // code that sets up a compiler to run tools on it, and we should refactor 73 // it to be based on the same framework. 74 75 /// Builds a clang driver initialized for running clang tools. 76 static driver::Driver * 77 newDriver(DiagnosticsEngine *Diagnostics, const char *BinaryName, 78 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) { 79 driver::Driver *CompilerDriver = 80 new driver::Driver(BinaryName, llvm::sys::getDefaultTargetTriple(), 81 *Diagnostics, "clang LLVM compiler", std::move(VFS)); 82 CompilerDriver->setTitle("clang_based_tool"); 83 return CompilerDriver; 84 } 85 86 /// Retrieves the clang CC1 specific flags out of the compilation's jobs. 87 /// 88 /// Returns nullptr on error. 89 static const llvm::opt::ArgStringList *getCC1Arguments( 90 DiagnosticsEngine *Diagnostics, driver::Compilation *Compilation) { 91 // We expect to get back exactly one Command job, if we didn't something 92 // failed. Extract that job from the Compilation. 93 const driver::JobList &Jobs = Compilation->getJobs(); 94 const driver::ActionList &Actions = Compilation->getActions(); 95 bool OffloadCompilation = false; 96 if (Jobs.size() > 1) { 97 for (auto A : Actions){ 98 // On MacOSX real actions may end up being wrapped in BindArchAction 99 if (isa<driver::BindArchAction>(A)) 100 A = *A->input_begin(); 101 if (isa<driver::OffloadAction>(A)) { 102 // Offload compilation has 2 top-level actions, one (at the front) is 103 // the original host compilation and the other is offload action 104 // composed of at least one device compilation. For such case, general 105 // tooling will consider host-compilation only. For tooling on device 106 // compilation, device compilation only option, such as 107 // `--cuda-device-only`, needs specifying. 108 assert(Actions.size() > 1); 109 assert( 110 isa<driver::CompileJobAction>(Actions.front()) || 111 // On MacOSX real actions may end up being wrapped in 112 // BindArchAction. 113 (isa<driver::BindArchAction>(Actions.front()) && 114 isa<driver::CompileJobAction>(*Actions.front()->input_begin()))); 115 OffloadCompilation = true; 116 break; 117 } 118 } 119 } 120 if (Jobs.size() == 0 || !isa<driver::Command>(*Jobs.begin()) || 121 (Jobs.size() > 1 && !OffloadCompilation)) { 122 SmallString<256> error_msg; 123 llvm::raw_svector_ostream error_stream(error_msg); 124 Jobs.Print(error_stream, "; ", true); 125 Diagnostics->Report(diag::err_fe_expected_compiler_job) 126 << error_stream.str(); 127 return nullptr; 128 } 129 130 // The one job we find should be to invoke clang again. 131 const auto &Cmd = cast<driver::Command>(*Jobs.begin()); 132 if (StringRef(Cmd.getCreator().getName()) != "clang") { 133 Diagnostics->Report(diag::err_fe_expected_clang_command); 134 return nullptr; 135 } 136 137 return &Cmd.getArguments(); 138 } 139 140 namespace clang { 141 namespace tooling { 142 143 /// Returns a clang build invocation initialized from the CC1 flags. 144 CompilerInvocation *newInvocation(DiagnosticsEngine *Diagnostics, 145 const llvm::opt::ArgStringList &CC1Args, 146 const char *const BinaryName) { 147 assert(!CC1Args.empty() && "Must at least contain the program name!"); 148 CompilerInvocation *Invocation = new CompilerInvocation; 149 CompilerInvocation::CreateFromArgs(*Invocation, CC1Args, *Diagnostics, 150 BinaryName); 151 Invocation->getFrontendOpts().DisableFree = false; 152 Invocation->getCodeGenOpts().DisableFree = false; 153 return Invocation; 154 } 155 156 bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction, 157 const Twine &Code, const Twine &FileName, 158 std::shared_ptr<PCHContainerOperations> PCHContainerOps) { 159 return runToolOnCodeWithArgs(std::move(ToolAction), Code, 160 std::vector<std::string>(), FileName, 161 "clang-tool", std::move(PCHContainerOps)); 162 } 163 164 } // namespace tooling 165 } // namespace clang 166 167 static std::vector<std::string> 168 getSyntaxOnlyToolArgs(const Twine &ToolName, 169 const std::vector<std::string> &ExtraArgs, 170 StringRef FileName) { 171 std::vector<std::string> Args; 172 Args.push_back(ToolName.str()); 173 Args.push_back("-fsyntax-only"); 174 Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end()); 175 Args.push_back(FileName.str()); 176 return Args; 177 } 178 179 namespace clang { 180 namespace tooling { 181 182 bool runToolOnCodeWithArgs( 183 std::unique_ptr<FrontendAction> ToolAction, const Twine &Code, 184 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 185 const std::vector<std::string> &Args, const Twine &FileName, 186 const Twine &ToolName, 187 std::shared_ptr<PCHContainerOperations> PCHContainerOps) { 188 SmallString<16> FileNameStorage; 189 StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage); 190 191 llvm::IntrusiveRefCntPtr<FileManager> Files( 192 new FileManager(FileSystemOptions(), VFS)); 193 ArgumentsAdjuster Adjuster = getClangStripDependencyFileAdjuster(); 194 ToolInvocation Invocation( 195 getSyntaxOnlyToolArgs(ToolName, Adjuster(Args, FileNameRef), FileNameRef), 196 std::move(ToolAction), Files.get(), std::move(PCHContainerOps)); 197 return Invocation.run(); 198 } 199 200 bool runToolOnCodeWithArgs( 201 std::unique_ptr<FrontendAction> ToolAction, const Twine &Code, 202 const std::vector<std::string> &Args, const Twine &FileName, 203 const Twine &ToolName, 204 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 205 const FileContentMappings &VirtualMappedFiles) { 206 llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem( 207 new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem())); 208 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem( 209 new llvm::vfs::InMemoryFileSystem); 210 OverlayFileSystem->pushOverlay(InMemoryFileSystem); 211 212 SmallString<1024> CodeStorage; 213 InMemoryFileSystem->addFile(FileName, 0, 214 llvm::MemoryBuffer::getMemBuffer( 215 Code.toNullTerminatedStringRef(CodeStorage))); 216 217 for (auto &FilenameWithContent : VirtualMappedFiles) { 218 InMemoryFileSystem->addFile( 219 FilenameWithContent.first, 0, 220 llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second)); 221 } 222 223 return runToolOnCodeWithArgs(std::move(ToolAction), Code, OverlayFileSystem, 224 Args, FileName, ToolName); 225 } 226 227 llvm::Expected<std::string> getAbsolutePath(llvm::vfs::FileSystem &FS, 228 StringRef File) { 229 StringRef RelativePath(File); 230 // FIXME: Should '.\\' be accepted on Win32? 231 if (RelativePath.startswith("./")) { 232 RelativePath = RelativePath.substr(strlen("./")); 233 } 234 235 SmallString<1024> AbsolutePath = RelativePath; 236 if (auto EC = FS.makeAbsolute(AbsolutePath)) 237 return llvm::errorCodeToError(EC); 238 llvm::sys::path::native(AbsolutePath); 239 return std::string(AbsolutePath.str()); 240 } 241 242 std::string getAbsolutePath(StringRef File) { 243 return llvm::cantFail(getAbsolutePath(*llvm::vfs::getRealFileSystem(), File)); 244 } 245 246 void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine, 247 StringRef InvokedAs) { 248 if (CommandLine.empty() || InvokedAs.empty()) 249 return; 250 const auto &Table = driver::getDriverOptTable(); 251 // --target=X 252 const std::string TargetOPT = 253 Table.getOption(driver::options::OPT_target).getPrefixedName(); 254 // -target X 255 const std::string TargetOPTLegacy = 256 Table.getOption(driver::options::OPT_target_legacy_spelling) 257 .getPrefixedName(); 258 // --driver-mode=X 259 const std::string DriverModeOPT = 260 Table.getOption(driver::options::OPT_driver_mode).getPrefixedName(); 261 auto TargetMode = 262 driver::ToolChain::getTargetAndModeFromProgramName(InvokedAs); 263 // No need to search for target args if we don't have a target/mode to insert. 264 bool ShouldAddTarget = TargetMode.TargetIsValid; 265 bool ShouldAddMode = TargetMode.DriverMode != nullptr; 266 // Skip CommandLine[0]. 267 for (auto Token = ++CommandLine.begin(); Token != CommandLine.end(); 268 ++Token) { 269 StringRef TokenRef(*Token); 270 ShouldAddTarget = ShouldAddTarget && !TokenRef.startswith(TargetOPT) && 271 !TokenRef.equals(TargetOPTLegacy); 272 ShouldAddMode = ShouldAddMode && !TokenRef.startswith(DriverModeOPT); 273 } 274 if (ShouldAddMode) { 275 CommandLine.insert(++CommandLine.begin(), TargetMode.DriverMode); 276 } 277 if (ShouldAddTarget) { 278 CommandLine.insert(++CommandLine.begin(), 279 TargetOPT + TargetMode.TargetPrefix); 280 } 281 } 282 283 } // namespace tooling 284 } // namespace clang 285 286 namespace { 287 288 class SingleFrontendActionFactory : public FrontendActionFactory { 289 std::unique_ptr<FrontendAction> Action; 290 291 public: 292 SingleFrontendActionFactory(std::unique_ptr<FrontendAction> Action) 293 : Action(std::move(Action)) {} 294 295 std::unique_ptr<FrontendAction> create() override { 296 return std::move(Action); 297 } 298 }; 299 300 } // namespace 301 302 ToolInvocation::ToolInvocation( 303 std::vector<std::string> CommandLine, ToolAction *Action, 304 FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps) 305 : CommandLine(std::move(CommandLine)), Action(Action), OwnsAction(false), 306 Files(Files), PCHContainerOps(std::move(PCHContainerOps)) {} 307 308 ToolInvocation::ToolInvocation( 309 std::vector<std::string> CommandLine, 310 std::unique_ptr<FrontendAction> FAction, FileManager *Files, 311 std::shared_ptr<PCHContainerOperations> PCHContainerOps) 312 : CommandLine(std::move(CommandLine)), 313 Action(new SingleFrontendActionFactory(std::move(FAction))), 314 OwnsAction(true), Files(Files), 315 PCHContainerOps(std::move(PCHContainerOps)) {} 316 317 ToolInvocation::~ToolInvocation() { 318 if (OwnsAction) 319 delete Action; 320 } 321 322 bool ToolInvocation::run() { 323 std::vector<const char*> Argv; 324 for (const std::string &Str : CommandLine) 325 Argv.push_back(Str.c_str()); 326 const char *const BinaryName = Argv[0]; 327 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); 328 unsigned MissingArgIndex, MissingArgCount; 329 llvm::opt::InputArgList ParsedArgs = driver::getDriverOptTable().ParseArgs( 330 ArrayRef<const char *>(Argv).slice(1), MissingArgIndex, MissingArgCount); 331 ParseDiagnosticArgs(*DiagOpts, ParsedArgs); 332 TextDiagnosticPrinter DiagnosticPrinter( 333 llvm::errs(), &*DiagOpts); 334 DiagnosticsEngine Diagnostics( 335 IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts, 336 DiagConsumer ? DiagConsumer : &DiagnosticPrinter, false); 337 338 const std::unique_ptr<driver::Driver> Driver( 339 newDriver(&Diagnostics, BinaryName, &Files->getVirtualFileSystem())); 340 // The "input file not found" diagnostics from the driver are useful. 341 // The driver is only aware of the VFS working directory, but some clients 342 // change this at the FileManager level instead. 343 // In this case the checks have false positives, so skip them. 344 if (!Files->getFileSystemOpts().WorkingDir.empty()) 345 Driver->setCheckInputsExist(false); 346 const std::unique_ptr<driver::Compilation> Compilation( 347 Driver->BuildCompilation(llvm::makeArrayRef(Argv))); 348 if (!Compilation) 349 return false; 350 const llvm::opt::ArgStringList *const CC1Args = getCC1Arguments( 351 &Diagnostics, Compilation.get()); 352 if (!CC1Args) 353 return false; 354 std::unique_ptr<CompilerInvocation> Invocation( 355 newInvocation(&Diagnostics, *CC1Args, BinaryName)); 356 return runInvocation(BinaryName, Compilation.get(), std::move(Invocation), 357 std::move(PCHContainerOps)); 358 } 359 360 bool ToolInvocation::runInvocation( 361 const char *BinaryName, driver::Compilation *Compilation, 362 std::shared_ptr<CompilerInvocation> Invocation, 363 std::shared_ptr<PCHContainerOperations> PCHContainerOps) { 364 // Show the invocation, with -v. 365 if (Invocation->getHeaderSearchOpts().Verbose) { 366 llvm::errs() << "clang Invocation:\n"; 367 Compilation->getJobs().Print(llvm::errs(), "\n", true); 368 llvm::errs() << "\n"; 369 } 370 371 return Action->runInvocation(std::move(Invocation), Files, 372 std::move(PCHContainerOps), DiagConsumer); 373 } 374 375 bool FrontendActionFactory::runInvocation( 376 std::shared_ptr<CompilerInvocation> Invocation, FileManager *Files, 377 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 378 DiagnosticConsumer *DiagConsumer) { 379 // Create a compiler instance to handle the actual work. 380 CompilerInstance Compiler(std::move(PCHContainerOps)); 381 Compiler.setInvocation(std::move(Invocation)); 382 Compiler.setFileManager(Files); 383 384 // The FrontendAction can have lifetime requirements for Compiler or its 385 // members, and we need to ensure it's deleted earlier than Compiler. So we 386 // pass it to an std::unique_ptr declared after the Compiler variable. 387 std::unique_ptr<FrontendAction> ScopedToolAction(create()); 388 389 // Create the compiler's actual diagnostics engine. 390 Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false); 391 if (!Compiler.hasDiagnostics()) 392 return false; 393 394 Compiler.createSourceManager(*Files); 395 396 const bool Success = Compiler.ExecuteAction(*ScopedToolAction); 397 398 Files->clearStatCache(); 399 return Success; 400 } 401 402 ClangTool::ClangTool(const CompilationDatabase &Compilations, 403 ArrayRef<std::string> SourcePaths, 404 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 405 IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS, 406 IntrusiveRefCntPtr<FileManager> Files) 407 : Compilations(Compilations), SourcePaths(SourcePaths), 408 PCHContainerOps(std::move(PCHContainerOps)), 409 OverlayFileSystem(new llvm::vfs::OverlayFileSystem(std::move(BaseFS))), 410 InMemoryFileSystem(new llvm::vfs::InMemoryFileSystem), 411 Files(Files ? Files 412 : new FileManager(FileSystemOptions(), OverlayFileSystem)) { 413 OverlayFileSystem->pushOverlay(InMemoryFileSystem); 414 appendArgumentsAdjuster(getClangStripOutputAdjuster()); 415 appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster()); 416 appendArgumentsAdjuster(getClangStripDependencyFileAdjuster()); 417 if (Files) 418 Files->setVirtualFileSystem(OverlayFileSystem); 419 } 420 421 ClangTool::~ClangTool() = default; 422 423 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) { 424 MappedFileContents.push_back(std::make_pair(FilePath, Content)); 425 } 426 427 void ClangTool::appendArgumentsAdjuster(ArgumentsAdjuster Adjuster) { 428 ArgsAdjuster = combineAdjusters(std::move(ArgsAdjuster), std::move(Adjuster)); 429 } 430 431 void ClangTool::clearArgumentsAdjusters() { 432 ArgsAdjuster = nullptr; 433 } 434 435 static void injectResourceDir(CommandLineArguments &Args, const char *Argv0, 436 void *MainAddr) { 437 // Allow users to override the resource dir. 438 for (StringRef Arg : Args) 439 if (Arg.startswith("-resource-dir")) 440 return; 441 442 // If there's no override in place add our resource dir. 443 Args.push_back("-resource-dir=" + 444 CompilerInvocation::GetResourcesPath(Argv0, MainAddr)); 445 } 446 447 int ClangTool::run(ToolAction *Action) { 448 // Exists solely for the purpose of lookup of the resource path. 449 // This just needs to be some symbol in the binary. 450 static int StaticSymbol; 451 452 // First insert all absolute paths into the in-memory VFS. These are global 453 // for all compile commands. 454 if (SeenWorkingDirectories.insert("/").second) 455 for (const auto &MappedFile : MappedFileContents) 456 if (llvm::sys::path::is_absolute(MappedFile.first)) 457 InMemoryFileSystem->addFile( 458 MappedFile.first, 0, 459 llvm::MemoryBuffer::getMemBuffer(MappedFile.second)); 460 461 bool ProcessingFailed = false; 462 bool FileSkipped = false; 463 // Compute all absolute paths before we run any actions, as those will change 464 // the working directory. 465 std::vector<std::string> AbsolutePaths; 466 AbsolutePaths.reserve(SourcePaths.size()); 467 for (const auto &SourcePath : SourcePaths) { 468 auto AbsPath = getAbsolutePath(*OverlayFileSystem, SourcePath); 469 if (!AbsPath) { 470 llvm::errs() << "Skipping " << SourcePath 471 << ". Error while getting an absolute path: " 472 << llvm::toString(AbsPath.takeError()) << "\n"; 473 continue; 474 } 475 AbsolutePaths.push_back(std::move(*AbsPath)); 476 } 477 478 // Remember the working directory in case we need to restore it. 479 std::string InitialWorkingDir; 480 if (RestoreCWD) { 481 if (auto CWD = OverlayFileSystem->getCurrentWorkingDirectory()) { 482 InitialWorkingDir = std::move(*CWD); 483 } else { 484 llvm::errs() << "Could not get working directory: " 485 << CWD.getError().message() << "\n"; 486 } 487 } 488 489 for (llvm::StringRef File : AbsolutePaths) { 490 // Currently implementations of CompilationDatabase::getCompileCommands can 491 // change the state of the file system (e.g. prepare generated headers), so 492 // this method needs to run right before we invoke the tool, as the next 493 // file may require a different (incompatible) state of the file system. 494 // 495 // FIXME: Make the compilation database interface more explicit about the 496 // requirements to the order of invocation of its members. 497 std::vector<CompileCommand> CompileCommandsForFile = 498 Compilations.getCompileCommands(File); 499 if (CompileCommandsForFile.empty()) { 500 llvm::errs() << "Skipping " << File << ". Compile command not found.\n"; 501 FileSkipped = true; 502 continue; 503 } 504 for (CompileCommand &CompileCommand : CompileCommandsForFile) { 505 // FIXME: chdir is thread hostile; on the other hand, creating the same 506 // behavior as chdir is complex: chdir resolves the path once, thus 507 // guaranteeing that all subsequent relative path operations work 508 // on the same path the original chdir resulted in. This makes a 509 // difference for example on network filesystems, where symlinks might be 510 // switched during runtime of the tool. Fixing this depends on having a 511 // file system abstraction that allows openat() style interactions. 512 if (OverlayFileSystem->setCurrentWorkingDirectory( 513 CompileCommand.Directory)) 514 llvm::report_fatal_error("Cannot chdir into \"" + 515 Twine(CompileCommand.Directory) + "\"!"); 516 517 // Now fill the in-memory VFS with the relative file mappings so it will 518 // have the correct relative paths. We never remove mappings but that 519 // should be fine. 520 if (SeenWorkingDirectories.insert(CompileCommand.Directory).second) 521 for (const auto &MappedFile : MappedFileContents) 522 if (!llvm::sys::path::is_absolute(MappedFile.first)) 523 InMemoryFileSystem->addFile( 524 MappedFile.first, 0, 525 llvm::MemoryBuffer::getMemBuffer(MappedFile.second)); 526 527 std::vector<std::string> CommandLine = CompileCommand.CommandLine; 528 if (ArgsAdjuster) 529 CommandLine = ArgsAdjuster(CommandLine, CompileCommand.Filename); 530 assert(!CommandLine.empty()); 531 532 // Add the resource dir based on the binary of this tool. argv[0] in the 533 // compilation database may refer to a different compiler and we want to 534 // pick up the very same standard library that compiler is using. The 535 // builtin headers in the resource dir need to match the exact clang 536 // version the tool is using. 537 // FIXME: On linux, GetMainExecutable is independent of the value of the 538 // first argument, thus allowing ClangTool and runToolOnCode to just 539 // pass in made-up names here. Make sure this works on other platforms. 540 injectResourceDir(CommandLine, "clang_tool", &StaticSymbol); 541 542 // FIXME: We need a callback mechanism for the tool writer to output a 543 // customized message for each file. 544 LLVM_DEBUG({ llvm::dbgs() << "Processing: " << File << ".\n"; }); 545 ToolInvocation Invocation(std::move(CommandLine), Action, Files.get(), 546 PCHContainerOps); 547 Invocation.setDiagnosticConsumer(DiagConsumer); 548 549 if (!Invocation.run()) { 550 // FIXME: Diagnostics should be used instead. 551 if (PrintErrorMessage) 552 llvm::errs() << "Error while processing " << File << ".\n"; 553 ProcessingFailed = true; 554 } 555 } 556 } 557 558 if (!InitialWorkingDir.empty()) { 559 if (auto EC = 560 OverlayFileSystem->setCurrentWorkingDirectory(InitialWorkingDir)) 561 llvm::errs() << "Error when trying to restore working dir: " 562 << EC.message() << "\n"; 563 } 564 return ProcessingFailed ? 1 : (FileSkipped ? 2 : 0); 565 } 566 567 namespace { 568 569 class ASTBuilderAction : public ToolAction { 570 std::vector<std::unique_ptr<ASTUnit>> &ASTs; 571 572 public: 573 ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {} 574 575 bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation, 576 FileManager *Files, 577 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 578 DiagnosticConsumer *DiagConsumer) override { 579 std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation( 580 Invocation, std::move(PCHContainerOps), 581 CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts(), 582 DiagConsumer, 583 /*ShouldOwnClient=*/false), 584 Files); 585 if (!AST) 586 return false; 587 588 ASTs.push_back(std::move(AST)); 589 return true; 590 } 591 }; 592 593 } // namespace 594 595 int ClangTool::buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs) { 596 ASTBuilderAction Action(ASTs); 597 return run(&Action); 598 } 599 600 void ClangTool::setRestoreWorkingDir(bool RestoreCWD) { 601 this->RestoreCWD = RestoreCWD; 602 } 603 604 void ClangTool::setPrintErrorMessage(bool PrintErrorMessage) { 605 this->PrintErrorMessage = PrintErrorMessage; 606 } 607 608 namespace clang { 609 namespace tooling { 610 611 std::unique_ptr<ASTUnit> 612 buildASTFromCode(StringRef Code, StringRef FileName, 613 std::shared_ptr<PCHContainerOperations> PCHContainerOps) { 614 return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName, 615 "clang-tool", std::move(PCHContainerOps)); 616 } 617 618 std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs( 619 StringRef Code, const std::vector<std::string> &Args, StringRef FileName, 620 StringRef ToolName, std::shared_ptr<PCHContainerOperations> PCHContainerOps, 621 ArgumentsAdjuster Adjuster, const FileContentMappings &VirtualMappedFiles, 622 DiagnosticConsumer *DiagConsumer) { 623 std::vector<std::unique_ptr<ASTUnit>> ASTs; 624 ASTBuilderAction Action(ASTs); 625 llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem( 626 new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem())); 627 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem( 628 new llvm::vfs::InMemoryFileSystem); 629 OverlayFileSystem->pushOverlay(InMemoryFileSystem); 630 llvm::IntrusiveRefCntPtr<FileManager> Files( 631 new FileManager(FileSystemOptions(), OverlayFileSystem)); 632 633 ToolInvocation Invocation( 634 getSyntaxOnlyToolArgs(ToolName, Adjuster(Args, FileName), FileName), 635 &Action, Files.get(), std::move(PCHContainerOps)); 636 Invocation.setDiagnosticConsumer(DiagConsumer); 637 638 InMemoryFileSystem->addFile(FileName, 0, 639 llvm::MemoryBuffer::getMemBufferCopy(Code)); 640 for (auto &FilenameWithContent : VirtualMappedFiles) { 641 InMemoryFileSystem->addFile( 642 FilenameWithContent.first, 0, 643 llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second)); 644 } 645 646 if (!Invocation.run()) 647 return nullptr; 648 649 assert(ASTs.size() == 1); 650 return std::move(ASTs[0]); 651 } 652 653 } // namespace tooling 654 } // namespace clang 655