CbC/CbC_llvm: clang-tools-extra/clangd/QueryDriverDatabase.cpp comparison

comparison clang-tools-extra/clangd/QueryDriverDatabase.cpp @ 221:79ff65ed7e25

LLVM12 Original

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 15 Jun 2021 19:15:29 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:42394fc6a535
+:79ff65ed7e25
 // implementation would not work with a driver that is not gcc-compatible.
 //
 // First argument of the command line received from underlying compilation
 // database is used as compiler driver path. Due to this arbitrary binary
 // execution, this mechanism is not used by default and only executes binaries
-// in the paths that are explicitly whitelisted by the user.
+// in the paths that are explicitly included by the user.
 #include "GlobalCompilationDatabase.h"
 #include "support/Logger.h"
 #include "support/Path.h"
 #include "support/Trace.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
 #include "clang/Driver/Types.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 namespace clang {
 namespace clangd {
 namespace {
-std::vector<std::string> parseDriverOutput(llvm::StringRef Output) {
+struct DriverInfo {
 std::vector<std::string> SystemIncludes;
+std::string Target;
+};
+bool isValidTarget(llvm::StringRef Triple) {
+std::shared_ptr<TargetOptions> TargetOpts(new TargetOptions);
+TargetOpts->Triple = Triple.str();
+DiagnosticsEngine Diags(new DiagnosticIDs, new DiagnosticOptions,
+new IgnoringDiagConsumer);
+IntrusiveRefCntPtr<TargetInfo> Target =
+TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+return bool(Target);
+}
+llvm::Optional<DriverInfo> parseDriverOutput(llvm::StringRef Output) {
+DriverInfo Info;
 const char SIS[] = "#include <...> search starts here:";
 const char SIE[] = "End of search list.";
-llvm::SmallVector<llvm::StringRef, 8> Lines;
+const char TS[] = "Target: ";
+llvm::SmallVector<llvm::StringRef> Lines;
 Output.split(Lines, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
-auto StartIt = llvm::find_if(
+enum {
-Lines, [SIS](llvm::StringRef Line) { return Line.trim() == SIS; });
+Initial,            // Initial state: searching for target or includes list.
-if (StartIt == Lines.end()) {
+IncludesExtracting, // Includes extracting.
+Done                // Includes and target extraction done.
+} State = Initial;
+bool SeenIncludes = false;
+bool SeenTarget = false;
+for (auto *It = Lines.begin(); State != Done && It != Lines.end(); ++It) {
+auto Line = *It;
+switch (State) {
+case Initial:
+if (!SeenIncludes && Line.trim() == SIS) {
+SeenIncludes = true;
+State = IncludesExtracting;
+} else if (!SeenTarget && Line.trim().startswith(TS)) {
+SeenTarget = true;
+llvm::StringRef TargetLine = Line.trim();
+TargetLine.consume_front(TS);
+// Only detect targets that clang understands
+if (!isValidTarget(TargetLine)) {
+elog("System include extraction: invalid target \"{0}\", ignoring",
+TargetLine);
+} else {
+Info.Target = TargetLine.str();
+vlog("System include extraction: target extracted: \"{0}\"",
+TargetLine);
+}
+}
+break;
+case IncludesExtracting:
+if (Line.trim() == SIE) {
+State = SeenTarget ? Done : Initial;
+} else {
+Info.SystemIncludes.push_back(Line.trim().str());
+vlog("System include extraction: adding {0}", Line);
+}
+break;
+default:
+llvm_unreachable("Impossible state of the driver output parser");
+break;
+}
+}
+if (!SeenIncludes) {
 elog("System include extraction: start marker not found: {0}", Output);
-return {};
+return llvm::None;
 }
-++StartIt;
+if (State == IncludesExtracting) {
-const auto EndIt =
-llvm::find_if(llvm::make_range(StartIt, Lines.end()),
-[SIE](llvm::StringRef Line) { return Line.trim() == SIE; });
-if (EndIt == Lines.end()) {
 elog("System include extraction: end marker missing: {0}", Output);
-return {};
+return llvm::None;
 }
+return std::move(Info);
-for (llvm::StringRef Line : llvm::make_range(StartIt, EndIt)) {
+}
-SystemIncludes.push_back(Line.trim().str());
-vlog("System include extraction: adding {0}", Line);
+llvm::Optional<DriverInfo>
-}
+extractSystemIncludesAndTarget(llvm::SmallString<128> Driver,
-return SystemIncludes;
+llvm::StringRef Lang,
-}
+llvm::ArrayRef<std::string> CommandLine,
+const llvm::Regex &QueryDriverRegex) {
-std::vector<std::string>
+trace::Span Tracer("Extract system includes and target");
-extractSystemIncludes(PathRef Driver, llvm::StringRef Lang,
-llvm::ArrayRef<std::string> CommandLine,
+if (!llvm::sys::path::is_absolute(Driver)) {
-llvm::Regex &QueryDriverRegex) {
+assert(llvm::none_of(
-trace::Span Tracer("Extract system includes");
+Driver, [](char C) { return llvm::sys::path::is_separator(C); }));
+auto DriverProgram = llvm::sys::findProgramByName(Driver);
+if (DriverProgram) {
+vlog("System include extraction: driver {0} expanded to {1}", Driver,
+*DriverProgram);
+Driver = *DriverProgram;
+} else {
+elog("System include extraction: driver {0} not found in PATH", Driver);
+return llvm::None;
+}
+}
 SPAN_ATTACH(Tracer, "driver", Driver);
 SPAN_ATTACH(Tracer, "lang", Lang);
 if (!QueryDriverRegex.match(Driver)) {
-vlog("System include extraction: not whitelisted driver {0}", Driver);
+vlog("System include extraction: not allowed driver {0}", Driver);
-return {};
+return llvm::None;
-}
-if (!llvm::sys::fs::exists(Driver)) {
-elog("System include extraction: {0} does not exist.", Driver);
-return {};
-}
-if (!llvm::sys::fs::can_execute(Driver)) {
-elog("System include extraction: {0} is not executable.", Driver);
-return {};
 }
 llvm::SmallString<128> StdErrPath;
 if (auto EC = llvm::sys::fs::createTemporaryFile("system-includes", "clangd",
 StdErrPath)) {
 elog("System include extraction: failed to create temporary file with "
 "error {0}",
 EC.message());
-return {};
+return llvm::None;
 }
 auto CleanUp = llvm::make_scope_exit(
 [&StdErrPath]() { llvm::sys::fs::remove(StdErrPath); });
 llvm::Optional<llvm::StringRef> Redirects[] = {
 {""}, {""}, llvm::StringRef(StdErrPath)};
-llvm::SmallVector<llvm::StringRef, 12> Args = {Driver, "-E", "-x",
+llvm::SmallVector<llvm::StringRef> Args = {Driver, "-E", "-x",
 Lang,   "-",  "-v"};
 // These flags will be preserved
 const llvm::StringRef FlagsToPreserve[] = {
 "-nostdinc", "--no-standard-includes", "-nostdinc++", "-nobuiltininc"};
 // Preserves these flags and their values, either as separate args or with an
 llvm::find_if(ArgsToPreserve, [&Arg](llvm::StringRef S) {
 return Arg.startswith(S);
 });
 if (Found == std::end(ArgsToPreserve))
 continue;
-Arg.consume_front(*Found);
+Arg = Arg.drop_front(Found->size());
 if (Arg.empty() && I + 1 < E) {
 Args.push_back(CommandLine[I]);
 Args.push_back(CommandLine[++I]);
 } else if (Arg.startswith("=")) {
 Args.push_back(CommandLine[I]);
 }
 }
 }
+std::string ErrMsg;
 if (int RC = llvm::sys::ExecuteAndWait(Driver, Args, /*Env=*/llvm::None,
-Redirects)) {
+Redirects, /*SecondsToWait=*/0,
+/*MemoryLimit=*/0, &ErrMsg)) {
 elog("System include extraction: driver execution failed with return code: "
-"{0}. Args: ['{1}']",
+"{0} - '{1}'. Args: [{2}]",
-llvm::to_string(RC), llvm::join(Args, "', '"));
+llvm::to_string(RC), ErrMsg, printArgv(Args));
-return {};
+return llvm::None;
 }
 auto BufOrError = llvm::MemoryBuffer::getFile(StdErrPath);
 if (!BufOrError) {
 elog("System include extraction: failed to read {0} with error {1}",
 StdErrPath, BufOrError.getError().message());
-return {};
+return llvm::None;
 }
-auto Includes = parseDriverOutput(BufOrError->get()->getBuffer());
+llvm::Optional<DriverInfo> Info =
-log("System include extractor: successfully executed {0}, got includes: "
+parseDriverOutput(BufOrError->get()->getBuffer());
-"\"{1}\"",
+if (!Info)
-Driver, llvm::join(Includes, ", "));
+return llvm::None;
-return Includes;
+log("System includes extractor: successfully executed {0}\n\tgot includes: "
+"\"{1}\"\n\tgot target: \"{2}\"",
+Driver, llvm::join(Info->SystemIncludes, ", "), Info->Target);
+return Info;
 }
 tooling::CompileCommand &
 addSystemIncludes(tooling::CompileCommand &Cmd,
 llvm::ArrayRef<std::string> SystemIncludes) {
 for (llvm::StringRef Include : SystemIncludes) {
 // FIXME(kadircet): This doesn't work when we have "--driver-mode=cl"
 Cmd.CommandLine.push_back("-isystem");
 Cmd.CommandLine.push_back(Include.str());
+}
+return Cmd;
+}
+tooling::CompileCommand &setTarget(tooling::CompileCommand &Cmd,
+const std::string &Target) {
+if (!Target.empty()) {
+// We do not want to override existing target with extracted one.
+for (llvm::StringRef Arg : Cmd.CommandLine) {
+if (Arg == "-target" || Arg.startswith("--target="))
+return Cmd;
+}
+Cmd.CommandLine.push_back("--target=" + Target);
 }
 return Cmd;
 }
 /// Converts a glob containing only ** or * into a regex.
 }
 /// Extracts system includes from a trusted driver by parsing the output of
 /// include search path and appends them to the commands coming from underlying
 /// compilation database.
-class QueryDriverDatabase : public GlobalCompilationDatabase {
+class QueryDriverDatabase : public DelegatingCDB {
 public:
 QueryDriverDatabase(llvm::ArrayRef<std::string> QueryDriverGlobs,
 std::unique_ptr<GlobalCompilationDatabase> Base)
-: QueryDriverRegex(convertGlobsToRegex(QueryDriverGlobs)),
+: DelegatingCDB(std::move(Base)),
-Base(std::move(Base)) {
+QueryDriverRegex(convertGlobsToRegex(QueryDriverGlobs)) {}
-assert(this->Base);
-BaseChanged =
-this->Base->watch([this](const std::vector<std::string> &Changes) {
-OnCommandChanged.broadcast(Changes);
-});
-}
 llvm::Optional<tooling::CompileCommand>
 getCompileCommand(PathRef File) const override {
-auto Cmd = Base->getCompileCommand(File);
+auto Cmd = DelegatingCDB::getCompileCommand(File);
 if (!Cmd || Cmd->CommandLine.empty())
 return Cmd;
 llvm::StringRef Lang;
 for (size_t I = 0, E = Cmd->CommandLine.size(); I < E; ++I) {
 }
 Lang = driver::types::getTypeName(Type);
 }
 llvm::SmallString<128> Driver(Cmd->CommandLine.front());
-llvm::sys::fs::make_absolute(Cmd->Directory, Driver);
+if (llvm::any_of(Driver,
-auto Key = std::make_pair(Driver.str().str(), Lang.str());
+[](char C) { return llvm::sys::path::is_separator(C); }))
+// Driver is a not a single executable name but instead a path (either
-std::vector<std::string> SystemIncludes;
+// relative or absolute).
-{
+llvm::sys::fs::make_absolute(Cmd->Directory, Driver);
-std::lock_guard<std::mutex> Lock(Mu);
+if (auto Info =
-auto It = DriverToIncludesCache.find(Key);
+QueriedDrivers.get(/*Key=*/(Driver + ":" + Lang).str(), [&] {
-if (It != DriverToIncludesCache.end())
+return extractSystemIncludesAndTarget(
-SystemIncludes = It->second;
+Driver, Lang, Cmd->CommandLine, QueryDriverRegex);
-else
+})) {
-DriverToIncludesCache[Key] = SystemIncludes = extractSystemIncludes(
+setTarget(addSystemIncludes(*Cmd, Info->SystemIncludes), Info->Target);
-Key.first, Key.second, Cmd->CommandLine, QueryDriverRegex);
+}
-}
+return Cmd;
-return addSystemIncludes(*Cmd, SystemIncludes);
-}
-llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override {
-return Base->getProjectInfo(File);
 }
 private:
-mutable std::mutex Mu;
+// Caches includes extracted from a driver. Key is driver:lang.
-// Caches includes extracted from a driver.
+Memoize<llvm::StringMap<llvm::Optional<DriverInfo>>> QueriedDrivers;
-mutable std::map<std::pair<std::string, std::string>,
+llvm::Regex QueryDriverRegex;
-std::vector<std::string>>
-DriverToIncludesCache;
-mutable llvm::Regex QueryDriverRegex;
-std::unique_ptr<GlobalCompilationDatabase> Base;
-CommandChanged::Subscription BaseChanged;
 };
 } // namespace
 std::unique_ptr<GlobalCompilationDatabase>
 getQueryDriverDatabase(llvm::ArrayRef<std::string> QueryDriverGlobs,

Mercurial > hg > CbC > CbC_llvm

comparison clang-tools-extra/clangd/QueryDriverDatabase.cpp @ 221:79ff65ed7e25