CbC/CbC_llvm: clang/lib/Tooling/Tooling.cpp comparison

comparison clang/lib/Tooling/Tooling.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	c4bab56944e8

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 static driver::Driver *
 newDriver(DiagnosticsEngine *Diagnostics, const char *BinaryName,
 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
 driver::Driver *CompilerDriver =
 new driver::Driver(BinaryName, llvm::sys::getDefaultTargetTriple(),
-*Diagnostics, std::move(VFS));
+*Diagnostics, "clang LLVM compiler", std::move(VFS));
 CompilerDriver->setTitle("clang_based_tool");
 return CompilerDriver;
 }
 /// Retrieves the clang CC1 specific flags out of the compilation's jobs.
 namespace clang {
 namespace tooling {
 /// Returns a clang build invocation initialized from the CC1 flags.
-CompilerInvocation *newInvocation(
+CompilerInvocation *newInvocation(DiagnosticsEngine *Diagnostics,
-DiagnosticsEngine *Diagnostics, const llvm::opt::ArgStringList &CC1Args) {
+const llvm::opt::ArgStringList &CC1Args,
+const char *const BinaryName) {
 assert(!CC1Args.empty() && "Must at least contain the program name!");
 CompilerInvocation *Invocation = new CompilerInvocation;
-CompilerInvocation::CreateFromArgs(*Invocation, CC1Args, *Diagnostics);
+CompilerInvocation::CreateFromArgs(*Invocation, CC1Args, *Diagnostics,
+BinaryName);
 Invocation->getFrontendOpts().DisableFree = false;
 Invocation->getCodeGenOpts().DisableFree = false;
 return Invocation;
 }
 return llvm::cantFail(getAbsolutePath(*llvm::vfs::getRealFileSystem(), File));
 }
 void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
 StringRef InvokedAs) {
-if (!CommandLine.empty() && !InvokedAs.empty()) {
+if (CommandLine.empty() || InvokedAs.empty())
-bool AlreadyHasTarget = false;
+return;
-bool AlreadyHasMode = false;
+const auto &Table = driver::getDriverOptTable();
-// Skip CommandLine[0].
+// --target=X
-for (auto Token = ++CommandLine.begin(); Token != CommandLine.end();
+const std::string TargetOPT =
-++Token) {
+Table.getOption(driver::options::OPT_target).getPrefixedName();
-StringRef TokenRef(*Token);
+// -target X
-AlreadyHasTarget |=
+const std::string TargetOPTLegacy =
-(TokenRef == "-target" || TokenRef.startswith("-target="));
+Table.getOption(driver::options::OPT_target_legacy_spelling)
-AlreadyHasMode |= (TokenRef == "--driver-mode" ||
+.getPrefixedName();
-TokenRef.startswith("--driver-mode="));
+// --driver-mode=X
-}
+const std::string DriverModeOPT =
-auto TargetMode =
+Table.getOption(driver::options::OPT_driver_mode).getPrefixedName();
-driver::ToolChain::getTargetAndModeFromProgramName(InvokedAs);
+auto TargetMode =
-if (!AlreadyHasMode && TargetMode.DriverMode) {
+driver::ToolChain::getTargetAndModeFromProgramName(InvokedAs);
-CommandLine.insert(++CommandLine.begin(), TargetMode.DriverMode);
+// No need to search for target args if we don't have a target/mode to insert.
-}
+bool ShouldAddTarget = TargetMode.TargetIsValid;
-if (!AlreadyHasTarget && TargetMode.TargetIsValid) {
+bool ShouldAddMode = TargetMode.DriverMode != nullptr;
-CommandLine.insert(++CommandLine.begin(), {"-target",
+// Skip CommandLine[0].
-TargetMode.TargetPrefix});
+for (auto Token = ++CommandLine.begin(); Token != CommandLine.end();
-}
+++Token) {
+StringRef TokenRef(*Token);
+ShouldAddTarget = ShouldAddTarget && !TokenRef.startswith(TargetOPT) &&
+!TokenRef.equals(TargetOPTLegacy);
+ShouldAddMode = ShouldAddMode && !TokenRef.startswith(DriverModeOPT);
+}
+if (ShouldAddMode) {
+CommandLine.insert(++CommandLine.begin(), TargetMode.DriverMode);
+}
+if (ShouldAddTarget) {
+CommandLine.insert(++CommandLine.begin(),
+TargetOPT + TargetMode.TargetPrefix);
 }
 }
 } // namespace tooling
 } // namespace clang
 PCHContainerOps(std::move(PCHContainerOps)) {}
 ToolInvocation::~ToolInvocation() {
 if (OwnsAction)
 delete Action;
-}
-void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
-SmallString<1024> PathStorage;
-llvm::sys::path::native(FilePath, PathStorage);
-MappedFileContents[PathStorage] = Content;
 }
 bool ToolInvocation::run() {
 std::vector<const char*> Argv;
 for (const std::string &Str : CommandLine)
 TextDiagnosticPrinter DiagnosticPrinter(
 llvm::errs(), &*DiagOpts);
 DiagnosticsEngine Diagnostics(
 IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
 DiagConsumer ? DiagConsumer : &DiagnosticPrinter, false);
+// Although `Diagnostics` are used only for command-line parsing, the custom
+// `DiagConsumer` might expect a `SourceManager` to be present.
+SourceManager SrcMgr(Diagnostics, *Files);
+Diagnostics.setSourceManager(&SrcMgr);
 const std::unique_ptr<driver::Driver> Driver(
 newDriver(&Diagnostics, BinaryName, &Files->getVirtualFileSystem()));
 // The "input file not found" diagnostics from the driver are useful.
 // The driver is only aware of the VFS working directory, but some clients
 const llvm::opt::ArgStringList *const CC1Args = getCC1Arguments(
 &Diagnostics, Compilation.get());
 if (!CC1Args)
 return false;
 std::unique_ptr<CompilerInvocation> Invocation(
-newInvocation(&Diagnostics, *CC1Args));
+newInvocation(&Diagnostics, *CC1Args, BinaryName));
-// FIXME: remove this when all users have migrated!
-for (const auto &It : MappedFileContents) {
-// Inject the code as the given file name into the preprocessor options.
-std::unique_ptr<llvm::MemoryBuffer> Input =
-llvm::MemoryBuffer::getMemBuffer(It.getValue());
-Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(),
-Input.release());
-}
 return runInvocation(BinaryName, Compilation.get(), std::move(Invocation),
 std::move(PCHContainerOps));
 }
 bool ToolInvocation::runInvocation(
 for (StringRef Arg : Args)
 if (Arg.startswith("-resource-dir"))
 return;
 // If there's no override in place add our resource dir.
-Args.push_back("-resource-dir=" +
+Args = getInsertArgumentAdjuster(
-CompilerInvocation::GetResourcesPath(Argv0, MainAddr));
+("-resource-dir=" + CompilerInvocation::GetResourcesPath(Argv0, MainAddr))
+.c_str())(Args, "");
 }
 int ClangTool::run(ToolAction *Action) {
 // Exists solely for the purpose of lookup of the resource path.
 // This just needs to be some symbol in the binary.
 llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second));
 }
 if (!Invocation.run())
 return nullptr;
 assert(ASTs.size() == 1);
 return std::move(ASTs[0]);
 }
 } // namespace tooling

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Tooling/Tooling.cpp @ 207:2e18cbf3894f