clang-tools 19.0.0git
CompileCommands.cpp
Go to the documentation of this file.
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 <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 a
90// generic driver with no path.
91std::string detectClangPath() {
92 // The driver and/or cc1 sometimes depend on the binary name to compute
93 // 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, and
96 // 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 knows
100 // 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#endif
106 // 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#endif
126
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 CompilerInvocation::GetResourcesPath("clangd",
136 (void *)&StaticForMainAddr);
137}
138
139// The path passed to argv[0] is important:
140// - its parent directory is Driver::Dir, used for library discovery
141// - its basename affects CLI parsing (clang-cl) and other settings
142// Where possible it should be an absolute path with sensible directory, but
143// with the original basename.
144static std::string resolveDriver(llvm::StringRef Driver, bool FollowSymlink,
145 std::optional<std::string> ClangPath) {
146 auto SiblingOf = [&](llvm::StringRef AbsPath) {
147 llvm::SmallString<128> Result = llvm::sys::path::parent_path(AbsPath);
148 llvm::sys::path::append(Result, llvm::sys::path::filename(Driver));
149 return Result.str().str();
150 };
151
152 // First, eliminate relative paths.
153 std::string Storage;
154 if (!llvm::sys::path::is_absolute(Driver)) {
155 // If it's working-dir relative like bin/clang, we can't resolve it.
156 // FIXME: we could if we had the working directory here.
157 // Let's hope it's not a symlink.
158 if (llvm::any_of(Driver,
159 [](char C) { return llvm::sys::path::is_separator(C); }))
160 return Driver.str();
161 // If the driver is a generic like "g++" with no path, add clang dir.
162 if (ClangPath &&
163 (Driver == "clang" || Driver == "clang++" || Driver == "gcc" ||
164 Driver == "g++" || Driver == "cc" || Driver == "c++")) {
165 return SiblingOf(*ClangPath);
166 }
167 // Otherwise try to look it up on PATH. This won't change basename.
168 auto Absolute = llvm::sys::findProgramByName(Driver);
169 if (Absolute && llvm::sys::path::is_absolute(*Absolute))
170 Driver = Storage = std::move(*Absolute);
171 else if (ClangPath) // If we don't find it, use clang dir again.
172 return SiblingOf(*ClangPath);
173 else // Nothing to do: can't find the command and no detected dir.
174 return Driver.str();
175 }
176
177 // Now we have an absolute path, but it may be a symlink.
178 assert(llvm::sys::path::is_absolute(Driver));
179 if (FollowSymlink) {
180 llvm::SmallString<256> Resolved;
181 if (!llvm::sys::fs::real_path(Driver, Resolved))
182 return SiblingOf(Resolved);
183 }
184 return Driver.str();
185}
186
187} // namespace
188
190 CommandMangler Result;
191 Result.ClangPath = detectClangPath();
192 Result.ResourceDir = detectStandardResourceDir();
193 Result.Sysroot = detectSysroot();
194 return Result;
195}
196
198
199void CommandMangler::operator()(tooling::CompileCommand &Command,
200 llvm::StringRef File) const {
201 std::vector<std::string> &Cmd = Command.CommandLine;
202 trace::Span S("AdjustCompileFlags");
203 // Most of the modifications below assumes the Cmd starts with a driver name.
204 // We might consider injecting a generic driver name like "cc" or "c++", but
205 // a Cmd missing the driver is probably rare enough in practice and erroneous.
206 if (Cmd.empty())
207 return;
208
209 auto &OptTable = clang::driver::getDriverOptTable();
210 // OriginalArgs needs to outlive ArgList.
211 llvm::SmallVector<const char *, 16> OriginalArgs;
212 OriginalArgs.reserve(Cmd.size());
213 for (const auto &S : Cmd)
214 OriginalArgs.push_back(S.c_str());
215 bool IsCLMode = driver::IsClangCL(driver::getDriverMode(
216 OriginalArgs[0], llvm::ArrayRef(OriginalArgs).slice(1)));
217 // ParseArgs propagates missing arg/opt counts on error, but preserves
218 // everything it could parse in ArgList. So we just ignore those counts.
219 unsigned IgnoredCount;
220 // Drop the executable name, as ParseArgs doesn't expect it. This means
221 // indices are actually of by one between ArgList and OriginalArgs.
222 llvm::opt::InputArgList ArgList;
223 ArgList = OptTable.ParseArgs(
224 llvm::ArrayRef(OriginalArgs).drop_front(), IgnoredCount, IgnoredCount,
225 llvm::opt::Visibility(IsCLMode ? driver::options::CLOption
226 : driver::options::ClangOption));
227
228 llvm::SmallVector<unsigned, 1> IndicesToDrop;
229 // Having multiple architecture options (e.g. when building fat binaries)
230 // results in multiple compiler jobs, which clangd cannot handle. In such
231 // cases strip all the `-arch` options and fallback to default architecture.
232 // As there are no signals to figure out which one user actually wants. They
233 // can explicitly specify one through `CompileFlags.Add` if need be.
234 unsigned ArchOptCount = 0;
235 for (auto *Input : ArgList.filtered(driver::options::OPT_arch)) {
236 ++ArchOptCount;
237 for (auto I = 0U; I <= Input->getNumValues(); ++I)
238 IndicesToDrop.push_back(Input->getIndex() + I);
239 }
240 // If there is a single `-arch` option, keep it.
241 if (ArchOptCount < 2)
242 IndicesToDrop.clear();
243
244 // In some cases people may try to reuse the command from another file, e.g.
245 // { File: "foo.h", CommandLine: "clang foo.cpp" }.
246 // We assume the intent is to parse foo.h the same way as foo.cpp, or as if
247 // it were being included from foo.cpp.
248 //
249 // We're going to rewrite the command to refer to foo.h, and this may change
250 // its semantics (e.g. by parsing the file as C). If we do this, we should
251 // use transferCompileCommand to adjust the argv.
252 // In practice only the extension of the file matters, so do this only when
253 // it differs.
254 llvm::StringRef FileExtension = llvm::sys::path::extension(File);
255 std::optional<std::string> TransferFrom;
256 auto SawInput = [&](llvm::StringRef Input) {
257 if (llvm::sys::path::extension(Input) != FileExtension)
258 TransferFrom.emplace(Input);
259 };
260
261 // Strip all the inputs and `--`. We'll put the input for the requested file
262 // explicitly at the end of the flags. This ensures modifications done in the
263 // following steps apply in more cases (like setting -x, which only affects
264 // inputs that come after it).
265 for (auto *Input : ArgList.filtered(driver::options::OPT_INPUT)) {
266 SawInput(Input->getValue(0));
267 IndicesToDrop.push_back(Input->getIndex());
268 }
269 // Anything after `--` is also treated as input, drop them as well.
270 if (auto *DashDash =
271 ArgList.getLastArgNoClaim(driver::options::OPT__DASH_DASH)) {
272 auto DashDashIndex = DashDash->getIndex() + 1; // +1 accounts for Cmd[0]
273 for (unsigned I = DashDashIndex; I < Cmd.size(); ++I)
274 SawInput(Cmd[I]);
275 Cmd.resize(DashDashIndex);
276 }
277 llvm::sort(IndicesToDrop);
278 for (unsigned Idx : llvm::reverse(IndicesToDrop))
279 // +1 to account for the executable name in Cmd[0] that
280 // doesn't exist in ArgList.
281 Cmd.erase(Cmd.begin() + Idx + 1);
282 // All the inputs are stripped, append the name for the requested file. Rest
283 // of the modifications should respect `--`.
284 Cmd.push_back("--");
285 Cmd.push_back(File.str());
286
287 if (TransferFrom) {
288 tooling::CompileCommand TransferCmd;
289 TransferCmd.Filename = std::move(*TransferFrom);
290 TransferCmd.CommandLine = std::move(Cmd);
291 TransferCmd = transferCompileCommand(std::move(TransferCmd), File);
292 Cmd = std::move(TransferCmd.CommandLine);
293 assert(Cmd.size() >= 2 && Cmd.back() == File &&
294 Cmd[Cmd.size() - 2] == "--" &&
295 "TransferCommand should produce a command ending in -- filename");
296 }
297
298 for (auto &Edit : Config::current().CompileFlags.Edits)
299 Edit(Cmd);
300
301 // The system include extractor needs to run:
302 // - AFTER transferCompileCommand(), because the -x flag it adds may be
303 // necessary for the system include extractor to identify the file type
304 // - AFTER applying CompileFlags.Edits, because the name of the compiler
305 // that needs to be invoked may come from the CompileFlags->Compiler key
306 // - BEFORE addTargetAndModeForProgramName(), because gcc doesn't support
307 // the target flag that might be added.
308 // - BEFORE resolveDriver() because that can mess up the driver path,
309 // e.g. changing gcc to /path/to/clang/bin/gcc
312 }
313
314 tooling::addTargetAndModeForProgramName(Cmd, Cmd.front());
315
316 // Check whether the flag exists in the command.
317 auto HasExact = [&](llvm::StringRef Flag) {
318 return llvm::any_of(Cmd, [&](llvm::StringRef Arg) { return Arg == Flag; });
319 };
320
321 // Check whether the flag appears in the command as a prefix.
322 auto HasPrefix = [&](llvm::StringRef Flag) {
323 return llvm::any_of(
324 Cmd, [&](llvm::StringRef Arg) { return Arg.starts_with(Flag); });
325 };
326
327 llvm::erase_if(Cmd, [](llvm::StringRef Elem) {
328 return Elem.starts_with("--save-temps") || Elem.starts_with("-save-temps");
329 });
330
331 std::vector<std::string> ToAppend;
332 if (ResourceDir && !HasExact("-resource-dir") && !HasPrefix("-resource-dir="))
333 ToAppend.push_back(("-resource-dir=" + *ResourceDir));
334
335 // Don't set `-isysroot` if it is already set or if `--sysroot` is set.
336 // `--sysroot` is a superset of the `-isysroot` argument.
337 if (Sysroot && !HasPrefix("-isysroot") && !HasExact("--sysroot") &&
338 !HasPrefix("--sysroot=")) {
339 ToAppend.push_back("-isysroot");
340 ToAppend.push_back(*Sysroot);
341 }
342
343 if (!ToAppend.empty()) {
344 Cmd.insert(llvm::find(Cmd, "--"), std::make_move_iterator(ToAppend.begin()),
345 std::make_move_iterator(ToAppend.end()));
346 }
347
348 if (!Cmd.empty()) {
349 bool FollowSymlink = !HasExact("-no-canonical-prefixes");
350 Cmd.front() =
351 (FollowSymlink ? ResolvedDrivers : ResolvedDriversNoFollow)
352 .get(Cmd.front(), [&, this] {
353 return resolveDriver(Cmd.front(), FollowSymlink, ClangPath);
354 });
355 }
356}
357
358// ArgStripper implementation
359namespace {
360
361// Determine total number of args consumed by this option.
362// Return answers for {Exact, Prefix} match. 0 means not allowed.
363std::pair<unsigned, unsigned> getArgCount(const llvm::opt::Option &Opt) {
364 constexpr static unsigned Rest = 10000; // Should be all the rest!
365 // Reference is llvm::opt::Option::acceptInternal()
366 using llvm::opt::Option;
367 switch (Opt.getKind()) {
368 case Option::FlagClass:
369 return {1, 0};
370 case Option::JoinedClass:
371 case Option::CommaJoinedClass:
372 return {1, 1};
373 case Option::GroupClass:
374 case Option::InputClass:
375 case Option::UnknownClass:
376 case Option::ValuesClass:
377 return {1, 0};
378 case Option::JoinedAndSeparateClass:
379 return {2, 2};
380 case Option::SeparateClass:
381 return {2, 0};
382 case Option::MultiArgClass:
383 return {1 + Opt.getNumArgs(), 0};
384 case Option::JoinedOrSeparateClass:
385 return {2, 1};
386 case Option::RemainingArgsClass:
387 return {Rest, 0};
388 case Option::RemainingArgsJoinedClass:
389 return {Rest, Rest};
390 }
391 llvm_unreachable("Unhandled option kind");
392}
393
394// Flag-parsing mode, which affects which flags are available.
395enum DriverMode : unsigned char {
396 DM_None = 0,
397 DM_GCC = 1, // Default mode e.g. when invoked as 'clang'
398 DM_CL = 2, // MS CL.exe compatible mode e.g. when invoked as 'clang-cl'
399 DM_CC1 = 4, // When invoked as 'clang -cc1' or after '-Xclang'
400 DM_All = 7
401};
402
403// Examine args list to determine if we're in GCC, CL-compatible, or cc1 mode.
404DriverMode getDriverMode(const std::vector<std::string> &Args) {
405 DriverMode Mode = DM_GCC;
406 llvm::StringRef Argv0 = Args.front();
407 if (Argv0.ends_with_insensitive(".exe"))
408 Argv0 = Argv0.drop_back(strlen(".exe"));
409 if (Argv0.ends_with_insensitive("cl"))
410 Mode = DM_CL;
411 for (const llvm::StringRef Arg : Args) {
412 if (Arg == "--driver-mode=cl") {
413 Mode = DM_CL;
414 break;
415 }
416 if (Arg == "-cc1") {
417 Mode = DM_CC1;
418 break;
419 }
420 }
421 return Mode;
422}
423
424// Returns the set of DriverModes where an option may be used.
425unsigned char getModes(const llvm::opt::Option &Opt) {
426 unsigned char Result = DM_None;
427 if (Opt.hasVisibilityFlag(driver::options::ClangOption))
428 Result |= DM_GCC;
429 if (Opt.hasVisibilityFlag(driver::options::CC1Option))
430 Result |= DM_CC1;
431 if (Opt.hasVisibilityFlag(driver::options::CLOption))
432 Result |= DM_CL;
433 return Result;
434}
435
436} // namespace
437
438llvm::ArrayRef<ArgStripper::Rule> ArgStripper::rulesFor(llvm::StringRef Arg) {
439 // All the hard work is done once in a static initializer.
440 // We compute a table containing strings to look for and #args to skip.
441 // e.g. "-x" => {-x 2 args, -x* 1 arg, --language 2 args, --language=* 1 arg}
442 using TableTy =
443 llvm::StringMap<llvm::SmallVector<Rule, 4>, llvm::BumpPtrAllocator>;
444 static TableTy *Table = [] {
445 auto &DriverTable = driver::getDriverOptTable();
446 using DriverID = clang::driver::options::ID;
447
448 // Collect sets of aliases, so we can treat -foo and -foo= as synonyms.
449 // Conceptually a double-linked list: PrevAlias[I] -> I -> NextAlias[I].
450 // If PrevAlias[I] is INVALID, then I is canonical.
451 DriverID PrevAlias[DriverID::LastOption] = {DriverID::OPT_INVALID};
452 DriverID NextAlias[DriverID::LastOption] = {DriverID::OPT_INVALID};
453 auto AddAlias = [&](DriverID Self, DriverID T) {
454 if (NextAlias[T]) {
455 PrevAlias[NextAlias[T]] = Self;
456 NextAlias[Self] = NextAlias[T];
457 }
458 PrevAlias[Self] = T;
459 NextAlias[T] = Self;
460 };
461 // Also grab prefixes for each option, these are not fully exposed.
462 llvm::ArrayRef<llvm::StringLiteral> Prefixes[DriverID::LastOption];
463
464#define PREFIX(NAME, VALUE) \
465 static constexpr llvm::StringLiteral NAME##_init[] = VALUE; \
466 static constexpr llvm::ArrayRef<llvm::StringLiteral> NAME( \
467 NAME##_init, std::size(NAME##_init) - 1);
468#define OPTION(PREFIX, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \
469 FLAGS, VISIBILITY, PARAM, HELP, METAVAR, VALUES) \
470 Prefixes[DriverID::OPT_##ID] = PREFIX;
471#include "clang/Driver/Options.inc"
472#undef OPTION
473#undef PREFIX
474
475 struct {
476 DriverID ID;
477 DriverID AliasID;
478 const void *AliasArgs;
479 } AliasTable[] = {
480#define OPTION(PREFIX, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \
481 FLAGS, VISIBILITY, PARAM, HELP, METAVAR, VALUES) \
482 {DriverID::OPT_##ID, DriverID::OPT_##ALIAS, ALIASARGS},
483#include "clang/Driver/Options.inc"
484#undef OPTION
485 };
486 for (auto &E : AliasTable)
487 if (E.AliasID != DriverID::OPT_INVALID && E.AliasArgs == nullptr)
488 AddAlias(E.ID, E.AliasID);
489
490 auto Result = std::make_unique<TableTy>();
491 // Iterate over distinct options (represented by the canonical alias).
492 // Every spelling of this option will get the same set of rules.
493 for (unsigned ID = 1 /*Skip INVALID */; ID < DriverID::LastOption; ++ID) {
494 if (PrevAlias[ID] || ID == DriverID::OPT_Xclang)
495 continue; // Not canonical, or specially handled.
496 llvm::SmallVector<Rule> Rules;
497 // Iterate over each alias, to add rules for parsing it.
498 for (unsigned A = ID; A != DriverID::OPT_INVALID; A = NextAlias[A]) {
499 if (!Prefixes[A].size()) // option groups.
500 continue;
501 auto Opt = DriverTable.getOption(A);
502 // Exclude - and -foo pseudo-options.
503 if (Opt.getName().empty())
504 continue;
505 auto Modes = getModes(Opt);
506 std::pair<unsigned, unsigned> ArgCount = getArgCount(Opt);
507 // Iterate over each spelling of the alias, e.g. -foo vs --foo.
508 for (StringRef Prefix : Prefixes[A]) {
509 llvm::SmallString<64> Buf(Prefix);
510 Buf.append(Opt.getName());
511 llvm::StringRef Spelling = Result->try_emplace(Buf).first->getKey();
512 Rules.emplace_back();
513 Rule &R = Rules.back();
514 R.Text = Spelling;
515 R.Modes = Modes;
516 R.ExactArgs = ArgCount.first;
517 R.PrefixArgs = ArgCount.second;
518 // Concrete priority is the index into the option table.
519 // Effectively, earlier entries take priority over later ones.
520 assert(ID < std::numeric_limits<decltype(R.Priority)>::max() &&
521 "Rules::Priority overflowed by options table");
522 R.Priority = ID;
523 }
524 }
525 // Register the set of rules under each possible name.
526 for (const auto &R : Rules)
527 Result->find(R.Text)->second.append(Rules.begin(), Rules.end());
528 }
529#ifndef NDEBUG
530 // Dump the table and various measures of its size.
531 unsigned RuleCount = 0;
532 dlog("ArgStripper Option spelling table");
533 for (const auto &Entry : *Result) {
534 dlog("{0}", Entry.first());
535 RuleCount += Entry.second.size();
536 for (const auto &R : Entry.second)
537 dlog(" {0} #={1} *={2} Mode={3}", R.Text, R.ExactArgs, R.PrefixArgs,
538 int(R.Modes));
539 }
540 dlog("Table spellings={0} rules={1} string-bytes={2}", Result->size(),
541 RuleCount, Result->getAllocator().getBytesAllocated());
542#endif
543 // The static table will never be destroyed.
544 return Result.release();
545 }();
546
547 auto It = Table->find(Arg);
548 return (It == Table->end()) ? llvm::ArrayRef<Rule>() : It->second;
549}
550
551void ArgStripper::strip(llvm::StringRef Arg) {
552 auto OptionRules = rulesFor(Arg);
553 if (OptionRules.empty()) {
554 // Not a recognized flag. Strip it literally.
555 Storage.emplace_back(Arg);
556 Rules.emplace_back();
557 Rules.back().Text = Storage.back();
558 Rules.back().ExactArgs = 1;
559 if (Rules.back().Text.consume_back("*"))
560 Rules.back().PrefixArgs = 1;
561 Rules.back().Modes = DM_All;
562 Rules.back().Priority = -1; // Max unsigned = lowest priority.
563 } else {
564 Rules.append(OptionRules.begin(), OptionRules.end());
565 }
566}
567
568const ArgStripper::Rule *ArgStripper::matchingRule(llvm::StringRef Arg,
569 unsigned Mode,
570 unsigned &ArgCount) const {
571 const ArgStripper::Rule *BestRule = nullptr;
572 for (const Rule &R : Rules) {
573 // Rule can fail to match if...
574 if (!(R.Modes & Mode))
575 continue; // not applicable to current driver mode
576 if (BestRule && BestRule->Priority < R.Priority)
577 continue; // lower-priority than best candidate.
578 if (!Arg.starts_with(R.Text))
579 continue; // current arg doesn't match the prefix string
580 bool PrefixMatch = Arg.size() > R.Text.size();
581 // Can rule apply as an exact/prefix match?
582 if (unsigned Count = PrefixMatch ? R.PrefixArgs : R.ExactArgs) {
583 BestRule = &R;
584 ArgCount = Count;
585 }
586 // Continue in case we find a higher-priority rule.
587 }
588 return BestRule;
589}
590
591void ArgStripper::process(std::vector<std::string> &Args) const {
592 if (Args.empty())
593 return;
594
595 // We're parsing the args list in some mode (e.g. gcc-compatible) but may
596 // temporarily switch to another mode with the -Xclang flag.
597 DriverMode MainMode = getDriverMode(Args);
598 DriverMode CurrentMode = MainMode;
599
600 // Read and write heads for in-place deletion.
601 unsigned Read = 0, Write = 0;
602 bool WasXclang = false;
603 while (Read < Args.size()) {
604 unsigned ArgCount = 0;
605 if (matchingRule(Args[Read], CurrentMode, ArgCount)) {
606 // Delete it and its args.
607 if (WasXclang) {
608 assert(Write > 0);
609 --Write; // Drop previous -Xclang arg
610 CurrentMode = MainMode;
611 WasXclang = false;
612 }
613 // Advance to last arg. An arg may be foo or -Xclang foo.
614 for (unsigned I = 1; Read < Args.size() && I < ArgCount; ++I) {
615 ++Read;
616 if (Read < Args.size() && Args[Read] == "-Xclang")
617 ++Read;
618 }
619 } else {
620 // No match, just copy the arg through.
621 WasXclang = Args[Read] == "-Xclang";
622 CurrentMode = WasXclang ? DM_CC1 : MainMode;
623 if (Write != Read)
624 Args[Write] = std::move(Args[Read]);
625 ++Write;
626 }
627 ++Read;
628 }
629 Args.resize(Write);
630}
631
632std::string printArgv(llvm::ArrayRef<llvm::StringRef> Args) {
633 std::string Buf;
634 llvm::raw_string_ostream OS(Buf);
635 bool Sep = false;
636 for (llvm::StringRef Arg : Args) {
637 if (Sep)
638 OS << ' ';
639 Sep = true;
640 if (llvm::all_of(Arg, llvm::isPrint) &&
641 Arg.find_first_of(" \t\n\"\\") == llvm::StringRef::npos) {
642 OS << Arg;
643 continue;
644 }
645 OS << '"';
646 OS.write_escaped(Arg, /*UseHexEscapes=*/true);
647 OS << '"';
648 }
649 return std::move(OS.str());
650}
651
652std::string printArgv(llvm::ArrayRef<std::string> Args) {
653 std::vector<llvm::StringRef> Refs(Args.size());
654 llvm::copy(Args, Refs.begin());
655 return printArgv(Refs);
656}
657
658} // namespace clangd
659} // namespace clang
const Expr * E
llvm::SmallString< 256U > Name
const Criteria C
#define dlog(...)
Definition: Logger.h:101
const char * Argv0
Definition: Modularize.cpp:333
std::string Driver
llvm::raw_string_ostream OS
Definition: TraceTests.cpp:160
llvm::json::Object Args
Definition: Trace.cpp:138
void process(std::vector< std::string > &Args) const
void strip(llvm::StringRef Arg)
Records an event whose duration is the lifetime of the Span object.
Definition: Trace.h:143
std::string Path
A typedef to represent a file path.
Definition: Path.h:26
void vlog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:72
void log(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:67
std::string printArgv(llvm::ArrayRef< llvm::StringRef > Args)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
std::optional< std::string > ResourceDir
static CommandMangler detect()
SystemIncludeExtractorFn SystemIncludeExtractor
std::optional< std::string > ClangPath
std::optional< std::string > Sysroot
static CommandMangler forTests()
void operator()(tooling::CompileCommand &Cmd, llvm::StringRef TargetFile) const
static const Config & current()
Returns the Config of the current Context, or an empty configuration.
Definition: Config.cpp:17
std::vector< llvm::unique_function< void(std::vector< std::string > &) const > > Edits
Edits to apply to the compile command, in sequence.
Definition: Config.h:66
A set of edits generated for a single file.
Definition: SourceCode.h:189