1	//===-- CommandLine.cpp - Command line parser implementation --------------===//
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	// This class implements a command line argument processor that is useful when
10	// creating a tool. It provides a simple, minimalistic interface that is easily
11	// extensible and supports nonlocal (library) command line options.
12	//
13	// Note that rather than trying to figure out what this code does, you could try
14	// reading the library documentation located in docs/CommandLine.html
15	//
16	//===----------------------------------------------------------------------===//
17
18	#include "llvm/Support/CommandLine.h"
19
20	#include "DebugOptions.h"
21
22	#include "llvm-c/Support.h"
23	#include "llvm/ADT/ArrayRef.h"
24	#include "llvm/ADT/STLFunctionalExtras.h"
25	#include "llvm/ADT/SmallPtrSet.h"
26	#include "llvm/ADT/SmallString.h"
27	#include "llvm/ADT/StringExtras.h"
28	#include "llvm/ADT/StringMap.h"
29	#include "llvm/ADT/StringRef.h"
30	#include "llvm/ADT/Twine.h"
31	#include "llvm/Config/config.h"
32	#include "llvm/Support/ConvertUTF.h"
33	#include "llvm/Support/Debug.h"
34	#include "llvm/Support/Error.h"
35	#include "llvm/Support/ErrorHandling.h"
36	#include "llvm/Support/FileSystem.h"
37	#include "llvm/Support/ManagedStatic.h"
38	#include "llvm/Support/MemoryBuffer.h"
39	#include "llvm/Support/Path.h"
40	#include "llvm/Support/Process.h"
41	#include "llvm/Support/StringSaver.h"
42	#include "llvm/Support/VirtualFileSystem.h"
43	#include "llvm/Support/raw_ostream.h"
44	#include <cstdlib>
45	#include <optional>
46	#include <string>
47	using namespace llvm;
48	using namespace cl;
49
50	#define DEBUG_TYPE "commandline"
51
52	//===----------------------------------------------------------------------===//
53	// Template instantiations and anchors.
54	//
55	namespace llvm {
56	namespace cl {
57	template class basic_parser<bool>;
58	template class basic_parser<boolOrDefault>;
59	template class basic_parser<int>;
60	template class basic_parser<long>;
61	template class basic_parser<long long>;
62	template class basic_parser<unsigned>;
63	template class basic_parser<unsigned long>;
64	template class basic_parser<unsigned long long>;
65	template class basic_parser<double>;
66	template class basic_parser<float>;
67	template class basic_parser<std::string>;
68	template class basic_parser<char>;
69
70	template class opt<unsigned>;
71	template class opt<int>;
72	template class opt<std::string>;
73	template class opt<char>;
74	template class opt<bool>;
75	} // namespace cl
76	} // namespace llvm
77
78	// Pin the vtables to this file.
79	void GenericOptionValue::anchor() {}
80	void OptionValue<boolOrDefault>::anchor() {}
81	void OptionValue<std::string>::anchor() {}
82	void Option::anchor() {}
83	void basic_parser_impl::anchor() {}
84	void parser<bool>::anchor() {}
85	void parser<boolOrDefault>::anchor() {}
86	void parser<int>::anchor() {}
87	void parser<long>::anchor() {}
88	void parser<long long>::anchor() {}
89	void parser<unsigned>::anchor() {}
90	void parser<unsigned long>::anchor() {}
91	void parser<unsigned long long>::anchor() {}
92	void parser<double>::anchor() {}
93	void parser<float>::anchor() {}
94	void parser<std::string>::anchor() {}
95	void parser<char>::anchor() {}
96
97	//===----------------------------------------------------------------------===//
98
99	const static size_t DefaultPad = 2;
100
101	static StringRef ArgPrefix = "-";
102	static StringRef ArgPrefixLong = "--";
103	static StringRef ArgHelpPrefix = " - ";
104
105	static size_t argPlusPrefixesSize(StringRef ArgName, size_t Pad = DefaultPad) {
106	size_t Len = ArgName.size();
107	if (Len == 1)
108	return Len + Pad + ArgPrefix.size() + ArgHelpPrefix.size();
109	return Len + Pad + ArgPrefixLong.size() + ArgHelpPrefix.size();
110	}
111
112	static SmallString<8> argPrefix(StringRef ArgName, size_t Pad = DefaultPad) {
113	SmallString<8> Prefix;
114	for (size_t I = 0; I < Pad; ++I) {
115	Prefix.push_back(Elt: ' ');
116	}
117	Prefix.append(RHS: ArgName.size() > 1 ? ArgPrefixLong : ArgPrefix);
118	return Prefix;
119	}
120
121	// Option predicates...
122	static inline bool isGrouping(const Option *O) {
123	return O->getMiscFlags() & cl::Grouping;
124	}
125	static inline bool isPrefixedOrGrouping(const Option *O) {
126	return isGrouping(O) || O->getFormattingFlag() == cl::Prefix ||
127	O->getFormattingFlag() == cl::AlwaysPrefix;
128	}
129
130
131	namespace {
132
133	class PrintArg {
134	StringRef ArgName;
135	size_t Pad;
136	public:
137	PrintArg(StringRef ArgName, size_t Pad = DefaultPad) : ArgName(ArgName), Pad(Pad) {}
138	friend raw_ostream &operator<<(raw_ostream &OS, const PrintArg &);
139	};
140
141	raw_ostream &operator<<(raw_ostream &OS, const PrintArg& Arg) {
142	OS << argPrefix(ArgName: Arg.ArgName, Pad: Arg.Pad) << Arg.ArgName;
143	return OS;
144	}
145
146	class CommandLineParser {
147	public:
148	// Globals for name and overview of program. Program name is not a string to
149	// avoid static ctor/dtor issues.
150	std::string ProgramName;
151	StringRef ProgramOverview;
152
153	// This collects additional help to be printed.
154	std::vector<StringRef> MoreHelp;
155
156	// This collects Options added with the cl::DefaultOption flag. Since they can
157	// be overridden, they are not added to the appropriate SubCommands until
158	// ParseCommandLineOptions actually runs.
159	SmallVector<Option*, 4> DefaultOptions;
160
161	// This collects the different option categories that have been registered.
162	SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
163
164	// This collects the different subcommands that have been registered.
165	SmallPtrSet<SubCommand *, 4> RegisteredSubCommands;
166
167	CommandLineParser() { registerSubCommand(sub: &SubCommand::getTopLevel()); }
168
169	void ResetAllOptionOccurrences();
170
171	bool ParseCommandLineOptions(int argc, const char *const *argv,
172	StringRef Overview, raw_ostream *Errs = nullptr,
173	bool LongOptionsUseDoubleDash = false);
174
175	void forEachSubCommand(Option &Opt, function_ref<void(SubCommand &)> Action) {
176	if (Opt.Subs.empty()) {
177	Action(SubCommand::getTopLevel());
178	return;
179	}
180	if (Opt.Subs.size() == 1 && *Opt.Subs.begin() == &SubCommand::getAll()) {
181	for (auto *SC : RegisteredSubCommands)
182	Action(*SC);
183	Action(SubCommand::getAll());
184	return;
185	}
186	for (auto *SC : Opt.Subs) {
187	assert(SC != &SubCommand::getAll() &&
188	"SubCommand::getAll() should not be used with other subcommands");
189	Action(*SC);
190	}
191	}
192
193	void addLiteralOption(Option &Opt, SubCommand *SC, StringRef Name) {
194	if (Opt.hasArgStr())
195	return;
196	if (!SC->OptionsMap.insert(KV: std::make_pair(x&: Name, y: &Opt)).second) {
197	errs() << ProgramName << ": CommandLine Error: Option '" << Name
198	<< "' registered more than once!\n";
199	report_fatal_error(reason: "inconsistency in registered CommandLine options");
200	}
201	}
202
203	void addLiteralOption(Option &Opt, StringRef Name) {
204	forEachSubCommand(
205	Opt, Action: [&](SubCommand &SC) { addLiteralOption(Opt, SC: &SC, Name); });
206	}
207
208	void addOption(Option *O, SubCommand *SC) {
209	bool HadErrors = false;
210	if (O->hasArgStr()) {
211	// If it's a DefaultOption, check to make sure it isn't already there.
212	if (O->isDefaultOption() && SC->OptionsMap.contains(Key: O->ArgStr))
213	return;
214
215	// Add argument to the argument map!
216	if (!SC->OptionsMap.insert(KV: std::make_pair(x&: O->ArgStr, y&: O)).second) {
217	errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
218	<< "' registered more than once!\n";
219	HadErrors = true;
220	}
221	}
222
223	// Remember information about positional options.
224	if (O->getFormattingFlag() == cl::Positional)
225	SC->PositionalOpts.push_back(Elt: O);
226	else if (O->getMiscFlags() & cl::Sink) // Remember sink options
227	SC->SinkOpts.push_back(Elt: O);
228	else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
229	if (SC->ConsumeAfterOpt) {
230	O->error(Message: "Cannot specify more than one option with cl::ConsumeAfter!");
231	HadErrors = true;
232	}
233	SC->ConsumeAfterOpt = O;
234	}
235
236	// Fail hard if there were errors. These are strictly unrecoverable and
237	// indicate serious issues such as conflicting option names or an
238	// incorrectly
239	// linked LLVM distribution.
240	if (HadErrors)
241	report_fatal_error(reason: "inconsistency in registered CommandLine options");
242	}
243
244	void addOption(Option *O, bool ProcessDefaultOption = false) {
245	if (!ProcessDefaultOption && O->isDefaultOption()) {
246	DefaultOptions.push_back(Elt: O);
247	return;
248	}
249	forEachSubCommand(Opt&: *O, Action: [&](SubCommand &SC) { addOption(O, SC: &SC); });
250	}
251
252	void removeOption(Option *O, SubCommand *SC) {
253	SmallVector<StringRef, 16> OptionNames;
254	O->getExtraOptionNames(OptionNames);
255	if (O->hasArgStr())
256	OptionNames.push_back(Elt: O->ArgStr);
257
258	SubCommand &Sub = *SC;
259	auto End = Sub.OptionsMap.end();
260	for (auto Name : OptionNames) {
261	auto I = Sub.OptionsMap.find(Key: Name);
262	if (I != End && I->getValue() == O)
263	Sub.OptionsMap.erase(I);
264	}
265
266	if (O->getFormattingFlag() == cl::Positional)
267	for (auto *Opt = Sub.PositionalOpts.begin();
268	Opt != Sub.PositionalOpts.end(); ++Opt) {
269	if (*Opt == O) {
270	Sub.PositionalOpts.erase(CI: Opt);
271	break;
272	}
273	}
274	else if (O->getMiscFlags() & cl::Sink)
275	for (auto *Opt = Sub.SinkOpts.begin(); Opt != Sub.SinkOpts.end(); ++Opt) {
276	if (*Opt == O) {
277	Sub.SinkOpts.erase(CI: Opt);
278	break;
279	}
280	}
281	else if (O == Sub.ConsumeAfterOpt)
282	Sub.ConsumeAfterOpt = nullptr;
283	}
284
285	void removeOption(Option *O) {
286	forEachSubCommand(Opt&: *O, Action: [&](SubCommand &SC) { removeOption(O, SC: &SC); });
287	}
288
289	bool hasOptions(const SubCommand &Sub) const {
290	return (!Sub.OptionsMap.empty() || !Sub.PositionalOpts.empty() ||
291	nullptr != Sub.ConsumeAfterOpt);
292	}
293
294	bool hasOptions() const {
295	for (const auto *S : RegisteredSubCommands) {
296	if (hasOptions(Sub: *S))
297	return true;
298	}
299	return false;
300	}
301
302	bool hasNamedSubCommands() const {
303	for (const auto *S : RegisteredSubCommands)
304	if (!S->getName().empty())
305	return true;
306	return false;
307	}
308
309	SubCommand *getActiveSubCommand() { return ActiveSubCommand; }
310
311	void updateArgStr(Option *O, StringRef NewName, SubCommand *SC) {
312	SubCommand &Sub = *SC;
313	if (!Sub.OptionsMap.insert(KV: std::make_pair(x&: NewName, y&: O)).second) {
314	errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
315	<< "' registered more than once!\n";
316	report_fatal_error(reason: "inconsistency in registered CommandLine options");
317	}
318	Sub.OptionsMap.erase(Key: O->ArgStr);
319	}
320
321	void updateArgStr(Option *O, StringRef NewName) {
322	forEachSubCommand(Opt&: *O,
323	Action: [&](SubCommand &SC) { updateArgStr(O, NewName, SC: &SC); });
324	}
325
326	void printOptionValues();
327
328	void registerCategory(OptionCategory *cat) {
329	assert(count_if(RegisteredOptionCategories,
330	[cat](const OptionCategory *Category) {
331	return cat->getName() == Category->getName();
332	}) == 0 &&
333	"Duplicate option categories");
334
335	RegisteredOptionCategories.insert(Ptr: cat);
336	}
337
338	void registerSubCommand(SubCommand *sub) {
339	assert(count_if(RegisteredSubCommands,
340	[sub](const SubCommand *Sub) {
341	return (!sub->getName().empty()) &&
342	(Sub->getName() == sub->getName());
343	}) == 0 &&
344	"Duplicate subcommands");
345	RegisteredSubCommands.insert(Ptr: sub);
346
347	// For all options that have been registered for all subcommands, add the
348	// option to this subcommand now.
349	assert(sub != &SubCommand::getAll() &&
350	"SubCommand::getAll() should not be registered");
351	for (auto &E : SubCommand::getAll().OptionsMap) {
352	Option *O = E.second;
353	if ((O->isPositional() || O->isSink() || O->isConsumeAfter()) ||
354	O->hasArgStr())
355	addOption(O, SC: sub);
356	else
357	addLiteralOption(Opt&: *O, SC: sub, Name: E.first());
358	}
359	}
360
361	void unregisterSubCommand(SubCommand *sub) {
362	RegisteredSubCommands.erase(Ptr: sub);
363	}
364
365	iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
366	getRegisteredSubcommands() {
367	return make_range(x: RegisteredSubCommands.begin(),
368	y: RegisteredSubCommands.end());
369	}
370
371	void reset() {
372	ActiveSubCommand = nullptr;
373	ProgramName.clear();
374	ProgramOverview = StringRef();
375
376	MoreHelp.clear();
377	RegisteredOptionCategories.clear();
378
379	ResetAllOptionOccurrences();
380	RegisteredSubCommands.clear();
381
382	SubCommand::getTopLevel().reset();
383	SubCommand::getAll().reset();
384	registerSubCommand(sub: &SubCommand::getTopLevel());
385
386	DefaultOptions.clear();
387	}
388
389	private:
390	SubCommand *ActiveSubCommand = nullptr;
391
392	Option *LookupOption(SubCommand &Sub, StringRef &Arg, StringRef &Value);
393	Option *LookupLongOption(SubCommand &Sub, StringRef &Arg, StringRef &Value,
394	bool LongOptionsUseDoubleDash, bool HaveDoubleDash) {
395	Option *Opt = LookupOption(Sub, Arg, Value);
396	if (Opt && LongOptionsUseDoubleDash && !HaveDoubleDash && !isGrouping(O: Opt))
397	return nullptr;
398	return Opt;
399	}
400	SubCommand *LookupSubCommand(StringRef Name, std::string &NearestString);
401	};
402
403	} // namespace
404
405	static ManagedStatic<CommandLineParser> GlobalParser;
406
407	void cl::AddLiteralOption(Option &O, StringRef Name) {
408	GlobalParser->addLiteralOption(Opt&: O, Name);
409	}
410
411	extrahelp::extrahelp(StringRef Help) : morehelp(Help) {
412	GlobalParser->MoreHelp.push_back(x: Help);
413	}
414
415	void Option::addArgument() {
416	GlobalParser->addOption(O: this);
417	FullyInitialized = true;
418	}
419
420	void Option::removeArgument() { GlobalParser->removeOption(O: this); }
421
422	void Option::setArgStr(StringRef S) {
423	if (FullyInitialized)
424	GlobalParser->updateArgStr(O: this, NewName: S);
425	assert(!S.starts_with("-") && "Option can't start with '-");
426	ArgStr = S;
427	if (ArgStr.size() == 1)
428	setMiscFlag(Grouping);
429	}
430
431	void Option::addCategory(OptionCategory &C) {
432	assert(!Categories.empty() && "Categories cannot be empty.");
433	// Maintain backward compatibility by replacing the default GeneralCategory
434	// if it's still set. Otherwise, just add the new one. The GeneralCategory
435	// must be explicitly added if you want multiple categories that include it.
436	if (&C != &getGeneralCategory() && Categories[0] == &getGeneralCategory())
437	Categories[0] = &C;
438	else if (!is_contained(Range&: Categories, Element: &C))
439	Categories.push_back(Elt: &C);
440	}
441
442	void Option::reset() {
443	NumOccurrences = 0;
444	setDefault();
445	if (isDefaultOption())
446	removeArgument();
447	}
448
449	void OptionCategory::registerCategory() {
450	GlobalParser->registerCategory(cat: this);
451	}
452
453	// A special subcommand representing no subcommand. It is particularly important
454	// that this ManagedStatic uses constant initailization and not dynamic
455	// initialization because it is referenced from cl::opt constructors, which run
456	// dynamically in an arbitrary order.
457	LLVM_REQUIRE_CONSTANT_INITIALIZATION
458	ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand;
459
460	// A special subcommand that can be used to put an option into all subcommands.
461	ManagedStatic<SubCommand> llvm::cl::AllSubCommands;
462
463	SubCommand &SubCommand::getTopLevel() { return *TopLevelSubCommand; }
464
465	SubCommand &SubCommand::getAll() { return *AllSubCommands; }
466
467	void SubCommand::registerSubCommand() {
468	GlobalParser->registerSubCommand(sub: this);
469	}
470
471	void SubCommand::unregisterSubCommand() {
472	GlobalParser->unregisterSubCommand(sub: this);
473	}
474
475	void SubCommand::reset() {
476	PositionalOpts.clear();
477	SinkOpts.clear();
478	OptionsMap.clear();
479
480	ConsumeAfterOpt = nullptr;
481	}
482
483	SubCommand::operator bool() const {
484	return (GlobalParser->getActiveSubCommand() == this);
485	}
486
487	//===----------------------------------------------------------------------===//
488	// Basic, shared command line option processing machinery.
489	//
490
491	/// LookupOption - Lookup the option specified by the specified option on the
492	/// command line. If there is a value specified (after an equal sign) return
493	/// that as well. This assumes that leading dashes have already been stripped.
494	Option *CommandLineParser::LookupOption(SubCommand &Sub, StringRef &Arg,
495	StringRef &Value) {
496	// Reject all dashes.
497	if (Arg.empty())
498	return nullptr;
499	assert(&Sub != &SubCommand::getAll());
500
501	size_t EqualPos = Arg.find(C: '=');
502
503	// If we have an equals sign, remember the value.
504	if (EqualPos == StringRef::npos) {
505	// Look up the option.
506	return Sub.OptionsMap.lookup(Key: Arg);
507	}
508
509	// If the argument before the = is a valid option name and the option allows
510	// non-prefix form (ie is not AlwaysPrefix), we match. If not, signal match
511	// failure by returning nullptr.
512	auto I = Sub.OptionsMap.find(Key: Arg.substr(Start: 0, N: EqualPos));
513	if (I == Sub.OptionsMap.end())
514	return nullptr;
515
516	auto *O = I->second;
517	if (O->getFormattingFlag() == cl::AlwaysPrefix)
518	return nullptr;
519
520	Value = Arg.substr(Start: EqualPos + 1);
521	Arg = Arg.substr(Start: 0, N: EqualPos);
522	return I->second;
523	}
524
525	SubCommand *CommandLineParser::LookupSubCommand(StringRef Name,
526	std::string &NearestString) {
527	if (Name.empty())
528	return &SubCommand::getTopLevel();
529	// Find a subcommand with the edit distance == 1.
530	SubCommand *NearestMatch = nullptr;
531	for (auto *S : RegisteredSubCommands) {
532	assert(S != &SubCommand::getAll() &&
533	"SubCommand::getAll() is not expected in RegisteredSubCommands");
534	if (S->getName().empty())
535	continue;
536
537	if (StringRef(S->getName()) == StringRef(Name))
538	return S;
539
540	if (!NearestMatch && S->getName().edit_distance(Other: Name) < 2)
541	NearestMatch = S;
542	}
543
544	if (NearestMatch)
545	NearestString = NearestMatch->getName();
546
547	return &SubCommand::getTopLevel();
548	}
549
550	/// LookupNearestOption - Lookup the closest match to the option specified by
551	/// the specified option on the command line. If there is a value specified
552	/// (after an equal sign) return that as well. This assumes that leading dashes
553	/// have already been stripped.
554	static Option *LookupNearestOption(StringRef Arg,
555	const StringMap<Option *> &OptionsMap,
556	std::string &NearestString) {
557	// Reject all dashes.
558	if (Arg.empty())
559	return nullptr;
560
561	// Split on any equal sign.
562	std::pair<StringRef, StringRef> SplitArg = Arg.split(Separator: '=');
563	StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present.
564	StringRef &RHS = SplitArg.second;
565
566	// Find the closest match.
567	Option *Best = nullptr;
568	unsigned BestDistance = 0;
569	for (StringMap<Option *>::const_iterator it = OptionsMap.begin(),
570	ie = OptionsMap.end();
571	it != ie; ++it) {
572	Option *O = it->second;
573	// Do not suggest really hidden options (not shown in any help).
574	if (O->getOptionHiddenFlag() == ReallyHidden)
575	continue;
576
577	SmallVector<StringRef, 16> OptionNames;
578	O->getExtraOptionNames(OptionNames);
579	if (O->hasArgStr())
580	OptionNames.push_back(Elt: O->ArgStr);
581
582	bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed;
583	StringRef Flag = PermitValue ? LHS : Arg;
584	for (const auto &Name : OptionNames) {
585	unsigned Distance = StringRef(Name).edit_distance(
586	Other: Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance);
587	if (!Best || Distance < BestDistance) {
588	Best = O;
589	BestDistance = Distance;
590	if (RHS.empty() || !PermitValue)
591	NearestString = std::string(Name);
592	else
593	NearestString = (Twine(Name) + "=" + RHS).str();
594	}
595	}
596	}
597
598	return Best;
599	}
600
601	/// CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence()
602	/// that does special handling of cl::CommaSeparated options.
603	static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos,
604	StringRef ArgName, StringRef Value,
605	bool MultiArg = false) {
606	// Check to see if this option accepts a comma separated list of values. If
607	// it does, we have to split up the value into multiple values.
608	if (Handler->getMiscFlags() & CommaSeparated) {
609	StringRef Val(Value);
610	StringRef::size_type Pos = Val.find(C: ',');
611
612	while (Pos != StringRef::npos) {
613	// Process the portion before the comma.
614	if (Handler->addOccurrence(pos, ArgName, Value: Val.substr(Start: 0, N: Pos), MultiArg))
615	return true;
616	// Erase the portion before the comma, AND the comma.
617	Val = Val.substr(Start: Pos + 1);
618	// Check for another comma.
619	Pos = Val.find(C: ',');
620	}
621
622	Value = Val;
623	}
624
625	return Handler->addOccurrence(pos, ArgName, Value, MultiArg);
626	}
627
628	/// ProvideOption - For Value, this differentiates between an empty value ("")
629	/// and a null value (StringRef()). The later is accepted for arguments that
630	/// don't allow a value (-foo) the former is rejected (-foo=).
631	static inline bool ProvideOption(Option *Handler, StringRef ArgName,
632	StringRef Value, int argc,
633	const char *const *argv, int &i) {
634	// Is this a multi-argument option?
635	unsigned NumAdditionalVals = Handler->getNumAdditionalVals();
636
637	// Enforce value requirements
638	switch (Handler->getValueExpectedFlag()) {
639	case ValueRequired:
640	if (!Value.data()) { // No value specified?
641	// If no other argument or the option only supports prefix form, we
642	// cannot look at the next argument.
643	if (i + 1 >= argc || Handler->getFormattingFlag() == cl::AlwaysPrefix)
644	return Handler->error(Message: "requires a value!");
645	// Steal the next argument, like for '-o filename'
646	assert(argv && "null check");
647	Value = StringRef(argv[++i]);
648	}
649	break;
650	case ValueDisallowed:
651	if (NumAdditionalVals > 0)
652	return Handler->error(Message: "multi-valued option specified"
653	" with ValueDisallowed modifier!");
654
655	if (Value.data())
656	return Handler->error(Message: "does not allow a value! '" + Twine(Value) +
657	"' specified.");
658	break;
659	case ValueOptional:
660	break;
661	}
662
663	// If this isn't a multi-arg option, just run the handler.
664	if (NumAdditionalVals == 0)
665	return CommaSeparateAndAddOccurrence(Handler, pos: i, ArgName, Value);
666
667	// If it is, run the handle several times.
668	bool MultiArg = false;
669
670	if (Value.data()) {
671	if (CommaSeparateAndAddOccurrence(Handler, pos: i, ArgName, Value, MultiArg))
672	return true;
673	--NumAdditionalVals;
674	MultiArg = true;
675	}
676
677	while (NumAdditionalVals > 0) {
678	if (i + 1 >= argc)
679	return Handler->error(Message: "not enough values!");
680	assert(argv && "null check");
681	Value = StringRef(argv[++i]);
682
683	if (CommaSeparateAndAddOccurrence(Handler, pos: i, ArgName, Value, MultiArg))
684	return true;
685	MultiArg = true;
686	--NumAdditionalVals;
687	}
688	return false;
689	}
690
691	bool llvm::cl::ProvidePositionalOption(Option *Handler, StringRef Arg, int i) {
692	int Dummy = i;
693	return ProvideOption(Handler, ArgName: Handler->ArgStr, Value: Arg, argc: 0, argv: nullptr, i&: Dummy);
694	}
695
696	// getOptionPred - Check to see if there are any options that satisfy the
697	// specified predicate with names that are the prefixes in Name. This is
698	// checked by progressively stripping characters off of the name, checking to
699	// see if there options that satisfy the predicate. If we find one, return it,
700	// otherwise return null.
701	//
702	static Option *getOptionPred(StringRef Name, size_t &Length,
703	bool (*Pred)(const Option *),
704	const StringMap<Option *> &OptionsMap) {
705	StringMap<Option *>::const_iterator OMI = OptionsMap.find(Key: Name);
706	if (OMI != OptionsMap.end() && !Pred(OMI->getValue()))
707	OMI = OptionsMap.end();
708
709	// Loop while we haven't found an option and Name still has at least two
710	// characters in it (so that the next iteration will not be the empty
711	// string.
712	while (OMI == OptionsMap.end() && Name.size() > 1) {
713	Name = Name.substr(Start: 0, N: Name.size() - 1); // Chop off the last character.
714	OMI = OptionsMap.find(Key: Name);
715	if (OMI != OptionsMap.end() && !Pred(OMI->getValue()))
716	OMI = OptionsMap.end();
717	}
718
719	if (OMI != OptionsMap.end() && Pred(OMI->second)) {
720	Length = Name.size();
721	return OMI->second; // Found one!
722	}
723	return nullptr; // No option found!
724	}
725
726	/// HandlePrefixedOrGroupedOption - The specified argument string (which started
727	/// with at least one '-') does not fully match an available option. Check to
728	/// see if this is a prefix or grouped option. If so, split arg into output an
729	/// Arg/Value pair and return the Option to parse it with.
730	static Option *
731	HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value,
732	bool &ErrorParsing,
733	const StringMap<Option *> &OptionsMap) {
734	if (Arg.size() == 1)
735	return nullptr;
736
737	// Do the lookup!
738	size_t Length = 0;
739	Option *PGOpt = getOptionPred(Name: Arg, Length, Pred: isPrefixedOrGrouping, OptionsMap);
740	if (!PGOpt)
741	return nullptr;
742
743	do {
744	StringRef MaybeValue =
745	(Length < Arg.size()) ? Arg.substr(Start: Length) : StringRef();
746	Arg = Arg.substr(Start: 0, N: Length);
747	assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt);
748
749	// cl::Prefix options do not preserve '=' when used separately.
750	// The behavior for them with grouped options should be the same.
751	if (MaybeValue.empty() || PGOpt->getFormattingFlag() == cl::AlwaysPrefix ||
752	(PGOpt->getFormattingFlag() == cl::Prefix && MaybeValue[0] != '=')) {
753	Value = MaybeValue;
754	return PGOpt;
755	}
756
757	if (MaybeValue[0] == '=') {
758	Value = MaybeValue.substr(Start: 1);
759	return PGOpt;
760	}
761
762	// This must be a grouped option.
763	assert(isGrouping(PGOpt) && "Broken getOptionPred!");
764
765	// Grouping options inside a group can't have values.
766	if (PGOpt->getValueExpectedFlag() == cl::ValueRequired) {
767	ErrorParsing |= PGOpt->error(Message: "may not occur within a group!");
768	return nullptr;
769	}
770
771	// Because the value for the option is not required, we don't need to pass
772	// argc/argv in.
773	int Dummy = 0;
774	ErrorParsing |= ProvideOption(Handler: PGOpt, ArgName: Arg, Value: StringRef(), argc: 0, argv: nullptr, i&: Dummy);
775
776	// Get the next grouping option.
777	Arg = MaybeValue;
778	PGOpt = getOptionPred(Name: Arg, Length, Pred: isGrouping, OptionsMap);
779	} while (PGOpt);
780
781	// We could not find a grouping option in the remainder of Arg.
782	return nullptr;
783	}
784
785	static bool RequiresValue(const Option *O) {
786	return O->getNumOccurrencesFlag() == cl::Required ||
787	O->getNumOccurrencesFlag() == cl::OneOrMore;
788	}
789
790	static bool EatsUnboundedNumberOfValues(const Option *O) {
791	return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
792	O->getNumOccurrencesFlag() == cl::OneOrMore;
793	}
794
795	static bool isWhitespace(char C) {
796	return C == ' ' || C == '\t' || C == '\r' || C == '\n';
797	}
798
799	static bool isWhitespaceOrNull(char C) {
800	return isWhitespace(C) || C == '\0';
801	}
802
803	static bool isQuote(char C) { return C == '\"' || C == '\''; }
804
805	void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver,
806	SmallVectorImpl<const char *> &NewArgv,
807	bool MarkEOLs) {
808	SmallString<128> Token;
809	for (size_t I = 0, E = Src.size(); I != E; ++I) {
810	// Consume runs of whitespace.
811	if (Token.empty()) {
812	while (I != E && isWhitespace(C: Src[I])) {
813	// Mark the end of lines in response files.
814	if (MarkEOLs && Src[I] == '\n')
815	NewArgv.push_back(Elt: nullptr);
816	++I;
817	}
818	if (I == E)
819	break;
820	}
821
822	char C = Src[I];
823
824	// Backslash escapes the next character.
825	if (I + 1 < E && C == '\\') {
826	++I; // Skip the escape.
827	Token.push_back(Elt: Src[I]);
828	continue;
829	}
830
831	// Consume a quoted string.
832	if (isQuote(C)) {
833	++I;
834	while (I != E && Src[I] != C) {
835	// Backslash escapes the next character.
836	if (Src[I] == '\\' && I + 1 != E)
837	++I;
838	Token.push_back(Elt: Src[I]);
839	++I;
840	}
841	if (I == E)
842	break;
843	continue;
844	}
845
846	// End the token if this is whitespace.
847	if (isWhitespace(C)) {
848	if (!Token.empty())
849	NewArgv.push_back(Elt: Saver.save(S: Token.str()).data());
850	// Mark the end of lines in response files.
851	if (MarkEOLs && C == '\n')
852	NewArgv.push_back(Elt: nullptr);
853	Token.clear();
854	continue;
855	}
856
857	// This is a normal character. Append it.
858	Token.push_back(Elt: C);
859	}
860
861	// Append the last token after hitting EOF with no whitespace.
862	if (!Token.empty())
863	NewArgv.push_back(Elt: Saver.save(S: Token.str()).data());
864	}
865
866	/// Backslashes are interpreted in a rather complicated way in the Windows-style
867	/// command line, because backslashes are used both to separate path and to
868	/// escape double quote. This method consumes runs of backslashes as well as the
869	/// following double quote if it's escaped.
870	///
871	/// * If an even number of backslashes is followed by a double quote, one
872	/// backslash is output for every pair of backslashes, and the last double
873	/// quote remains unconsumed. The double quote will later be interpreted as
874	/// the start or end of a quoted string in the main loop outside of this
875	/// function.
876	///
877	/// * If an odd number of backslashes is followed by a double quote, one
878	/// backslash is output for every pair of backslashes, and a double quote is
879	/// output for the last pair of backslash-double quote. The double quote is
880	/// consumed in this case.
881	///
882	/// * Otherwise, backslashes are interpreted literally.
883	static size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) {
884	size_t E = Src.size();
885	int BackslashCount = 0;
886	// Skip the backslashes.
887	do {
888	++I;
889	++BackslashCount;
890	} while (I != E && Src[I] == '\\');
891
892	bool FollowedByDoubleQuote = (I != E && Src[I] == '"');
893	if (FollowedByDoubleQuote) {
894	Token.append(NumInputs: BackslashCount / 2, Elt: '\\');
895	if (BackslashCount % 2 == 0)
896	return I - 1;
897	Token.push_back(Elt: '"');
898	return I;
899	}
900	Token.append(NumInputs: BackslashCount, Elt: '\\');
901	return I - 1;
902	}
903
904	// Windows treats whitespace, double quotes, and backslashes specially, except
905	// when parsing the first token of a full command line, in which case
906	// backslashes are not special.
907	static bool isWindowsSpecialChar(char C) {
908	return isWhitespaceOrNull(C) || C == '\\' || C == '\"';
909	}
910	static bool isWindowsSpecialCharInCommandName(char C) {
911	return isWhitespaceOrNull(C) || C == '\"';
912	}
913
914	// Windows tokenization implementation. The implementation is designed to be
915	// inlined and specialized for the two user entry points.
916	static inline void tokenizeWindowsCommandLineImpl(
917	StringRef Src, StringSaver &Saver, function_ref<void(StringRef)> AddToken,
918	bool AlwaysCopy, function_ref<void()> MarkEOL, bool InitialCommandName) {
919	SmallString<128> Token;
920
921	// Sometimes, this function will be handling a full command line including an
922	// executable pathname at the start. In that situation, the initial pathname
923	// needs different handling from the following arguments, because when
924	// CreateProcess or cmd.exe scans the pathname, it doesn't treat \ as
925	// escaping the quote character, whereas when libc scans the rest of the
926	// command line, it does.
927	bool CommandName = InitialCommandName;
928
929	// Try to do as much work inside the state machine as possible.
930	enum { INIT, UNQUOTED, QUOTED } State = INIT;
931
932	for (size_t I = 0, E = Src.size(); I < E; ++I) {
933	switch (State) {
934	case INIT: {
935	assert(Token.empty() && "token should be empty in initial state");
936	// Eat whitespace before a token.
937	while (I < E && isWhitespaceOrNull(C: Src[I])) {
938	if (Src[I] == '\n')
939	MarkEOL();
940	++I;
941	}
942	// Stop if this was trailing whitespace.
943	if (I >= E)
944	break;
945	size_t Start = I;
946	if (CommandName) {
947	while (I < E && !isWindowsSpecialCharInCommandName(C: Src[I]))
948	++I;
949	} else {
950	while (I < E && !isWindowsSpecialChar(C: Src[I]))
951	++I;
952	}
953	StringRef NormalChars = Src.slice(Start, End: I);
954	if (I >= E || isWhitespaceOrNull(C: Src[I])) {
955	// No special characters: slice out the substring and start the next
956	// token. Copy the string if the caller asks us to.
957	AddToken(AlwaysCopy ? Saver.save(S: NormalChars) : NormalChars);
958	if (I < E && Src[I] == '\n') {
959	MarkEOL();
960	CommandName = InitialCommandName;
961	} else {
962	CommandName = false;
963	}
964	} else if (Src[I] == '\"') {
965	Token += NormalChars;
966	State = QUOTED;
967	} else if (Src[I] == '\\') {
968	assert(!CommandName && "or else we'd have treated it as a normal char");
969	Token += NormalChars;
970	I = parseBackslash(Src, I, Token);
971	State = UNQUOTED;
972	} else {
973	llvm_unreachable("unexpected special character");
974	}
975	break;
976	}
977
978	case UNQUOTED:
979	if (isWhitespaceOrNull(C: Src[I])) {
980	// Whitespace means the end of the token. If we are in this state, the
981	// token must have contained a special character, so we must copy the
982	// token.
983	AddToken(Saver.save(S: Token.str()));
984	Token.clear();
985	if (Src[I] == '\n') {
986	CommandName = InitialCommandName;
987	MarkEOL();
988	} else {
989	CommandName = false;
990	}
991	State = INIT;
992	} else if (Src[I] == '\"') {
993	State = QUOTED;
994	} else if (Src[I] == '\\' && !CommandName) {
995	I = parseBackslash(Src, I, Token);
996	} else {
997	Token.push_back(Elt: Src[I]);
998	}
999	break;
1000
1001	case QUOTED:
1002	if (Src[I] == '\"') {
1003	if (I < (E - 1) && Src[I + 1] == '"') {
1004	// Consecutive double-quotes inside a quoted string implies one
1005	// double-quote.
1006	Token.push_back(Elt: '"');
1007	++I;
1008	} else {
1009	// Otherwise, end the quoted portion and return to the unquoted state.
1010	State = UNQUOTED;
1011	}
1012	} else if (Src[I] == '\\' && !CommandName) {
1013	I = parseBackslash(Src, I, Token);
1014	} else {
1015	Token.push_back(Elt: Src[I]);
1016	}
1017	break;
1018	}
1019	}
1020
1021	if (State != INIT)
1022	AddToken(Saver.save(S: Token.str()));
1023	}
1024
1025	void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver,
1026	SmallVectorImpl<const char *> &NewArgv,
1027	bool MarkEOLs) {
1028	auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Elt: Tok.data()); };
1029	auto OnEOL = [&]() {
1030	if (MarkEOLs)
1031	NewArgv.push_back(Elt: nullptr);
1032	};
1033	tokenizeWindowsCommandLineImpl(Src, Saver, AddToken,
1034	/*AlwaysCopy=*/true, MarkEOL: OnEOL, InitialCommandName: false);
1035	}
1036
1037	void cl::TokenizeWindowsCommandLineNoCopy(StringRef Src, StringSaver &Saver,
1038	SmallVectorImpl<StringRef> &NewArgv) {
1039	auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Elt: Tok); };
1040	auto OnEOL = []() {};
1041	tokenizeWindowsCommandLineImpl(Src, Saver, AddToken, /*AlwaysCopy=*/false,
1042	MarkEOL: OnEOL, InitialCommandName: false);
1043	}
1044
1045	void cl::TokenizeWindowsCommandLineFull(StringRef Src, StringSaver &Saver,
1046	SmallVectorImpl<const char *> &NewArgv,
1047	bool MarkEOLs) {
1048	auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Elt: Tok.data()); };
1049	auto OnEOL = [&]() {
1050	if (MarkEOLs)
1051	NewArgv.push_back(Elt: nullptr);
1052	};
1053	tokenizeWindowsCommandLineImpl(Src, Saver, AddToken,
1054	/*AlwaysCopy=*/true, MarkEOL: OnEOL, InitialCommandName: true);
1055	}
1056
1057	void cl::tokenizeConfigFile(StringRef Source, StringSaver &Saver,
1058	SmallVectorImpl<const char *> &NewArgv,
1059	bool MarkEOLs) {
1060	for (const char *Cur = Source.begin(); Cur != Source.end();) {
1061	SmallString<128> Line;
1062	// Check for comment line.
1063	if (isWhitespace(C: *Cur)) {
1064	while (Cur != Source.end() && isWhitespace(C: *Cur))
1065	++Cur;
1066	continue;
1067	}
1068	if (*Cur == '#') {
1069	while (Cur != Source.end() && *Cur != '\n')
1070	++Cur;
1071	continue;
1072	}
1073	// Find end of the current line.
1074	const char *Start = Cur;
1075	for (const char *End = Source.end(); Cur != End; ++Cur) {
1076	if (*Cur == '\\') {
1077	if (Cur + 1 != End) {
1078	++Cur;
1079	if (*Cur == '\n' ||
1080	(*Cur == '\r' && (Cur + 1 != End) && Cur[1] == '\n')) {
1081	Line.append(in_start: Start, in_end: Cur - 1);
1082	if (*Cur == '\r')
1083	++Cur;
1084	Start = Cur + 1;
1085	}
1086	}
1087	} else if (*Cur == '\n')
1088	break;
1089	}
1090	// Tokenize line.
1091	Line.append(in_start: Start, in_end: Cur);
1092	cl::TokenizeGNUCommandLine(Src: Line, Saver, NewArgv, MarkEOLs);
1093	}
1094	}
1095
1096	// It is called byte order marker but the UTF-8 BOM is actually not affected
1097	// by the host system's endianness.
1098	static bool hasUTF8ByteOrderMark(ArrayRef<char> S) {
1099	return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
1100	}
1101
1102	// Substitute <CFGDIR> with the file's base path.
1103	static void ExpandBasePaths(StringRef BasePath, StringSaver &Saver,
1104	const char *&Arg) {
1105	assert(sys::path::is_absolute(BasePath));
1106	constexpr StringLiteral Token("<CFGDIR>");
1107	const StringRef ArgString(Arg);
1108
1109	SmallString<128> ResponseFile;
1110	StringRef::size_type StartPos = 0;
1111	for (StringRef::size_type TokenPos = ArgString.find(Str: Token);
1112	TokenPos != StringRef::npos;
1113	TokenPos = ArgString.find(Str: Token, From: StartPos)) {
1114	// Token may appear more than once per arg (e.g. comma-separated linker
1115	// args). Support by using path-append on any subsequent appearances.
1116	const StringRef LHS = ArgString.substr(Start: StartPos, N: TokenPos - StartPos);
1117	if (ResponseFile.empty())
1118	ResponseFile = LHS;
1119	else
1120	llvm::sys::path::append(path&: ResponseFile, a: LHS);
1121	ResponseFile.append(RHS: BasePath);
1122	StartPos = TokenPos + Token.size();
1123	}
1124
1125	if (!ResponseFile.empty()) {
1126	// Path-append the remaining arg substring if at least one token appeared.
1127	const StringRef Remaining = ArgString.substr(Start: StartPos);
1128	if (!Remaining.empty())
1129	llvm::sys::path::append(path&: ResponseFile, a: Remaining);
1130	Arg = Saver.save(S: ResponseFile.str()).data();
1131	}
1132	}
1133
1134	// FName must be an absolute path.
1135	Error ExpansionContext::expandResponseFile(
1136	StringRef FName, SmallVectorImpl<const char *> &NewArgv) {
1137	assert(sys::path::is_absolute(FName));
1138	llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
1139	FS->getBufferForFile(Name: FName);
1140	if (!MemBufOrErr) {
1141	std::error_code EC = MemBufOrErr.getError();
1142	return llvm::createStringError(EC, S: Twine("cannot not open file '") + FName +
1143	"': " + EC.message());
1144	}
1145	MemoryBuffer &MemBuf = *MemBufOrErr.get();
1146	StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize());
1147
1148	// If we have a UTF-16 byte order mark, convert to UTF-8 for parsing.
1149	ArrayRef<char> BufRef(MemBuf.getBufferStart(), MemBuf.getBufferEnd());
1150	std::string UTF8Buf;
1151	if (hasUTF16ByteOrderMark(SrcBytes: BufRef)) {
1152	if (!convertUTF16ToUTF8String(SrcBytes: BufRef, Out&: UTF8Buf))
1153	return llvm::createStringError(EC: std::errc::illegal_byte_sequence,
1154	Fmt: "Could not convert UTF16 to UTF8");
1155	Str = StringRef(UTF8Buf);
1156	}
1157	// If we see UTF-8 BOM sequence at the beginning of a file, we shall remove
1158	// these bytes before parsing.
1159	// Reference: http://en.wikipedia.org/wiki/UTF-8#Byte_order_mark
1160	else if (hasUTF8ByteOrderMark(S: BufRef))
1161	Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);
1162
1163	// Tokenize the contents into NewArgv.
1164	Tokenizer(Str, Saver, NewArgv, MarkEOLs);
1165
1166	// Expanded file content may require additional transformations, like using
1167	// absolute paths instead of relative in '@file' constructs or expanding
1168	// macros.
1169	if (!RelativeNames && !InConfigFile)
1170	return Error::success();
1171
1172	StringRef BasePath = llvm::sys::path::parent_path(path: FName);
1173	for (const char *&Arg : NewArgv) {
1174	if (!Arg)
1175	continue;
1176
1177	// Substitute <CFGDIR> with the file's base path.
1178	if (InConfigFile)
1179	ExpandBasePaths(BasePath, Saver, Arg);
1180
1181	// Discover the case, when argument should be transformed into '@file' and
1182	// evaluate 'file' for it.
1183	StringRef ArgStr(Arg);
1184	StringRef FileName;
1185	bool ConfigInclusion = false;
1186	if (ArgStr.consume_front(Prefix: "@")) {
1187	FileName = ArgStr;
1188	if (!llvm::sys::path::is_relative(path: FileName))
1189	continue;
1190	} else if (ArgStr.consume_front(Prefix: "--config=")) {
1191	FileName = ArgStr;
1192	ConfigInclusion = true;
1193	} else {
1194	continue;
1195	}
1196
1197	// Update expansion construct.
1198	SmallString<128> ResponseFile;
1199	ResponseFile.push_back(Elt: '@');
1200	if (ConfigInclusion && !llvm::sys::path::has_parent_path(path: FileName)) {
1201	SmallString<128> FilePath;
1202	if (!findConfigFile(FileName, FilePath))
1203	return createStringError(
1204	EC: std::make_error_code(e: std::errc::no_such_file_or_directory),
1205	S: "cannot not find configuration file: " + FileName);
1206	ResponseFile.append(RHS: FilePath);
1207	} else {
1208	ResponseFile.append(RHS: BasePath);
1209	llvm::sys::path::append(path&: ResponseFile, a: FileName);
1210	}
1211	Arg = Saver.save(S: ResponseFile.str()).data();
1212	}
1213	return Error::success();
1214	}
1215
1216	/// Expand response files on a command line recursively using the given
1217	/// StringSaver and tokenization strategy.
1218	Error ExpansionContext::expandResponseFiles(
1219	SmallVectorImpl<const char *> &Argv) {
1220	struct ResponseFileRecord {
1221	std::string File;
1222	size_t End;
1223	};
1224
1225	// To detect recursive response files, we maintain a stack of files and the
1226	// position of the last argument in the file. This position is updated
1227	// dynamically as we recursively expand files.
1228	SmallVector<ResponseFileRecord, 3> FileStack;
1229
1230	// Push a dummy entry that represents the initial command line, removing
1231	// the need to check for an empty list.
1232	FileStack.push_back(Elt: {.File: "", .End: Argv.size()});
1233
1234	// Don't cache Argv.size() because it can change.
1235	for (unsigned I = 0; I != Argv.size();) {
1236	while (I == FileStack.back().End) {
1237	// Passing the end of a file's argument list, so we can remove it from the
1238	// stack.
1239	FileStack.pop_back();
1240	}
1241
1242	const char *Arg = Argv[I];
1243	// Check if it is an EOL marker
1244	if (Arg == nullptr) {
1245	++I;
1246	continue;
1247	}
1248
1249	if (Arg[0] != '@') {
1250	++I;
1251	continue;
1252	}
1253
1254	const char *FName = Arg + 1;
1255	// Note that CurrentDir is only used for top-level rsp files, the rest will
1256	// always have an absolute path deduced from the containing file.
1257	SmallString<128> CurrDir;
1258	if (llvm::sys::path::is_relative(path: FName)) {
1259	if (CurrentDir.empty()) {
1260	if (auto CWD = FS->getCurrentWorkingDirectory()) {
1261	CurrDir = *CWD;
1262	} else {
1263	return createStringError(
1264	EC: CWD.getError(), S: Twine("cannot get absolute path for: ") + FName);
1265	}
1266	} else {
1267	CurrDir = CurrentDir;
1268	}
1269	llvm::sys::path::append(path&: CurrDir, a: FName);
1270	FName = CurrDir.c_str();
1271	}
1272
1273	ErrorOr<llvm::vfs::Status> Res = FS->status(Path: FName);
1274	if (!Res || !Res->exists()) {
1275	std::error_code EC = Res.getError();
1276	if (!InConfigFile) {
1277	// If the specified file does not exist, leave '@file' unexpanded, as
1278	// libiberty does.
1279	if (!EC || EC == llvm::errc::no_such_file_or_directory) {
1280	++I;
1281	continue;
1282	}
1283	}
1284	if (!EC)
1285	EC = llvm::errc::no_such_file_or_directory;
1286	return createStringError(EC, S: Twine("cannot not open file '") + FName +
1287	"': " + EC.message());
1288	}
1289	const llvm::vfs::Status &FileStatus = Res.get();
1290
1291	auto IsEquivalent =
1292	[FileStatus, this](const ResponseFileRecord &RFile) -> ErrorOr<bool> {
1293	ErrorOr<llvm::vfs::Status> RHS = FS->status(Path: RFile.File);
1294	if (!RHS)
1295	return RHS.getError();
1296	return FileStatus.equivalent(Other: *RHS);
1297	};
1298
1299	// Check for recursive response files.
1300	for (const auto &F : drop_begin(RangeOrContainer&: FileStack)) {
1301	if (ErrorOr<bool> R = IsEquivalent(F)) {
1302	if (R.get())
1303	return createStringError(
1304	EC: R.getError(), S: Twine("recursive expansion of: '") + F.File + "'");
1305	} else {
1306	return createStringError(EC: R.getError(),
1307	S: Twine("cannot open file: ") + F.File);
1308	}
1309	}
1310
1311	// Replace this response file argument with the tokenization of its
1312	// contents. Nested response files are expanded in subsequent iterations.
1313	SmallVector<const char *, 0> ExpandedArgv;
1314	if (Error Err = expandResponseFile(FName, NewArgv&: ExpandedArgv))
1315	return Err;
1316
1317	for (ResponseFileRecord &Record : FileStack) {
1318	// Increase the end of all active records by the number of newly expanded
1319	// arguments, minus the response file itself.
1320	Record.End += ExpandedArgv.size() - 1;
1321	}
1322
1323	FileStack.push_back(Elt: {.File: FName, .End: I + ExpandedArgv.size()});
1324	Argv.erase(CI: Argv.begin() + I);
1325	Argv.insert(I: Argv.begin() + I, From: ExpandedArgv.begin(), To: ExpandedArgv.end());
1326	}
1327
1328	// If successful, the top of the file stack will mark the end of the Argv
1329	// stream. A failure here indicates a bug in the stack popping logic above.
1330	// Note that FileStack may have more than one element at this point because we
1331	// don't have a chance to pop the stack when encountering recursive files at
1332	// the end of the stream, so seeing that doesn't indicate a bug.
1333	assert(FileStack.size() > 0 && Argv.size() == FileStack.back().End);
1334	return Error::success();
1335	}
1336
1337	bool cl::expandResponseFiles(int Argc, const char *const *Argv,
1338	const char *EnvVar, StringSaver &Saver,
1339	SmallVectorImpl<const char *> &NewArgv) {
1340	#ifdef _WIN32
1341	auto Tokenize = cl::TokenizeWindowsCommandLine;
1342	#else
1343	auto Tokenize = cl::TokenizeGNUCommandLine;
1344	#endif
1345	// The environment variable specifies initial options.
1346	if (EnvVar)
1347	if (std::optional<std::string> EnvValue = sys::Process::GetEnv(name: EnvVar))
1348	Tokenize(*EnvValue, Saver, NewArgv, /*MarkEOLs=*/false);
1349
1350	// Command line options can override the environment variable.
1351	NewArgv.append(in_start: Argv + 1, in_end: Argv + Argc);
1352	ExpansionContext ECtx(Saver.getAllocator(), Tokenize);
1353	if (Error Err = ECtx.expandResponseFiles(Argv&: NewArgv)) {
1354	errs() << toString(E: std::move(Err)) << '\n';
1355	return false;
1356	}
1357	return true;
1358	}
1359
1360	bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
1361	SmallVectorImpl<const char *> &Argv) {
1362	ExpansionContext ECtx(Saver.getAllocator(), Tokenizer);
1363	if (Error Err = ECtx.expandResponseFiles(Argv)) {
1364	errs() << toString(E: std::move(Err)) << '\n';
1365	return false;
1366	}
1367	return true;
1368	}
1369
1370	ExpansionContext::ExpansionContext(BumpPtrAllocator &A, TokenizerCallback T)
1371	: Saver(A), Tokenizer(T), FS(vfs::getRealFileSystem().get()) {}
1372
1373	bool ExpansionContext::findConfigFile(StringRef FileName,
1374	SmallVectorImpl<char> &FilePath) {
1375	SmallString<128> CfgFilePath;
1376	const auto FileExists = [this](SmallString<128> Path) -> bool {
1377	auto Status = FS->status(Path);
1378	return Status &&
1379	Status->getType() == llvm::sys::fs::file_type::regular_file;
1380	};
1381
1382	// If file name contains directory separator, treat it as a path to
1383	// configuration file.
1384	if (llvm::sys::path::has_parent_path(path: FileName)) {
1385	CfgFilePath = FileName;
1386	if (llvm::sys::path::is_relative(path: FileName) && FS->makeAbsolute(Path&: CfgFilePath))
1387	return false;
1388	if (!FileExists(CfgFilePath))
1389	return false;
1390	FilePath.assign(in_start: CfgFilePath.begin(), in_end: CfgFilePath.end());
1391	return true;
1392	}
1393
1394	// Look for the file in search directories.
1395	for (const StringRef &Dir : SearchDirs) {
1396	if (Dir.empty())
1397	continue;
1398	CfgFilePath.assign(RHS: Dir);
1399	llvm::sys::path::append(path&: CfgFilePath, a: FileName);
1400	llvm::sys::path::native(path&: CfgFilePath);
1401	if (FileExists(CfgFilePath)) {
1402	FilePath.assign(in_start: CfgFilePath.begin(), in_end: CfgFilePath.end());
1403	return true;
1404	}
1405	}
1406
1407	return false;
1408	}
1409
1410	Error ExpansionContext::readConfigFile(StringRef CfgFile,
1411	SmallVectorImpl<const char *> &Argv) {
1412	SmallString<128> AbsPath;
1413	if (sys::path::is_relative(path: CfgFile)) {
1414	AbsPath.assign(RHS: CfgFile);
1415	if (std::error_code EC = FS->makeAbsolute(Path&: AbsPath))
1416	return make_error<StringError>(
1417	Args&: EC, Args: Twine("cannot get absolute path for " + CfgFile));
1418	CfgFile = AbsPath.str();
1419	}
1420	InConfigFile = true;
1421	RelativeNames = true;
1422	if (Error Err = expandResponseFile(FName: CfgFile, NewArgv&: Argv))
1423	return Err;
1424	return expandResponseFiles(Argv);
1425	}
1426
1427	static void initCommonOptions();
1428	bool cl::ParseCommandLineOptions(int argc, const char *const *argv,
1429	StringRef Overview, raw_ostream *Errs,
1430	const char *EnvVar,
1431	bool LongOptionsUseDoubleDash) {
1432	initCommonOptions();
1433	SmallVector<const char *, 20> NewArgv;
1434	BumpPtrAllocator A;
1435	StringSaver Saver(A);
1436	NewArgv.push_back(Elt: argv[0]);
1437
1438	// Parse options from environment variable.
1439	if (EnvVar) {
1440	if (std::optional<std::string> EnvValue =
1441	sys::Process::GetEnv(name: StringRef(EnvVar)))
1442	TokenizeGNUCommandLine(Src: *EnvValue, Saver, NewArgv);
1443	}
1444
1445	// Append options from command line.
1446	for (int I = 1; I < argc; ++I)
1447	NewArgv.push_back(Elt: argv[I]);
1448	int NewArgc = static_cast<int>(NewArgv.size());
1449
1450	// Parse all options.
1451	return GlobalParser->ParseCommandLineOptions(argc: NewArgc, argv: &NewArgv[0], Overview,
1452	Errs, LongOptionsUseDoubleDash);
1453	}
1454
1455	/// Reset all options at least once, so that we can parse different options.
1456	void CommandLineParser::ResetAllOptionOccurrences() {
1457	// Reset all option values to look like they have never been seen before.
1458	// Options might be reset twice (they can be reference in both OptionsMap
1459	// and one of the other members), but that does not harm.
1460	for (auto *SC : RegisteredSubCommands) {
1461	for (auto &O : SC->OptionsMap)
1462	O.second->reset();
1463	for (Option *O : SC->PositionalOpts)
1464	O->reset();
1465	for (Option *O : SC->SinkOpts)
1466	O->reset();
1467	if (SC->ConsumeAfterOpt)
1468	SC->ConsumeAfterOpt->reset();
1469	}
1470	}
1471
1472	bool CommandLineParser::ParseCommandLineOptions(int argc,
1473	const char *const *argv,
1474	StringRef Overview,
1475	raw_ostream *Errs,
1476	bool LongOptionsUseDoubleDash) {
1477	assert(hasOptions() && "No options specified!");
1478
1479	ProgramOverview = Overview;
1480	bool IgnoreErrors = Errs;
1481	if (!Errs)
1482	Errs = &errs();
1483	bool ErrorParsing = false;
1484
1485	// Expand response files.
1486	SmallVector<const char *, 20> newArgv(argv, argv + argc);
1487	BumpPtrAllocator A;
1488	#ifdef _WIN32
1489	auto Tokenize = cl::TokenizeWindowsCommandLine;
1490	#else
1491	auto Tokenize = cl::TokenizeGNUCommandLine;
1492	#endif
1493	ExpansionContext ECtx(A, Tokenize);
1494	if (Error Err = ECtx.expandResponseFiles(Argv&: newArgv)) {
1495	*Errs << toString(E: std::move(Err)) << '\n';
1496	return false;
1497	}
1498	argv = &newArgv[0];
1499	argc = static_cast<int>(newArgv.size());
1500
1501	// Copy the program name into ProgName, making sure not to overflow it.
1502	ProgramName = std::string(sys::path::filename(path: StringRef(argv[0])));
1503
1504	// Check out the positional arguments to collect information about them.
1505	unsigned NumPositionalRequired = 0;
1506
1507	// Determine whether or not there are an unlimited number of positionals
1508	bool HasUnlimitedPositionals = false;
1509
1510	int FirstArg = 1;
1511	SubCommand *ChosenSubCommand = &SubCommand::getTopLevel();
1512	std::string NearestSubCommandString;
1513	bool MaybeNamedSubCommand =
1514	argc >= 2 && argv[FirstArg][0] != '-' && hasNamedSubCommands();
1515	if (MaybeNamedSubCommand) {
1516	// If the first argument specifies a valid subcommand, start processing
1517	// options from the second argument.
1518	ChosenSubCommand =
1519	LookupSubCommand(Name: StringRef(argv[FirstArg]), NearestString&: NearestSubCommandString);
1520	if (ChosenSubCommand != &SubCommand::getTopLevel())
1521	FirstArg = 2;
1522	}
1523	GlobalParser->ActiveSubCommand = ChosenSubCommand;
1524
1525	assert(ChosenSubCommand);
1526	auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
1527	auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
1528	auto &SinkOpts = ChosenSubCommand->SinkOpts;
1529	auto &OptionsMap = ChosenSubCommand->OptionsMap;
1530
1531	for (auto *O: DefaultOptions) {
1532	addOption(O, ProcessDefaultOption: true);
1533	}
1534
1535	if (ConsumeAfterOpt) {
1536	assert(PositionalOpts.size() > 0 &&
1537	"Cannot specify cl::ConsumeAfter without a positional argument!");
1538	}
1539	if (!PositionalOpts.empty()) {
1540
1541	// Calculate how many positional values are _required_.
1542	bool UnboundedFound = false;
1543	for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
1544	Option *Opt = PositionalOpts[i];
1545	if (RequiresValue(O: Opt))
1546	++NumPositionalRequired;
1547	else if (ConsumeAfterOpt) {
1548	// ConsumeAfter cannot be combined with "optional" positional options
1549	// unless there is only one positional argument...
1550	if (PositionalOpts.size() > 1) {
1551	if (!IgnoreErrors)
1552	Opt->error(Message: "error - this positional option will never be matched, "
1553	"because it does not Require a value, and a "
1554	"cl::ConsumeAfter option is active!");
1555	ErrorParsing = true;
1556	}
1557	} else if (UnboundedFound && !Opt->hasArgStr()) {
1558	// This option does not "require" a value... Make sure this option is
1559	// not specified after an option that eats all extra arguments, or this
1560	// one will never get any!
1561	//
1562	if (!IgnoreErrors)
1563	Opt->error(Message: "error - option can never match, because "
1564	"another positional argument will match an "
1565	"unbounded number of values, and this option"
1566	" does not require a value!");
1567	*Errs << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr
1568	<< "' is all messed up!\n";
1569	*Errs << PositionalOpts.size();
1570	ErrorParsing = true;
1571	}
1572	UnboundedFound |= EatsUnboundedNumberOfValues(O: Opt);
1573	}
1574	HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;
1575	}
1576
1577	// PositionalVals - A vector of "positional" arguments we accumulate into
1578	// the process at the end.
1579	//
1580	SmallVector<std::pair<StringRef, unsigned>, 4> PositionalVals;
1581
1582	// If the program has named positional arguments, and the name has been run
1583	// across, keep track of which positional argument was named. Otherwise put
1584	// the positional args into the PositionalVals list...
1585	Option *ActivePositionalArg = nullptr;
1586
1587	// Loop over all of the arguments... processing them.
1588	bool DashDashFound = false; // Have we read '--'?
1589	for (int i = FirstArg; i < argc; ++i) {
1590	Option *Handler = nullptr;
1591	std::string NearestHandlerString;
1592	StringRef Value;
1593	StringRef ArgName = "";
1594	bool HaveDoubleDash = false;
1595
1596	// Check to see if this is a positional argument. This argument is
1597	// considered to be positional if it doesn't start with '-', if it is "-"
1598	// itself, or if we have seen "--" already.
1599	//
1600	if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
1601	// Positional argument!
1602	if (ActivePositionalArg) {
1603	ProvidePositionalOption(Handler: ActivePositionalArg, Arg: StringRef(argv[i]), i);
1604	continue; // We are done!
1605	}
1606
1607	if (!PositionalOpts.empty()) {
1608	PositionalVals.push_back(Elt: std::make_pair(x: StringRef(argv[i]), y&: i));
1609
1610	// All of the positional arguments have been fulfulled, give the rest to
1611	// the consume after option... if it's specified...
1612	//
1613	if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) {
1614	for (++i; i < argc; ++i)
1615	PositionalVals.push_back(Elt: std::make_pair(x: StringRef(argv[i]), y&: i));
1616	break; // Handle outside of the argument processing loop...
1617	}
1618
1619	// Delay processing positional arguments until the end...
1620	continue;
1621	}
1622	} else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&
1623	!DashDashFound) {
1624	DashDashFound = true; // This is the mythical "--"?
1625	continue; // Don't try to process it as an argument itself.
1626	} else if (ActivePositionalArg &&
1627	(ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) {
1628	// If there is a positional argument eating options, check to see if this
1629	// option is another positional argument. If so, treat it as an argument,
1630	// otherwise feed it to the eating positional.
1631	ArgName = StringRef(argv[i] + 1);
1632	// Eat second dash.
1633	if (ArgName.consume_front(Prefix: "-"))
1634	HaveDoubleDash = true;
1635
1636	Handler = LookupLongOption(Sub&: *ChosenSubCommand, Arg&: ArgName, Value,
1637	LongOptionsUseDoubleDash, HaveDoubleDash);
1638	if (!Handler || Handler->getFormattingFlag() != cl::Positional) {
1639	ProvidePositionalOption(Handler: ActivePositionalArg, Arg: StringRef(argv[i]), i);
1640	continue; // We are done!
1641	}
1642	} else { // We start with a '-', must be an argument.
1643	ArgName = StringRef(argv[i] + 1);
1644	// Eat second dash.
1645	if (ArgName.consume_front(Prefix: "-"))
1646	HaveDoubleDash = true;
1647
1648	Handler = LookupLongOption(Sub&: *ChosenSubCommand, Arg&: ArgName, Value,
1649	LongOptionsUseDoubleDash, HaveDoubleDash);
1650
1651	// If Handler is not found in a specialized subcommand, look up handler
1652	// in the top-level subcommand.
1653	// cl::opt without cl::sub belongs to top-level subcommand.
1654	if (!Handler && ChosenSubCommand != &SubCommand::getTopLevel())
1655	Handler = LookupLongOption(Sub&: SubCommand::getTopLevel(), Arg&: ArgName, Value,
1656	LongOptionsUseDoubleDash, HaveDoubleDash);
1657
1658	// Check to see if this "option" is really a prefixed or grouped argument.
1659	if (!Handler && !(LongOptionsUseDoubleDash && HaveDoubleDash))
1660	Handler = HandlePrefixedOrGroupedOption(Arg&: ArgName, Value, ErrorParsing,
1661	OptionsMap);
1662
1663	// Otherwise, look for the closest available option to report to the user
1664	// in the upcoming error.
1665	if (!Handler && SinkOpts.empty())
1666	LookupNearestOption(Arg: ArgName, OptionsMap, NearestString&: NearestHandlerString);
1667	}
1668
1669	if (!Handler) {
1670	if (!SinkOpts.empty()) {
1671	for (Option *SinkOpt : SinkOpts)
1672	SinkOpt->addOccurrence(pos: i, ArgName: "", Value: StringRef(argv[i]));
1673	continue;
1674	}
1675
1676	auto ReportUnknownArgument = [&](bool IsArg,
1677	StringRef NearestArgumentName) {
1678	*Errs << ProgramName << ": Unknown "
1679	<< (IsArg ? "command line argument" : "subcommand") << " '"
1680	<< argv[i] << "'. Try: '" << argv[0] << " --help'\n";
1681
1682	if (NearestArgumentName.empty())
1683	return;
1684
1685	*Errs << ProgramName << ": Did you mean '";
1686	if (IsArg)
1687	*Errs << PrintArg(NearestArgumentName, 0);
1688	else
1689	*Errs << NearestArgumentName;
1690	*Errs << "'?\n";
1691	};
1692
1693	if (i > 1 || !MaybeNamedSubCommand)
1694	ReportUnknownArgument(/*IsArg=*/true, NearestHandlerString);
1695	else
1696	ReportUnknownArgument(/*IsArg=*/false, NearestSubCommandString);
1697
1698	ErrorParsing = true;
1699	continue;
1700	}
1701
1702	// If this is a named positional argument, just remember that it is the
1703	// active one...
1704	if (Handler->getFormattingFlag() == cl::Positional) {
1705	if ((Handler->getMiscFlags() & PositionalEatsArgs) && !Value.empty()) {
1706	Handler->error(Message: "This argument does not take a value.\n"
1707	"\tInstead, it consumes any positional arguments until "
1708	"the next recognized option.", Errs&: *Errs);
1709	ErrorParsing = true;
1710	}
1711	ActivePositionalArg = Handler;
1712	}
1713	else
1714	ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
1715	}
1716
1717	// Check and handle positional arguments now...
1718	if (NumPositionalRequired > PositionalVals.size()) {
1719	*Errs << ProgramName
1720	<< ": Not enough positional command line arguments specified!\n"
1721	<< "Must specify at least " << NumPositionalRequired
1722	<< " positional argument" << (NumPositionalRequired > 1 ? "s" : "")
1723	<< ": See: " << argv[0] << " --help\n";
1724
1725	ErrorParsing = true;
1726	} else if (!HasUnlimitedPositionals &&
1727	PositionalVals.size() > PositionalOpts.size()) {
1728	*Errs << ProgramName << ": Too many positional arguments specified!\n"
1729	<< "Can specify at most " << PositionalOpts.size()
1730	<< " positional arguments: See: " << argv[0] << " --help\n";
1731	ErrorParsing = true;
1732
1733	} else if (!ConsumeAfterOpt) {
1734	// Positional args have already been handled if ConsumeAfter is specified.
1735	unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size());
1736	for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
1737	if (RequiresValue(O: PositionalOpts[i])) {
1738	ProvidePositionalOption(Handler: PositionalOpts[i], Arg: PositionalVals[ValNo].first,
1739	i: PositionalVals[ValNo].second);
1740	ValNo++;
1741	--NumPositionalRequired; // We fulfilled our duty...
1742	}
1743
1744	// If we _can_ give this option more arguments, do so now, as long as we
1745	// do not give it values that others need. 'Done' controls whether the
1746	// option even _WANTS_ any more.
1747	//
1748	bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required;
1749	while (NumVals - ValNo > NumPositionalRequired && !Done) {
1750	switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
1751	case cl::Optional:
1752	Done = true; // Optional arguments want _at most_ one value
1753	[[fallthrough]];
1754	case cl::ZeroOrMore: // Zero or more will take all they can get...
1755	case cl::OneOrMore: // One or more will take all they can get...
1756	ProvidePositionalOption(Handler: PositionalOpts[i],
1757	Arg: PositionalVals[ValNo].first,
1758	i: PositionalVals[ValNo].second);
1759	ValNo++;
1760	break;
1761	default:
1762	llvm_unreachable("Internal error, unexpected NumOccurrences flag in "
1763	"positional argument processing!");
1764	}
1765	}
1766	}
1767	} else {
1768	assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());
1769	unsigned ValNo = 0;
1770	for (size_t J = 0, E = PositionalOpts.size(); J != E; ++J)
1771	if (RequiresValue(O: PositionalOpts[J])) {
1772	ErrorParsing |= ProvidePositionalOption(Handler: PositionalOpts[J],
1773	Arg: PositionalVals[ValNo].first,
1774	i: PositionalVals[ValNo].second);
1775	ValNo++;
1776	}
1777
1778	// Handle the case where there is just one positional option, and it's
1779	// optional. In this case, we want to give JUST THE FIRST option to the
1780	// positional option and keep the rest for the consume after. The above
1781	// loop would have assigned no values to positional options in this case.
1782	//
1783	if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) {
1784	ErrorParsing |= ProvidePositionalOption(Handler: PositionalOpts[0],
1785	Arg: PositionalVals[ValNo].first,
1786	i: PositionalVals[ValNo].second);
1787	ValNo++;
1788	}
1789
1790	// Handle over all of the rest of the arguments to the
1791	// cl::ConsumeAfter command line option...
1792	for (; ValNo != PositionalVals.size(); ++ValNo)
1793	ErrorParsing |=
1794	ProvidePositionalOption(Handler: ConsumeAfterOpt, Arg: PositionalVals[ValNo].first,
1795	i: PositionalVals[ValNo].second);
1796	}
1797
1798	// Loop over args and make sure all required args are specified!
1799	for (const auto &Opt : OptionsMap) {
1800	switch (Opt.second->getNumOccurrencesFlag()) {
1801	case Required:
1802	case OneOrMore:
1803	if (Opt.second->getNumOccurrences() == 0) {
1804	Opt.second->error(Message: "must be specified at least once!");
1805	ErrorParsing = true;
1806	}
1807	[[fallthrough]];
1808	default:
1809	break;
1810	}
1811	}
1812
1813	// Now that we know if -debug is specified, we can use it.
1814	// Note that if ReadResponseFiles == true, this must be done before the
1815	// memory allocated for the expanded command line is free()d below.
1816	LLVM_DEBUG(dbgs() << "Args: ";
1817	for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' ';
1818	dbgs() << '\n';);
1819
1820	// Free all of the memory allocated to the map. Command line options may only
1821	// be processed once!
1822	MoreHelp.clear();
1823
1824	// If we had an error processing our arguments, don't let the program execute
1825	if (ErrorParsing) {
1826	if (!IgnoreErrors)
1827	exit(status: 1);
1828	return false;
1829	}
1830	return true;
1831	}
1832
1833	//===----------------------------------------------------------------------===//
1834	// Option Base class implementation
1835	//
1836
1837	bool Option::error(const Twine &Message, StringRef ArgName, raw_ostream &Errs) {
1838	if (!ArgName.data())
1839	ArgName = ArgStr;
1840	if (ArgName.empty())
1841	Errs << HelpStr; // Be nice for positional arguments
1842	else
1843	Errs << GlobalParser->ProgramName << ": for the " << PrintArg(ArgName, 0);
1844
1845	Errs << " option: " << Message << "\n";
1846	return true;
1847	}
1848
1849	bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
1850	bool MultiArg) {
1851	if (!MultiArg)
1852	NumOccurrences++; // Increment the number of times we have been seen
1853
1854	return handleOccurrence(pos, ArgName, Arg: Value);
1855	}
1856
1857	// getValueStr - Get the value description string, using "DefaultMsg" if nothing
1858	// has been specified yet.
1859	//
1860	static StringRef getValueStr(const Option &O, StringRef DefaultMsg) {
1861	if (O.ValueStr.empty())
1862	return DefaultMsg;
1863	return O.ValueStr;
1864	}
1865
1866	//===----------------------------------------------------------------------===//
1867	// cl::alias class implementation
1868	//
1869
1870	// Return the width of the option tag for printing...
1871	size_t alias::getOptionWidth() const {
1872	return argPlusPrefixesSize(ArgName: ArgStr);
1873	}
1874
1875	void Option::printHelpStr(StringRef HelpStr, size_t Indent,
1876	size_t FirstLineIndentedBy) {
1877	assert(Indent >= FirstLineIndentedBy);
1878	std::pair<StringRef, StringRef> Split = HelpStr.split(Separator: '\n');
1879	outs().indent(NumSpaces: Indent - FirstLineIndentedBy)
1880	<< ArgHelpPrefix << Split.first << "\n";
1881	while (!Split.second.empty()) {
1882	Split = Split.second.split(Separator: '\n');
1883	outs().indent(NumSpaces: Indent) << Split.first << "\n";
1884	}
1885	}
1886
1887	void Option::printEnumValHelpStr(StringRef HelpStr, size_t BaseIndent,
1888	size_t FirstLineIndentedBy) {
1889	const StringRef ValHelpPrefix = " ";
1890	assert(BaseIndent >= FirstLineIndentedBy);
1891	std::pair<StringRef, StringRef> Split = HelpStr.split(Separator: '\n');
1892	outs().indent(NumSpaces: BaseIndent - FirstLineIndentedBy)
1893	<< ArgHelpPrefix << ValHelpPrefix << Split.first << "\n";
1894	while (!Split.second.empty()) {
1895	Split = Split.second.split(Separator: '\n');
1896	outs().indent(NumSpaces: BaseIndent + ValHelpPrefix.size()) << Split.first << "\n";
1897	}
1898	}
1899
1900	// Print out the option for the alias.
1901	void alias::printOptionInfo(size_t GlobalWidth) const {
1902	outs() << PrintArg(ArgStr);
1903	printHelpStr(HelpStr, Indent: GlobalWidth, FirstLineIndentedBy: argPlusPrefixesSize(ArgName: ArgStr));
1904	}
1905
1906	//===----------------------------------------------------------------------===//
1907	// Parser Implementation code...
1908	//
1909
1910	// basic_parser implementation
1911	//
1912
1913	// Return the width of the option tag for printing...
1914	size_t basic_parser_impl::getOptionWidth(const Option &O) const {
1915	size_t Len = argPlusPrefixesSize(ArgName: O.ArgStr);
1916	auto ValName = getValueName();
1917	if (!ValName.empty()) {
1918	size_t FormattingLen = 3;
1919	if (O.getMiscFlags() & PositionalEatsArgs)
1920	FormattingLen = 6;
1921	Len += getValueStr(O, DefaultMsg: ValName).size() + FormattingLen;
1922	}
1923
1924	return Len;
1925	}
1926
1927	// printOptionInfo - Print out information about this option. The
1928	// to-be-maintained width is specified.
1929	//
1930	void basic_parser_impl::printOptionInfo(const Option &O,
1931	size_t GlobalWidth) const {
1932	outs() << PrintArg(O.ArgStr);
1933
1934	auto ValName = getValueName();
1935	if (!ValName.empty()) {
1936	if (O.getMiscFlags() & PositionalEatsArgs) {
1937	outs() << " <" << getValueStr(O, DefaultMsg: ValName) << ">...";
1938	} else if (O.getValueExpectedFlag() == ValueOptional)
1939	outs() << "[=<" << getValueStr(O, DefaultMsg: ValName) << ">]";
1940	else {
1941	outs() << (O.ArgStr.size() == 1 ? " <" : "=<") << getValueStr(O, DefaultMsg: ValName)
1942	<< '>';
1943	}
1944	}
1945
1946	Option::printHelpStr(HelpStr: O.HelpStr, Indent: GlobalWidth, FirstLineIndentedBy: getOptionWidth(O));
1947	}
1948
1949	void basic_parser_impl::printOptionName(const Option &O,
1950	size_t GlobalWidth) const {
1951	outs() << PrintArg(O.ArgStr);
1952	outs().indent(NumSpaces: GlobalWidth - O.ArgStr.size());
1953	}
1954
1955	// parser<bool> implementation
1956	//
1957	bool parser<bool>::parse(Option &O, StringRef ArgName, StringRef Arg,
1958	bool &Value) {
1959	if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
1960	Arg == "1") {
1961	Value = true;
1962	return false;
1963	}
1964
1965	if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
1966	Value = false;
1967	return false;
1968	}
1969	return O.error(Message: "'" + Arg +
1970	"' is invalid value for boolean argument! Try 0 or 1");
1971	}
1972
1973	// parser<boolOrDefault> implementation
1974	//
1975	bool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, StringRef Arg,
1976	boolOrDefault &Value) {
1977	if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
1978	Arg == "1") {
1979	Value = BOU_TRUE;
1980	return false;
1981	}
1982	if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
1983	Value = BOU_FALSE;
1984	return false;
1985	}
1986
1987	return O.error(Message: "'" + Arg +
1988	"' is invalid value for boolean argument! Try 0 or 1");
1989	}
1990
1991	// parser<int> implementation
1992	//
1993	bool parser<int>::parse(Option &O, StringRef ArgName, StringRef Arg,
1994	int &Value) {
1995	if (Arg.getAsInteger(Radix: 0, Result&: Value))
1996	return O.error(Message: "'" + Arg + "' value invalid for integer argument!");
1997	return false;
1998	}
1999
2000	// parser<long> implementation
2001	//
2002	bool parser<long>::parse(Option &O, StringRef ArgName, StringRef Arg,
2003	long &Value) {
2004	if (Arg.getAsInteger(Radix: 0, Result&: Value))
2005	return O.error(Message: "'" + Arg + "' value invalid for long argument!");
2006	return false;
2007	}
2008
2009	// parser<long long> implementation
2010	//
2011	bool parser<long long>::parse(Option &O, StringRef ArgName, StringRef Arg,
2012	long long &Value) {
2013	if (Arg.getAsInteger(Radix: 0, Result&: Value))
2014	return O.error(Message: "'" + Arg + "' value invalid for llong argument!");
2015	return false;
2016	}
2017
2018	// parser<unsigned> implementation
2019	//
2020	bool parser<unsigned>::parse(Option &O, StringRef ArgName, StringRef Arg,
2021	unsigned &Value) {
2022
2023	if (Arg.getAsInteger(Radix: 0, Result&: Value))
2024	return O.error(Message: "'" + Arg + "' value invalid for uint argument!");
2025	return false;
2026	}
2027
2028	// parser<unsigned long> implementation
2029	//
2030	bool parser<unsigned long>::parse(Option &O, StringRef ArgName, StringRef Arg,
2031	unsigned long &Value) {
2032
2033	if (Arg.getAsInteger(Radix: 0, Result&: Value))
2034	return O.error(Message: "'" + Arg + "' value invalid for ulong argument!");
2035	return false;
2036	}
2037
2038	// parser<unsigned long long> implementation
2039	//
2040	bool parser<unsigned long long>::parse(Option &O, StringRef ArgName,
2041	StringRef Arg,
2042	unsigned long long &Value) {
2043
2044	if (Arg.getAsInteger(Radix: 0, Result&: Value))
2045	return O.error(Message: "'" + Arg + "' value invalid for ullong argument!");
2046	return false;
2047	}
2048
2049	// parser<double>/parser<float> implementation
2050	//
2051	static bool parseDouble(Option &O, StringRef Arg, double &Value) {
2052	if (to_float(T: Arg, Num&: Value))
2053	return false;
2054	return O.error(Message: "'" + Arg + "' value invalid for floating point argument!");
2055	}
2056
2057	bool parser<double>::parse(Option &O, StringRef ArgName, StringRef Arg,
2058	double &Val) {
2059	return parseDouble(O, Arg, Value&: Val);
2060	}
2061
2062	bool parser<float>::parse(Option &O, StringRef ArgName, StringRef Arg,
2063	float &Val) {
2064	double dVal;
2065	if (parseDouble(O, Arg, Value&: dVal))
2066	return true;
2067	Val = (float)dVal;
2068	return false;
2069	}
2070
2071	// generic_parser_base implementation
2072	//
2073
2074	// findOption - Return the option number corresponding to the specified
2075	// argument string. If the option is not found, getNumOptions() is returned.
2076	//
2077	unsigned generic_parser_base::findOption(StringRef Name) {
2078	unsigned e = getNumOptions();
2079
2080	for (unsigned i = 0; i != e; ++i) {
2081	if (getOption(N: i) == Name)
2082	return i;
2083	}
2084	return e;
2085	}
2086
2087	static StringRef EqValue = "=<value>";
2088	static StringRef EmptyOption = "<empty>";
2089	static StringRef OptionPrefix = " =";
2090	static size_t getOptionPrefixesSize() {
2091	return OptionPrefix.size() + ArgHelpPrefix.size();
2092	}
2093
2094	static bool shouldPrintOption(StringRef Name, StringRef Description,
2095	const Option &O) {
2096	return O.getValueExpectedFlag() != ValueOptional || !Name.empty() ||
2097	!Description.empty();
2098	}
2099
2100	// Return the width of the option tag for printing...
2101	size_t generic_parser_base::getOptionWidth(const Option &O) const {
2102	if (O.hasArgStr()) {
2103	size_t Size =
2104	argPlusPrefixesSize(ArgName: O.ArgStr) + EqValue.size();
2105	for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
2106	StringRef Name = getOption(N: i);
2107	if (!shouldPrintOption(Name, Description: getDescription(N: i), O))
2108	continue;
2109	size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size();
2110	Size = std::max(a: Size, b: NameSize + getOptionPrefixesSize());
2111	}
2112	return Size;
2113	} else {
2114	size_t BaseSize = 0;
2115	for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
2116	BaseSize = std::max(a: BaseSize, b: getOption(N: i).size() + 8);
2117	return BaseSize;
2118	}
2119	}
2120
2121	// printOptionInfo - Print out information about this option. The
2122	// to-be-maintained width is specified.
2123	//
2124	void generic_parser_base::printOptionInfo(const Option &O,
2125	size_t GlobalWidth) const {
2126	if (O.hasArgStr()) {
2127	// When the value is optional, first print a line just describing the
2128	// option without values.
2129	if (O.getValueExpectedFlag() == ValueOptional) {
2130	for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
2131	if (getOption(N: i).empty()) {
2132	outs() << PrintArg(O.ArgStr);
2133	Option::printHelpStr(HelpStr: O.HelpStr, Indent: GlobalWidth,
2134	FirstLineIndentedBy: argPlusPrefixesSize(ArgName: O.ArgStr));
2135	break;
2136	}
2137	}
2138	}
2139
2140	outs() << PrintArg(O.ArgStr) << EqValue;
2141	Option::printHelpStr(HelpStr: O.HelpStr, Indent: GlobalWidth,
2142	FirstLineIndentedBy: EqValue.size() +
2143	argPlusPrefixesSize(ArgName: O.ArgStr));
2144	for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
2145	StringRef OptionName = getOption(N: i);
2146	StringRef Description = getDescription(N: i);
2147	if (!shouldPrintOption(Name: OptionName, Description, O))
2148	continue;
2149	size_t FirstLineIndent = OptionName.size() + getOptionPrefixesSize();
2150	outs() << OptionPrefix << OptionName;
2151	if (OptionName.empty()) {
2152	outs() << EmptyOption;
2153	assert(FirstLineIndent >= EmptyOption.size());
2154	FirstLineIndent += EmptyOption.size();
2155	}
2156	if (!Description.empty())
2157	Option::printEnumValHelpStr(HelpStr: Description, BaseIndent: GlobalWidth, FirstLineIndentedBy: FirstLineIndent);
2158	else
2159	outs() << '\n';
2160	}
2161	} else {
2162	if (!O.HelpStr.empty())
2163	outs() << " " << O.HelpStr << '\n';
2164	for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
2165	StringRef Option = getOption(N: i);
2166	outs() << " " << PrintArg(Option);
2167	Option::printHelpStr(HelpStr: getDescription(N: i), Indent: GlobalWidth, FirstLineIndentedBy: Option.size() + 8);
2168	}
2169	}
2170	}
2171
2172	static const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff
2173
2174	// printGenericOptionDiff - Print the value of this option and it's default.
2175	//
2176	// "Generic" options have each value mapped to a name.
2177	void generic_parser_base::printGenericOptionDiff(
2178	const Option &O, const GenericOptionValue &Value,
2179	const GenericOptionValue &Default, size_t GlobalWidth) const {
2180	outs() << " " << PrintArg(O.ArgStr);
2181	outs().indent(NumSpaces: GlobalWidth - O.ArgStr.size());
2182
2183	unsigned NumOpts = getNumOptions();
2184	for (unsigned i = 0; i != NumOpts; ++i) {
2185	if (!Value.compare(V: getOptionValue(N: i)))
2186	continue;
2187
2188	outs() << "= " << getOption(N: i);
2189	size_t L = getOption(N: i).size();
2190	size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0;
2191	outs().indent(NumSpaces) << " (default: ";
2192	for (unsigned j = 0; j != NumOpts; ++j) {
2193	if (!Default.compare(V: getOptionValue(N: j)))
2194	continue;
2195	outs() << getOption(N: j);
2196	break;
2197	}
2198	outs() << ")\n";
2199	return;
2200	}
2201	outs() << "= *unknown option value*\n";
2202	}
2203
2204	// printOptionDiff - Specializations for printing basic value types.
2205	//
2206	#define PRINT_OPT_DIFF(T) \
2207	void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \
2208	size_t GlobalWidth) const { \
2209	printOptionName(O, GlobalWidth); \
2210	std::string Str; \
2211	{ \
2212	raw_string_ostream SS(Str); \
2213	SS << V; \
2214	} \
2215	outs() << "= " << Str; \
2216	size_t NumSpaces = \
2217	MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \
2218	outs().indent(NumSpaces) << " (default: "; \
2219	if (D.hasValue()) \
2220	outs() << D.getValue(); \
2221	else \
2222	outs() << "*no default*"; \
2223	outs() << ")\n"; \
2224	}
2225
2226	PRINT_OPT_DIFF(bool)
2227	PRINT_OPT_DIFF(boolOrDefault)
2228	PRINT_OPT_DIFF(int)
2229	PRINT_OPT_DIFF(long)
2230	PRINT_OPT_DIFF(long long)
2231	PRINT_OPT_DIFF(unsigned)
2232	PRINT_OPT_DIFF(unsigned long)
2233	PRINT_OPT_DIFF(unsigned long long)
2234	PRINT_OPT_DIFF(double)
2235	PRINT_OPT_DIFF(float)
2236	PRINT_OPT_DIFF(char)
2237
2238	void parser<std::string>::printOptionDiff(const Option &O, StringRef V,
2239	const OptionValue<std::string> &D,
2240	size_t GlobalWidth) const {
2241	printOptionName(O, GlobalWidth);
2242	outs() << "= " << V;
2243	size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;
2244	outs().indent(NumSpaces) << " (default: ";
2245	if (D.hasValue())
2246	outs() << D.getValue();
2247	else
2248	outs() << "*no default*";
2249	outs() << ")\n";
2250	}
2251
2252	// Print a placeholder for options that don't yet support printOptionDiff().
2253	void basic_parser_impl::printOptionNoValue(const Option &O,
2254	size_t GlobalWidth) const {
2255	printOptionName(O, GlobalWidth);
2256	outs() << "= *cannot print option value*\n";
2257	}
2258
2259	//===----------------------------------------------------------------------===//
2260	// -help and -help-hidden option implementation
2261	//
2262
2263	static int OptNameCompare(const std::pair<const char *, Option *> *LHS,
2264	const std::pair<const char *, Option *> *RHS) {
2265	return strcmp(s1: LHS->first, s2: RHS->first);
2266	}
2267
2268	static int SubNameCompare(const std::pair<const char *, SubCommand *> *LHS,
2269	const std::pair<const char *, SubCommand *> *RHS) {
2270	return strcmp(s1: LHS->first, s2: RHS->first);
2271	}
2272
2273	// Copy Options into a vector so we can sort them as we like.
2274	static void sortOpts(StringMap<Option *> &OptMap,
2275	SmallVectorImpl<std::pair<const char *, Option *>> &Opts,
2276	bool ShowHidden) {
2277	SmallPtrSet<Option *, 32> OptionSet; // Duplicate option detection.
2278
2279	for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end();
2280	I != E; ++I) {
2281	// Ignore really-hidden options.
2282	if (I->second->getOptionHiddenFlag() == ReallyHidden)
2283	continue;
2284
2285	// Unless showhidden is set, ignore hidden flags.
2286	if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden)
2287	continue;
2288
2289	// If we've already seen this option, don't add it to the list again.
2290	if (!OptionSet.insert(Ptr: I->second).second)
2291	continue;
2292
2293	Opts.push_back(
2294	Elt: std::pair<const char *, Option *>(I->getKey().data(), I->second));
2295	}
2296
2297	// Sort the options list alphabetically.
2298	array_pod_sort(Start: Opts.begin(), End: Opts.end(), Compare: OptNameCompare);
2299	}
2300
2301	static void
2302	sortSubCommands(const SmallPtrSetImpl<SubCommand *> &SubMap,
2303	SmallVectorImpl<std::pair<const char *, SubCommand *>> &Subs) {
2304	for (auto *S : SubMap) {
2305	if (S->getName().empty())
2306	continue;
2307	Subs.push_back(Elt: std::make_pair(x: S->getName().data(), y&: S));
2308	}
2309	array_pod_sort(Start: Subs.begin(), End: Subs.end(), Compare: SubNameCompare);
2310	}
2311
2312	namespace {
2313
2314	class HelpPrinter {
2315	protected:
2316	const bool ShowHidden;
2317	typedef SmallVector<std::pair<const char *, Option *>, 128>
2318	StrOptionPairVector;
2319	typedef SmallVector<std::pair<const char *, SubCommand *>, 128>
2320	StrSubCommandPairVector;
2321	// Print the options. Opts is assumed to be alphabetically sorted.
2322	virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
2323	for (size_t i = 0, e = Opts.size(); i != e; ++i)
2324	Opts[i].second->printOptionInfo(GlobalWidth: MaxArgLen);
2325	}
2326
2327	void printSubCommands(StrSubCommandPairVector &Subs, size_t MaxSubLen) {
2328	for (const auto &S : Subs) {
2329	outs() << " " << S.first;
2330	if (!S.second->getDescription().empty()) {
2331	outs().indent(NumSpaces: MaxSubLen - strlen(s: S.first));
2332	outs() << " - " << S.second->getDescription();
2333	}
2334	outs() << "\n";
2335	}
2336	}
2337
2338	public:
2339	explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
2340	virtual ~HelpPrinter() = default;
2341
2342	// Invoke the printer.
2343	void operator=(bool Value) {
2344	if (!Value)
2345	return;
2346	printHelp();
2347
2348	// Halt the program since help information was printed
2349	exit(status: 0);
2350	}
2351
2352	void printHelp() {
2353	SubCommand *Sub = GlobalParser->getActiveSubCommand();
2354	auto &OptionsMap = Sub->OptionsMap;
2355	auto &PositionalOpts = Sub->PositionalOpts;
2356	auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
2357
2358	StrOptionPairVector Opts;
2359	sortOpts(OptMap&: OptionsMap, Opts, ShowHidden);
2360
2361	StrSubCommandPairVector Subs;
2362	sortSubCommands(SubMap: GlobalParser->RegisteredSubCommands, Subs);
2363
2364	if (!GlobalParser->ProgramOverview.empty())
2365	outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";
2366
2367	if (Sub == &SubCommand::getTopLevel()) {
2368	outs() << "USAGE: " << GlobalParser->ProgramName;
2369	if (!Subs.empty())
2370	outs() << " [subcommand]";
2371	outs() << " [options]";
2372	} else {
2373	if (!Sub->getDescription().empty()) {
2374	outs() << "SUBCOMMAND '" << Sub->getName()
2375	<< "': " << Sub->getDescription() << "\n\n";
2376	}
2377	outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName()
2378	<< " [options]";
2379	}
2380
2381	for (auto *Opt : PositionalOpts) {
2382	if (Opt->hasArgStr())
2383	outs() << " --" << Opt->ArgStr;
2384	outs() << " " << Opt->HelpStr;
2385	}
2386
2387	// Print the consume after option info if it exists...
2388	if (ConsumeAfterOpt)
2389	outs() << " " << ConsumeAfterOpt->HelpStr;
2390
2391	if (Sub == &SubCommand::getTopLevel() && !Subs.empty()) {
2392	// Compute the maximum subcommand length...
2393	size_t MaxSubLen = 0;
2394	for (size_t i = 0, e = Subs.size(); i != e; ++i)
2395	MaxSubLen = std::max(a: MaxSubLen, b: strlen(s: Subs[i].first));
2396
2397	outs() << "\n\n";
2398	outs() << "SUBCOMMANDS:\n\n";
2399	printSubCommands(Subs, MaxSubLen);
2400	outs() << "\n";
2401	outs() << " Type \"" << GlobalParser->ProgramName
2402	<< " <subcommand> --help\" to get more help on a specific "
2403	"subcommand";
2404	}
2405
2406	outs() << "\n\n";
2407
2408	// Compute the maximum argument length...
2409	size_t MaxArgLen = 0;
2410	for (size_t i = 0, e = Opts.size(); i != e; ++i)
2411	MaxArgLen = std::max(a: MaxArgLen, b: Opts[i].second->getOptionWidth());
2412
2413	outs() << "OPTIONS:\n";
2414	printOptions(Opts, MaxArgLen);
2415
2416	// Print any extra help the user has declared.
2417	for (const auto &I : GlobalParser->MoreHelp)
2418	outs() << I;
2419	GlobalParser->MoreHelp.clear();
2420	}
2421	};
2422
2423	class CategorizedHelpPrinter : public HelpPrinter {
2424	public:
2425	explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}
2426
2427	// Helper function for printOptions().
2428	// It shall return a negative value if A's name should be lexicographically
2429	// ordered before B's name. It returns a value greater than zero if B's name
2430	// should be ordered before A's name, and it returns 0 otherwise.
2431	static int OptionCategoryCompare(OptionCategory *const *A,
2432	OptionCategory *const *B) {
2433	return (*A)->getName().compare(RHS: (*B)->getName());
2434	}
2435
2436	// Make sure we inherit our base class's operator=()
2437	using HelpPrinter::operator=;
2438
2439	protected:
2440	void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override {
2441	std::vector<OptionCategory *> SortedCategories;
2442	DenseMap<OptionCategory *, std::vector<Option *>> CategorizedOptions;
2443
2444	// Collect registered option categories into vector in preparation for
2445	// sorting.
2446	for (OptionCategory *Category : GlobalParser->RegisteredOptionCategories)
2447	SortedCategories.push_back(x: Category);
2448
2449	// Sort the different option categories alphabetically.
2450	assert(SortedCategories.size() > 0 && "No option categories registered!");
2451	array_pod_sort(Start: SortedCategories.begin(), End: SortedCategories.end(),
2452	Compare: OptionCategoryCompare);
2453
2454	// Walk through pre-sorted options and assign into categories.
2455	// Because the options are already alphabetically sorted the
2456	// options within categories will also be alphabetically sorted.
2457	for (size_t I = 0, E = Opts.size(); I != E; ++I) {
2458	Option *Opt = Opts[I].second;
2459	for (auto &Cat : Opt->Categories) {
2460	assert(llvm::is_contained(SortedCategories, Cat) &&
2461	"Option has an unregistered category");
2462	CategorizedOptions[Cat].push_back(x: Opt);
2463	}
2464	}
2465
2466	// Now do printing.
2467	for (OptionCategory *Category : SortedCategories) {
2468	// Hide empty categories for --help, but show for --help-hidden.
2469	const auto &CategoryOptions = CategorizedOptions[Category];
2470	if (CategoryOptions.empty())
2471	continue;
2472
2473	// Print category information.
2474	outs() << "\n";
2475	outs() << Category->getName() << ":\n";
2476
2477	// Check if description is set.
2478	if (!Category->getDescription().empty())
2479	outs() << Category->getDescription() << "\n\n";
2480	else
2481	outs() << "\n";
2482
2483	// Loop over the options in the category and print.
2484	for (const Option *Opt : CategoryOptions)
2485	Opt->printOptionInfo(GlobalWidth: MaxArgLen);
2486	}
2487	}
2488	};
2489
2490	// This wraps the Uncategorizing and Categorizing printers and decides
2491	// at run time which should be invoked.
2492	class HelpPrinterWrapper {
2493	private:
2494	HelpPrinter &UncategorizedPrinter;
2495	CategorizedHelpPrinter &CategorizedPrinter;
2496
2497	public:
2498	explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,
2499	CategorizedHelpPrinter &CategorizedPrinter)
2500	: UncategorizedPrinter(UncategorizedPrinter),
2501	CategorizedPrinter(CategorizedPrinter) {}
2502
2503	// Invoke the printer.
2504	void operator=(bool Value);
2505	};
2506
2507	} // End anonymous namespace
2508
2509	#if defined(__GNUC__)
2510	// GCC and GCC-compatible compilers define __OPTIMIZE__ when optimizations are
2511	// enabled.
2512	# if defined(__OPTIMIZE__)
2513	# define LLVM_IS_DEBUG_BUILD 0
2514	# else
2515	# define LLVM_IS_DEBUG_BUILD 1
2516	# endif
2517	#elif defined(_MSC_VER)
2518	// MSVC doesn't have a predefined macro indicating if optimizations are enabled.
2519	// Use _DEBUG instead. This macro actually corresponds to the choice between
2520	// debug and release CRTs, but it is a reasonable proxy.
2521	# if defined(_DEBUG)
2522	# define LLVM_IS_DEBUG_BUILD 1
2523	# else
2524	# define LLVM_IS_DEBUG_BUILD 0
2525	# endif
2526	#else
2527	// Otherwise, for an unknown compiler, assume this is an optimized build.
2528	# define LLVM_IS_DEBUG_BUILD 0
2529	#endif
2530
2531	namespace {
2532	class VersionPrinter {
2533	public:
2534	void print(std::vector<VersionPrinterTy> ExtraPrinters = {}) {
2535	raw_ostream &OS = outs();
2536	#ifdef PACKAGE_VENDOR
2537	OS << PACKAGE_VENDOR << " ";
2538	#else
2539	OS << "LLVM (http://llvm.org/):\n ";
2540	#endif
2541	OS << PACKAGE_NAME << " version " << PACKAGE_VERSION << "\n ";
2542	#if LLVM_IS_DEBUG_BUILD
2543	OS << "DEBUG build";
2544	#else
2545	OS << "Optimized build";
2546	#endif
2547	#ifndef NDEBUG
2548	OS << " with assertions";
2549	#endif
2550	OS << ".\n";
2551
2552	// Iterate over any registered extra printers and call them to add further
2553	// information.
2554	if (!ExtraPrinters.empty()) {
2555	for (const auto &I : ExtraPrinters)
2556	I(outs());
2557	}
2558	}
2559	void operator=(bool OptionWasSpecified);
2560	};
2561
2562	struct CommandLineCommonOptions {
2563	// Declare the four HelpPrinter instances that are used to print out help, or
2564	// help-hidden as an uncategorized list or in categories.
2565	HelpPrinter UncategorizedNormalPrinter{false};
2566	HelpPrinter UncategorizedHiddenPrinter{true};
2567	CategorizedHelpPrinter CategorizedNormalPrinter{false};
2568	CategorizedHelpPrinter CategorizedHiddenPrinter{true};
2569	// Declare HelpPrinter wrappers that will decide whether or not to invoke
2570	// a categorizing help printer
2571	HelpPrinterWrapper WrappedNormalPrinter{UncategorizedNormalPrinter,
2572	CategorizedNormalPrinter};
2573	HelpPrinterWrapper WrappedHiddenPrinter{UncategorizedHiddenPrinter,
2574	CategorizedHiddenPrinter};
2575	// Define a category for generic options that all tools should have.
2576	cl::OptionCategory GenericCategory{"Generic Options"};
2577
2578	// Define uncategorized help printers.
2579	// --help-list is hidden by default because if Option categories are being
2580	// used then --help behaves the same as --help-list.
2581	cl::opt<HelpPrinter, true, parser<bool>> HLOp{
2582	"help-list",
2583	cl::desc(
2584	"Display list of available options (--help-list-hidden for more)"),
2585	cl::location(L&: UncategorizedNormalPrinter),
2586	cl::Hidden,
2587	cl::ValueDisallowed,
2588	cl::cat(GenericCategory),
2589	cl::sub(SubCommand::getAll())};
2590
2591	cl::opt<HelpPrinter, true, parser<bool>> HLHOp{
2592	"help-list-hidden",
2593	cl::desc("Display list of all available options"),
2594	cl::location(L&: UncategorizedHiddenPrinter),
2595	cl::Hidden,
2596	cl::ValueDisallowed,
2597	cl::cat(GenericCategory),
2598	cl::sub(SubCommand::getAll())};
2599
2600	// Define uncategorized/categorized help printers. These printers change their
2601	// behaviour at runtime depending on whether one or more Option categories
2602	// have been declared.
2603	cl::opt<HelpPrinterWrapper, true, parser<bool>> HOp{
2604	"help",
2605	cl::desc("Display available options (--help-hidden for more)"),
2606	cl::location(L&: WrappedNormalPrinter),
2607	cl::ValueDisallowed,
2608	cl::cat(GenericCategory),
2609	cl::sub(SubCommand::getAll())};
2610
2611	cl::alias HOpA{"h", cl::desc("Alias for --help"), cl::aliasopt(HOp),
2612	cl::DefaultOption};
2613
2614	cl::opt<HelpPrinterWrapper, true, parser<bool>> HHOp{
2615	"help-hidden",
2616	cl::desc("Display all available options"),
2617	cl::location(L&: WrappedHiddenPrinter),
2618	cl::Hidden,
2619	cl::ValueDisallowed,
2620	cl::cat(GenericCategory),
2621	cl::sub(SubCommand::getAll())};
2622
2623	cl::opt<bool> PrintOptions{
2624	"print-options",
2625	cl::desc("Print non-default options after command line parsing"),
2626	cl::Hidden,
2627	cl::init(Val: false),
2628	cl::cat(GenericCategory),
2629	cl::sub(SubCommand::getAll())};
2630
2631	cl::opt<bool> PrintAllOptions{
2632	"print-all-options",
2633	cl::desc("Print all option values after command line parsing"),
2634	cl::Hidden,
2635	cl::init(Val: false),
2636	cl::cat(GenericCategory),
2637	cl::sub(SubCommand::getAll())};
2638
2639	VersionPrinterTy OverrideVersionPrinter = nullptr;
2640
2641	std::vector<VersionPrinterTy> ExtraVersionPrinters;
2642
2643	// Define the --version option that prints out the LLVM version for the tool
2644	VersionPrinter VersionPrinterInstance;
2645
2646	cl::opt<VersionPrinter, true, parser<bool>> VersOp{
2647	"version", cl::desc("Display the version of this program"),
2648	cl::location(L&: VersionPrinterInstance), cl::ValueDisallowed,
2649	cl::cat(GenericCategory)};
2650	};
2651	} // End anonymous namespace
2652
2653	// Lazy-initialized global instance of options controlling the command-line
2654	// parser and general handling.
2655	static ManagedStatic<CommandLineCommonOptions> CommonOptions;
2656
2657	static void initCommonOptions() {
2658	*CommonOptions;
2659	initDebugCounterOptions();
2660	initGraphWriterOptions();
2661	initSignalsOptions();
2662	initStatisticOptions();
2663	initTimerOptions();
2664	initTypeSizeOptions();
2665	initWithColorOptions();
2666	initDebugOptions();
2667	initRandomSeedOptions();
2668	}
2669
2670	OptionCategory &cl::getGeneralCategory() {
2671	// Initialise the general option category.
2672	static OptionCategory GeneralCategory{"General options"};
2673	return GeneralCategory;
2674	}
2675
2676	void VersionPrinter::operator=(bool OptionWasSpecified) {
2677	if (!OptionWasSpecified)
2678	return;
2679
2680	if (CommonOptions->OverrideVersionPrinter != nullptr) {
2681	CommonOptions->OverrideVersionPrinter(outs());
2682	exit(status: 0);
2683	}
2684	print(ExtraPrinters: CommonOptions->ExtraVersionPrinters);
2685
2686	exit(status: 0);
2687	}
2688
2689	void HelpPrinterWrapper::operator=(bool Value) {
2690	if (!Value)
2691	return;
2692
2693	// Decide which printer to invoke. If more than one option category is
2694	// registered then it is useful to show the categorized help instead of
2695	// uncategorized help.
2696	if (GlobalParser->RegisteredOptionCategories.size() > 1) {
2697	// unhide --help-list option so user can have uncategorized output if they
2698	// want it.
2699	CommonOptions->HLOp.setHiddenFlag(NotHidden);
2700
2701	CategorizedPrinter = true; // Invoke categorized printer
2702	} else
2703	UncategorizedPrinter = true; // Invoke uncategorized printer
2704	}
2705
2706	// Print the value of each option.
2707	void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
2708
2709	void CommandLineParser::printOptionValues() {
2710	if (!CommonOptions->PrintOptions && !CommonOptions->PrintAllOptions)
2711	return;
2712
2713	SmallVector<std::pair<const char *, Option *>, 128> Opts;
2714	sortOpts(OptMap&: ActiveSubCommand->OptionsMap, Opts, /*ShowHidden*/ true);
2715
2716	// Compute the maximum argument length...
2717	size_t MaxArgLen = 0;
2718	for (size_t i = 0, e = Opts.size(); i != e; ++i)
2719	MaxArgLen = std::max(a: MaxArgLen, b: Opts[i].second->getOptionWidth());
2720
2721	for (size_t i = 0, e = Opts.size(); i != e; ++i)
2722	Opts[i].second->printOptionValue(GlobalWidth: MaxArgLen, Force: CommonOptions->PrintAllOptions);
2723	}
2724
2725	// Utility function for printing the help message.
2726	void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
2727	if (!Hidden && !Categorized)
2728	CommonOptions->UncategorizedNormalPrinter.printHelp();
2729	else if (!Hidden && Categorized)
2730	CommonOptions->CategorizedNormalPrinter.printHelp();
2731	else if (Hidden && !Categorized)
2732	CommonOptions->UncategorizedHiddenPrinter.printHelp();
2733	else
2734	CommonOptions->CategorizedHiddenPrinter.printHelp();
2735	}
2736
2737	/// Utility function for printing version number.
2738	void cl::PrintVersionMessage() {
2739	CommonOptions->VersionPrinterInstance.print(ExtraPrinters: CommonOptions->ExtraVersionPrinters);
2740	}
2741
2742	void cl::SetVersionPrinter(VersionPrinterTy func) {
2743	CommonOptions->OverrideVersionPrinter = func;
2744	}
2745
2746	void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
2747	CommonOptions->ExtraVersionPrinters.push_back(x: func);
2748	}
2749
2750	StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
2751	initCommonOptions();
2752	auto &Subs = GlobalParser->RegisteredSubCommands;
2753	(void)Subs;
2754	assert(Subs.contains(&Sub));
2755	return Sub.OptionsMap;
2756	}
2757
2758	iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
2759	cl::getRegisteredSubcommands() {
2760	return GlobalParser->getRegisteredSubcommands();
2761	}
2762
2763	void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
2764	initCommonOptions();
2765	for (auto &I : Sub.OptionsMap) {
2766	bool Unrelated = true;
2767	for (auto &Cat : I.second->Categories) {
2768	if (Cat == &Category || Cat == &CommonOptions->GenericCategory)
2769	Unrelated = false;
2770	}
2771	if (Unrelated)
2772	I.second->setHiddenFlag(cl::ReallyHidden);
2773	}
2774	}
2775
2776	void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
2777	SubCommand &Sub) {
2778	initCommonOptions();
2779	for (auto &I : Sub.OptionsMap) {
2780	bool Unrelated = true;
2781	for (auto &Cat : I.second->Categories) {
2782	if (is_contained(Range&: Categories, Element: Cat) ||
2783	Cat == &CommonOptions->GenericCategory)
2784	Unrelated = false;
2785	}
2786	if (Unrelated)
2787	I.second->setHiddenFlag(cl::ReallyHidden);
2788	}
2789	}
2790
2791	void cl::ResetCommandLineParser() { GlobalParser->reset(); }
2792	void cl::ResetAllOptionOccurrences() {
2793	GlobalParser->ResetAllOptionOccurrences();
2794	}
2795
2796	void LLVMParseCommandLineOptions(int argc, const char *const *argv,
2797	const char *Overview) {
2798	llvm::cl::ParseCommandLineOptions(argc, argv, Overview: StringRef(Overview),
2799	Errs: &llvm::nulls());
2800	}
2801