648 lines · cpp
1//===--- CompileCommands.cpp ----------------------------------------------===//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-exception6//7//===----------------------------------------------------------------------===//8 9#include "CompileCommands.h"10#include "Config.h"11#include "support/Logger.h"12#include "support/Trace.h"13#include "clang/Driver/Driver.h"14#include "clang/Frontend/CompilerInvocation.h"15#include "clang/Options/Options.h"16#include "clang/Tooling/CompilationDatabase.h"17#include "clang/Tooling/Tooling.h"18#include "llvm/ADT/ArrayRef.h"19#include "llvm/ADT/STLExtras.h"20#include "llvm/ADT/SmallVector.h"21#include "llvm/ADT/StringRef.h"22#include "llvm/Option/ArgList.h"23#include "llvm/Option/Option.h"24#include "llvm/Support/Allocator.h"25#include "llvm/Support/Debug.h"26#include "llvm/Support/FileSystem.h"27#include "llvm/Support/FileUtilities.h"28#include "llvm/Support/MemoryBuffer.h"29#include "llvm/Support/Path.h"30#include "llvm/Support/Program.h"31#include <iterator>32#include <optional>33#include <string>34#include <vector>35 36namespace clang {37namespace clangd {38namespace {39 40// Query apple's `xcrun` launcher, which is the source of truth for "how should"41// clang be invoked on this system.42std::optional<std::string> queryXcrun(llvm::ArrayRef<llvm::StringRef> Argv) {43 auto Xcrun = llvm::sys::findProgramByName("xcrun");44 if (!Xcrun) {45 log("Couldn't find xcrun. Hopefully you have a non-apple toolchain...");46 return std::nullopt;47 }48 llvm::SmallString<64> OutFile;49 llvm::sys::fs::createTemporaryFile("clangd-xcrun", "", OutFile);50 llvm::FileRemover OutRemover(OutFile);51 std::optional<llvm::StringRef> Redirects[3] = {52 /*stdin=*/{""}, /*stdout=*/{OutFile.str()}, /*stderr=*/{""}};53 vlog("Invoking {0} to find clang installation", *Xcrun);54 int Ret = llvm::sys::ExecuteAndWait(*Xcrun, Argv,55 /*Env=*/std::nullopt, Redirects,56 /*SecondsToWait=*/10);57 if (Ret != 0) {58 log("xcrun exists but failed with code {0}. "59 "If you have a non-apple toolchain, this is OK. "60 "Otherwise, try xcode-select --install.",61 Ret);62 return std::nullopt;63 }64 65 auto Buf = llvm::MemoryBuffer::getFile(OutFile);66 if (!Buf) {67 log("Can't read xcrun output: {0}", Buf.getError().message());68 return std::nullopt;69 }70 StringRef Path = Buf->get()->getBuffer().trim();71 if (Path.empty()) {72 log("xcrun produced no output");73 return std::nullopt;74 }75 return Path.str();76}77 78// Resolve symlinks if possible.79std::string resolve(std::string Path) {80 llvm::SmallString<128> Resolved;81 if (llvm::sys::fs::real_path(Path, Resolved)) {82 log("Failed to resolve possible symlink {0}", Path);83 return Path;84 }85 return std::string(Resolved);86}87 88// Get a plausible full `clang` path.89// This is used in the fallback compile command, or when the CDB returns a90// generic driver with no path.91std::string detectClangPath() {92 // The driver and/or cc1 sometimes depend on the binary name to compute93 // useful things like the standard library location.94 // We need to emulate what clang on this system is likely to see.95 // cc1 in particular looks at the "real path" of the running process, and96 // so if /usr/bin/clang is a symlink, it sees the resolved path.97 // clangd doesn't have that luxury, so we resolve symlinks ourselves.98 99 // On Mac, `which clang` is /usr/bin/clang. It runs `xcrun clang`, which knows100 // where the real clang is kept. We need to do the same thing,101 // because cc1 (not the driver!) will find libc++ relative to argv[0].102#ifdef __APPLE__103 if (auto MacClang = queryXcrun({"xcrun", "--find", "clang"}))104 return resolve(std::move(*MacClang));105#endif106 // On other platforms, just look for compilers on the PATH.107 for (const char *Name : {"clang", "gcc", "cc"})108 if (auto PathCC = llvm::sys::findProgramByName(Name))109 return resolve(std::move(*PathCC));110 // Fallback: a nonexistent 'clang' binary next to clangd.111 static int StaticForMainAddr;112 std::string ClangdExecutable =113 llvm::sys::fs::getMainExecutable("clangd", (void *)&StaticForMainAddr);114 SmallString<128> ClangPath;115 ClangPath = llvm::sys::path::parent_path(ClangdExecutable);116 llvm::sys::path::append(ClangPath, "clang");117 return std::string(ClangPath);118}119 120// On mac, /usr/bin/clang sets SDKROOT and then invokes the real clang.121// The effect of this is to set -isysroot correctly. We do the same.122std::optional<std::string> detectSysroot() {123#ifndef __APPLE__124 return std::nullopt;125#endif126 127 // SDKROOT overridden in environment, respect it. Driver will set isysroot.128 if (::getenv("SDKROOT"))129 return std::nullopt;130 return queryXcrun({"xcrun", "--show-sdk-path"});131}132 133std::string detectStandardResourceDir() {134 static int StaticForMainAddr; // Just an address in this process.135 return GetResourcesPath("clangd", (void *)&StaticForMainAddr);136}137 138// The path passed to argv[0] is important:139// - its parent directory is Driver::Dir, used for library discovery140// - its basename affects CLI parsing (clang-cl) and other settings141// Where possible it should be an absolute path with sensible directory, but142// with the original basename.143static std::string resolveDriver(llvm::StringRef Driver, bool FollowSymlink,144 std::optional<std::string> ClangPath) {145 auto SiblingOf = [&](llvm::StringRef AbsPath) {146 llvm::SmallString<128> Result = llvm::sys::path::parent_path(AbsPath);147 llvm::sys::path::append(Result, llvm::sys::path::filename(Driver));148 return Result.str().str();149 };150 151 // First, eliminate relative paths.152 std::string Storage;153 if (!llvm::sys::path::is_absolute(Driver)) {154 // If it's working-dir relative like bin/clang, we can't resolve it.155 // FIXME: we could if we had the working directory here.156 // Let's hope it's not a symlink.157 if (llvm::any_of(Driver,158 [](char C) { return llvm::sys::path::is_separator(C); }))159 return Driver.str();160 // If the driver is a generic like "g++" with no path, add clang dir.161 if (ClangPath &&162 (Driver == "clang" || Driver == "clang++" || Driver == "gcc" ||163 Driver == "g++" || Driver == "cc" || Driver == "c++")) {164 return SiblingOf(*ClangPath);165 }166 // Otherwise try to look it up on PATH. This won't change basename.167 auto Absolute = llvm::sys::findProgramByName(Driver);168 if (Absolute && llvm::sys::path::is_absolute(*Absolute))169 Driver = Storage = std::move(*Absolute);170 else if (ClangPath) // If we don't find it, use clang dir again.171 return SiblingOf(*ClangPath);172 else // Nothing to do: can't find the command and no detected dir.173 return Driver.str();174 }175 176 // Now we have an absolute path, but it may be a symlink.177 assert(llvm::sys::path::is_absolute(Driver));178 if (FollowSymlink) {179 llvm::SmallString<256> Resolved;180 if (!llvm::sys::fs::real_path(Driver, Resolved))181 return SiblingOf(Resolved);182 }183 return Driver.str();184}185 186} // namespace187 188CommandMangler CommandMangler::detect() {189 CommandMangler Result;190 Result.ClangPath = detectClangPath();191 Result.ResourceDir = detectStandardResourceDir();192 Result.Sysroot = detectSysroot();193 return Result;194}195 196CommandMangler CommandMangler::forTests() { return CommandMangler(); }197 198void CommandMangler::operator()(tooling::CompileCommand &Command,199 llvm::StringRef File) const {200 std::vector<std::string> &Cmd = Command.CommandLine;201 trace::Span S("AdjustCompileFlags");202 // Most of the modifications below assumes the Cmd starts with a driver name.203 // We might consider injecting a generic driver name like "cc" or "c++", but204 // a Cmd missing the driver is probably rare enough in practice and erroneous.205 if (Cmd.empty())206 return;207 208 auto &OptTable = getDriverOptTable();209 // OriginalArgs needs to outlive ArgList.210 llvm::SmallVector<const char *, 16> OriginalArgs;211 OriginalArgs.reserve(Cmd.size());212 for (const auto &S : Cmd)213 OriginalArgs.push_back(S.c_str());214 bool IsCLMode = driver::IsClangCL(driver::getDriverMode(215 OriginalArgs[0], llvm::ArrayRef(OriginalArgs).slice(1)));216 // ParseArgs propagates missing arg/opt counts on error, but preserves217 // everything it could parse in ArgList. So we just ignore those counts.218 unsigned IgnoredCount;219 // Drop the executable name, as ParseArgs doesn't expect it. This means220 // indices are actually of by one between ArgList and OriginalArgs.221 llvm::opt::InputArgList ArgList;222 ArgList = OptTable.ParseArgs(223 llvm::ArrayRef(OriginalArgs).drop_front(), IgnoredCount, IgnoredCount,224 llvm::opt::Visibility(IsCLMode ? options::CLOption225 : options::ClangOption));226 227 llvm::SmallVector<unsigned, 1> IndicesToDrop;228 // Having multiple architecture options (e.g. when building fat binaries)229 // results in multiple compiler jobs, which clangd cannot handle. In such230 // cases strip all the `-arch` options and fallback to default architecture.231 // As there are no signals to figure out which one user actually wants. They232 // can explicitly specify one through `CompileFlags.Add` if need be.233 unsigned ArchOptCount = 0;234 for (auto *Input : ArgList.filtered(options::OPT_arch)) {235 ++ArchOptCount;236 for (auto I = 0U; I <= Input->getNumValues(); ++I)237 IndicesToDrop.push_back(Input->getIndex() + I);238 }239 // If there is a single `-arch` option, keep it.240 if (ArchOptCount < 2)241 IndicesToDrop.clear();242 243 // In some cases people may try to reuse the command from another file, e.g.244 // { File: "foo.h", CommandLine: "clang foo.cpp" }.245 // We assume the intent is to parse foo.h the same way as foo.cpp, or as if246 // it were being included from foo.cpp.247 //248 // We're going to rewrite the command to refer to foo.h, and this may change249 // its semantics (e.g. by parsing the file as C). If we do this, we should250 // use transferCompileCommand to adjust the argv.251 // In practice only the extension of the file matters, so do this only when252 // it differs.253 llvm::StringRef FileExtension = llvm::sys::path::extension(File);254 std::optional<std::string> TransferFrom;255 auto SawInput = [&](llvm::StringRef Input) {256 if (llvm::sys::path::extension(Input) != FileExtension)257 TransferFrom.emplace(Input);258 };259 260 // Strip all the inputs and `--`. We'll put the input for the requested file261 // explicitly at the end of the flags. This ensures modifications done in the262 // following steps apply in more cases (like setting -x, which only affects263 // inputs that come after it).264 for (auto *Input : ArgList.filtered(options::OPT_INPUT)) {265 SawInput(Input->getValue(0));266 IndicesToDrop.push_back(Input->getIndex());267 }268 // Anything after `--` is also treated as input, drop them as well.269 if (auto *DashDash = ArgList.getLastArgNoClaim(options::OPT__DASH_DASH)) {270 auto DashDashIndex = DashDash->getIndex() + 1; // +1 accounts for Cmd[0]271 // Another +1 so we don't treat the `--` itself as an input.272 for (unsigned I = DashDashIndex + 1; I < Cmd.size(); ++I)273 SawInput(Cmd[I]);274 Cmd.resize(DashDashIndex);275 }276 llvm::sort(IndicesToDrop);277 for (unsigned Idx : llvm::reverse(IndicesToDrop))278 // +1 to account for the executable name in Cmd[0] that279 // doesn't exist in ArgList.280 Cmd.erase(Cmd.begin() + Idx + 1);281 // All the inputs are stripped, append the name for the requested file. Rest282 // of the modifications should respect `--`.283 Cmd.push_back("--");284 Cmd.push_back(File.str());285 286 if (TransferFrom) {287 tooling::CompileCommand TransferCmd;288 TransferCmd.Filename = std::move(*TransferFrom);289 TransferCmd.CommandLine = std::move(Cmd);290 TransferCmd = transferCompileCommand(std::move(TransferCmd), File);291 Cmd = std::move(TransferCmd.CommandLine);292 assert(Cmd.size() >= 2 && Cmd.back() == File &&293 Cmd[Cmd.size() - 2] == "--" &&294 "TransferCommand should produce a command ending in -- filename");295 }296 297 for (auto &Edit : Config::current().CompileFlags.Edits)298 Edit(Cmd);299 300 // The system include extractor needs to run:301 // - AFTER transferCompileCommand(), because the -x flag it adds may be302 // necessary for the system include extractor to identify the file type303 // - AFTER applying CompileFlags.Edits, because the name of the compiler304 // that needs to be invoked may come from the CompileFlags->Compiler key305 // - BEFORE addTargetAndModeForProgramName(), because gcc doesn't support306 // the target flag that might be added.307 // - BEFORE resolveDriver() because that can mess up the driver path,308 // e.g. changing gcc to /path/to/clang/bin/gcc309 if (SystemIncludeExtractor) {310 SystemIncludeExtractor(Command, File);311 }312 313 tooling::addTargetAndModeForProgramName(Cmd, Cmd.front());314 315 // Check whether the flag exists in the command.316 auto HasExact = [&](llvm::StringRef Flag) {317 return llvm::is_contained(Cmd, Flag);318 };319 320 // Check whether the flag appears in the command as a prefix.321 auto HasPrefix = [&](llvm::StringRef Flag) {322 return llvm::any_of(323 Cmd, [&](llvm::StringRef Arg) { return Arg.starts_with(Flag); });324 };325 326 llvm::erase_if(Cmd, [](llvm::StringRef Elem) {327 return Elem.starts_with("--save-temps") || Elem.starts_with("-save-temps");328 });329 330 std::vector<std::string> ToAppend;331 if (ResourceDir && !HasExact("-resource-dir") && !HasPrefix("-resource-dir="))332 ToAppend.push_back(("-resource-dir=" + *ResourceDir));333 334 // Don't set `-isysroot` if it is already set or if `--sysroot` is set.335 // `--sysroot` is a superset of the `-isysroot` argument.336 if (Sysroot && !HasPrefix("-isysroot") && !HasExact("--sysroot") &&337 !HasPrefix("--sysroot=")) {338 ToAppend.push_back("-isysroot");339 ToAppend.push_back(*Sysroot);340 }341 342 if (!ToAppend.empty()) {343 Cmd.insert(llvm::find(Cmd, "--"), std::make_move_iterator(ToAppend.begin()),344 std::make_move_iterator(ToAppend.end()));345 }346 347 if (!Cmd.empty()) {348 bool FollowSymlink = !HasExact("-no-canonical-prefixes");349 Cmd.front() =350 (FollowSymlink ? ResolvedDrivers : ResolvedDriversNoFollow)351 .get(Cmd.front(), [&, this] {352 return resolveDriver(Cmd.front(), FollowSymlink, ClangPath);353 });354 }355}356 357// ArgStripper implementation358namespace {359 360// Determine total number of args consumed by this option.361// Return answers for {Exact, Prefix} match. 0 means not allowed.362std::pair<unsigned, unsigned> getArgCount(const llvm::opt::Option &Opt) {363 constexpr static unsigned Rest = 10000; // Should be all the rest!364 // Reference is llvm::opt::Option::acceptInternal()365 using llvm::opt::Option;366 switch (Opt.getKind()) {367 case Option::FlagClass:368 return {1, 0};369 case Option::JoinedClass:370 case Option::CommaJoinedClass:371 return {1, 1};372 case Option::GroupClass:373 case Option::InputClass:374 case Option::UnknownClass:375 case Option::ValuesClass:376 return {1, 0};377 case Option::JoinedAndSeparateClass:378 return {2, 2};379 case Option::SeparateClass:380 return {2, 0};381 case Option::MultiArgClass:382 return {1 + Opt.getNumArgs(), 0};383 case Option::JoinedOrSeparateClass:384 return {2, 1};385 case Option::RemainingArgsClass:386 return {Rest, 0};387 case Option::RemainingArgsJoinedClass:388 return {Rest, Rest};389 }390 llvm_unreachable("Unhandled option kind");391}392 393// Flag-parsing mode, which affects which flags are available.394enum DriverMode : unsigned char {395 DM_None = 0,396 DM_GCC = 1, // Default mode e.g. when invoked as 'clang'397 DM_CL = 2, // MS CL.exe compatible mode e.g. when invoked as 'clang-cl'398 DM_CC1 = 4, // When invoked as 'clang -cc1' or after '-Xclang'399 DM_All = 7400};401 402// Examine args list to determine if we're in GCC, CL-compatible, or cc1 mode.403DriverMode getDriverMode(const std::vector<std::string> &Args) {404 DriverMode Mode = DM_GCC;405 llvm::StringRef Argv0 = Args.front();406 Argv0.consume_back_insensitive(".exe");407 if (Argv0.ends_with_insensitive("cl"))408 Mode = DM_CL;409 for (const llvm::StringRef Arg : Args) {410 if (Arg == "--driver-mode=cl") {411 Mode = DM_CL;412 break;413 }414 if (Arg == "-cc1") {415 Mode = DM_CC1;416 break;417 }418 }419 return Mode;420}421 422// Returns the set of DriverModes where an option may be used.423unsigned char getModes(const llvm::opt::Option &Opt) {424 unsigned char Result = DM_None;425 if (Opt.hasVisibilityFlag(options::ClangOption))426 Result |= DM_GCC;427 if (Opt.hasVisibilityFlag(options::CC1Option))428 Result |= DM_CC1;429 if (Opt.hasVisibilityFlag(options::CLOption))430 Result |= DM_CL;431 return Result;432}433 434} // namespace435 436llvm::ArrayRef<ArgStripper::Rule> ArgStripper::rulesFor(llvm::StringRef Arg) {437 // All the hard work is done once in a static initializer.438 // We compute a table containing strings to look for and #args to skip.439 // e.g. "-x" => {-x 2 args, -x* 1 arg, --language 2 args, --language=* 1 arg}440 using TableTy =441 llvm::StringMap<llvm::SmallVector<Rule, 4>, llvm::BumpPtrAllocator>;442 static TableTy *Table = [] {443 auto &DriverTable = getDriverOptTable();444 using DriverID = clang::options::ID;445 446 // Collect sets of aliases, so we can treat -foo and -foo= as synonyms.447 // Conceptually a double-linked list: PrevAlias[I] -> I -> NextAlias[I].448 // If PrevAlias[I] is INVALID, then I is canonical.449 DriverID PrevAlias[DriverID::LastOption] = {DriverID::OPT_INVALID};450 DriverID NextAlias[DriverID::LastOption] = {DriverID::OPT_INVALID};451 auto AddAlias = [&](DriverID Self, DriverID T) {452 if (NextAlias[T]) {453 PrevAlias[NextAlias[T]] = Self;454 NextAlias[Self] = NextAlias[T];455 }456 PrevAlias[Self] = T;457 NextAlias[T] = Self;458 };459 460 struct {461 DriverID ID;462 DriverID AliasID;463 const void *AliasArgs;464 } AliasTable[] = {465#define OPTION(PREFIX, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \466 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, \467 METAVAR, VALUES, SUBCOMMANDIDS_OFFSET) \468 {DriverID::OPT_##ID, DriverID::OPT_##ALIAS, ALIASARGS},469#include "clang/Options/Options.inc"470#undef OPTION471 };472 for (auto &E : AliasTable)473 if (E.AliasID != DriverID::OPT_INVALID && E.AliasArgs == nullptr)474 AddAlias(E.ID, E.AliasID);475 476 auto Result = std::make_unique<TableTy>();477 // Iterate over distinct options (represented by the canonical alias).478 // Every spelling of this option will get the same set of rules.479 for (unsigned ID = 1 /*Skip INVALID */; ID < DriverID::LastOption; ++ID) {480 if (PrevAlias[ID] || ID == DriverID::OPT_Xclang)481 continue; // Not canonical, or specially handled.482 llvm::SmallVector<Rule> Rules;483 // Iterate over each alias, to add rules for parsing it.484 for (unsigned A = ID; A != DriverID::OPT_INVALID; A = NextAlias[A]) {485 llvm::SmallVector<llvm::StringRef, 4> Prefixes;486 DriverTable.appendOptionPrefixes(A, Prefixes);487 if (Prefixes.empty()) // option groups.488 continue;489 auto Opt = DriverTable.getOption(A);490 // Exclude - and -foo pseudo-options.491 if (Opt.getName().empty())492 continue;493 auto Modes = getModes(Opt);494 std::pair<unsigned, unsigned> ArgCount = getArgCount(Opt);495 // Iterate over each spelling of the alias, e.g. -foo vs --foo.496 for (StringRef Prefix : Prefixes) {497 llvm::SmallString<64> Buf(Prefix);498 Buf.append(Opt.getName());499 llvm::StringRef Spelling = Result->try_emplace(Buf).first->getKey();500 Rules.emplace_back();501 Rule &R = Rules.back();502 R.Text = Spelling;503 R.Modes = Modes;504 R.ExactArgs = ArgCount.first;505 R.PrefixArgs = ArgCount.second;506 // Concrete priority is the index into the option table.507 // Effectively, earlier entries take priority over later ones.508 assert(ID < std::numeric_limits<decltype(R.Priority)>::max() &&509 "Rules::Priority overflowed by options table");510 R.Priority = ID;511 }512 }513 // Register the set of rules under each possible name.514 for (const auto &R : Rules)515 Result->find(R.Text)->second.append(Rules.begin(), Rules.end());516 }517#ifndef NDEBUG518 // Dump the table and various measures of its size.519 unsigned RuleCount = 0;520 dlog("ArgStripper Option spelling table");521 for (const auto &Entry : *Result) {522 dlog("{0}", Entry.first());523 RuleCount += Entry.second.size();524 for (const auto &R : Entry.second)525 dlog(" {0} #={1} *={2} Mode={3}", R.Text, R.ExactArgs, R.PrefixArgs,526 int(R.Modes));527 }528 dlog("Table spellings={0} rules={1} string-bytes={2}", Result->size(),529 RuleCount, Result->getAllocator().getBytesAllocated());530#endif531 // The static table will never be destroyed.532 return Result.release();533 }();534 535 auto It = Table->find(Arg);536 return (It == Table->end()) ? llvm::ArrayRef<Rule>() : It->second;537}538 539void ArgStripper::strip(llvm::StringRef Arg) {540 auto OptionRules = rulesFor(Arg);541 if (OptionRules.empty()) {542 // Not a recognized flag. Strip it literally.543 Storage.emplace_back(Arg);544 Rules.emplace_back();545 Rules.back().Text = Storage.back();546 Rules.back().ExactArgs = 1;547 if (Rules.back().Text.consume_back("*"))548 Rules.back().PrefixArgs = 1;549 Rules.back().Modes = DM_All;550 Rules.back().Priority = -1; // Max unsigned = lowest priority.551 } else {552 Rules.append(OptionRules.begin(), OptionRules.end());553 }554}555 556const ArgStripper::Rule *ArgStripper::matchingRule(llvm::StringRef Arg,557 unsigned Mode,558 unsigned &ArgCount) const {559 const ArgStripper::Rule *BestRule = nullptr;560 for (const Rule &R : Rules) {561 // Rule can fail to match if...562 if (!(R.Modes & Mode))563 continue; // not applicable to current driver mode564 if (BestRule && BestRule->Priority < R.Priority)565 continue; // lower-priority than best candidate.566 if (!Arg.starts_with(R.Text))567 continue; // current arg doesn't match the prefix string568 bool PrefixMatch = Arg.size() > R.Text.size();569 // Can rule apply as an exact/prefix match?570 if (unsigned Count = PrefixMatch ? R.PrefixArgs : R.ExactArgs) {571 BestRule = &R;572 ArgCount = Count;573 }574 // Continue in case we find a higher-priority rule.575 }576 return BestRule;577}578 579void ArgStripper::process(std::vector<std::string> &Args) const {580 if (Args.empty())581 return;582 583 // We're parsing the args list in some mode (e.g. gcc-compatible) but may584 // temporarily switch to another mode with the -Xclang flag.585 DriverMode MainMode = getDriverMode(Args);586 DriverMode CurrentMode = MainMode;587 588 // Read and write heads for in-place deletion.589 unsigned Read = 0, Write = 0;590 bool WasXclang = false;591 while (Read < Args.size()) {592 unsigned ArgCount = 0;593 if (matchingRule(Args[Read], CurrentMode, ArgCount)) {594 // Delete it and its args.595 if (WasXclang) {596 assert(Write > 0);597 --Write; // Drop previous -Xclang arg598 CurrentMode = MainMode;599 WasXclang = false;600 }601 // Advance to last arg. An arg may be foo or -Xclang foo.602 for (unsigned I = 1; Read < Args.size() && I < ArgCount; ++I) {603 ++Read;604 if (Read < Args.size() && Args[Read] == "-Xclang")605 ++Read;606 }607 } else {608 // No match, just copy the arg through.609 WasXclang = Args[Read] == "-Xclang";610 CurrentMode = WasXclang ? DM_CC1 : MainMode;611 if (Write != Read)612 Args[Write] = std::move(Args[Read]);613 ++Write;614 }615 ++Read;616 }617 Args.resize(Write);618}619 620std::string printArgv(llvm::ArrayRef<llvm::StringRef> Args) {621 std::string Buf;622 llvm::raw_string_ostream OS(Buf);623 bool Sep = false;624 for (llvm::StringRef Arg : Args) {625 if (Sep)626 OS << ' ';627 Sep = true;628 if (llvm::all_of(Arg, llvm::isPrint) &&629 Arg.find_first_of(" \t\n\"\\") == llvm::StringRef::npos) {630 OS << Arg;631 continue;632 }633 OS << '"';634 OS.write_escaped(Arg, /*UseHexEscapes=*/true);635 OS << '"';636 }637 return std::move(OS.str());638}639 640std::string printArgv(llvm::ArrayRef<std::string> Args) {641 std::vector<llvm::StringRef> Refs(Args.size());642 llvm::copy(Args, Refs.begin());643 return printArgv(Refs);644}645 646} // namespace clangd647} // namespace clang648