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