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, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ |
497 | 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, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ |
509 | 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 | |