31#include "llvm/Config/config.h"
53#define DEBUG_TYPE "commandline"
74#if !(defined(LLVM_ENABLE_LLVM_EXPORT_ANNOTATIONS) && defined(_MSC_VER))
91void GenericOptionValue::anchor() {}
92void OptionValue<boolOrDefault>::anchor() {}
93void OptionValue<std::string>::anchor() {}
94void Option::anchor() {}
129 size_t Len = ArgName.
size();
137 for (
size_t I = 0;
I < Pad; ++
I) {
157 OS <<
argPrefix(Arg.ArgName, Arg.Pad) << Arg.ArgName;
161class CommandLineParser {
165 std::string ProgramName;
169 std::vector<StringRef> MoreHelp;
181 size_t NumIndexedLibraries = 0;
189 bool RecognizeLibraryOptions =
false;
202 if (Opt.
Subs.empty()) {
207 for (
auto *SC : RegisteredSubCommands)
212 for (
auto *SC : Opt.
Subs) {
214 "SubCommand::getAll() should not be used with other subcommands");
223 errs() << ProgramName <<
": CommandLine Error: Option '" << Name
224 <<
"' registered more than once!\n";
231 Opt, [&](
SubCommand &SC) { addLiteralOption(Opt, &SC, Name); });
235 bool HadErrors =
false;
236 if (O->hasArgStr()) {
241 (RegisteredSubCommands.
contains(SC) &&
242 (LibraryIndex.
contains(O->ArgStr) ||
244 errs() << ProgramName <<
": CommandLine Error: Option '" << O->ArgStr
245 <<
"' registered more than once!\n";
255 O->error(
"Cannot specify more than one option with cl::ConsumeAfter!");
269 void addOption(
Option *O) {
270 forEachSubCommand(*O, [&](
SubCommand &SC) { addOption(O, &SC); });
275 O->getExtraOptionNames(OptionNames);
280 for (
auto Name : OptionNames) {
281 auto I =
Sub.OptionsMap.find(Name);
284 if (
I !=
Sub.OptionsMap.end() &&
I->second == O)
285 Sub.OptionsMap.erase(
I);
289 for (
auto *Opt =
Sub.PositionalOpts.begin();
290 Opt !=
Sub.PositionalOpts.end(); ++Opt) {
292 Sub.PositionalOpts.erase(Opt);
296 else if (O ==
Sub.ConsumeAfterOpt)
297 Sub.ConsumeAfterOpt =
nullptr;
300 void removeOption(
Option *O) {
301 forEachSubCommand(*O, [&](
SubCommand &SC) { removeOption(O, &SC); });
305 return (!
Sub.OptionsMap.empty() || !
Sub.PositionalOpts.empty() ||
306 nullptr !=
Sub.ConsumeAfterOpt);
309 bool hasOptions()
const {
310 for (
const auto *S : RegisteredSubCommands) {
314 return !Libraries.
empty();
317 bool hasNamedSubCommands()
const {
318 for (
const auto *S : RegisteredSubCommands)
319 if (!S->getName().empty())
324 SubCommand *getActiveSubCommand() {
return ActiveSubCommand; }
328 if (!
Sub.OptionsMap.insert(std::make_pair(NewName, O)).second) {
329 errs() << ProgramName <<
": CommandLine Error: Option '" << O->ArgStr
330 <<
"' registered more than once!\n";
333 Sub.OptionsMap.erase(O->ArgStr);
337 forEachSubCommand(*O,
338 [&](
SubCommand &SC) { updateArgStr(O, NewName, &SC); });
341 void printOptionValues();
347 bool HadErrors =
false;
351 auto [It, Inserted] = Index.try_emplace(Name, L);
352 if (Inserted ? !
Other.contains(Name) &&
359 errs() << ProgramName <<
": CommandLine Error: Option '" << Name
360 <<
"' registered more than once!\n";
368 void indexLibraryOptions() {
369 indexLibraries(
ArrayRef(Libraries).drop_front(NumIndexedLibraries),
370 LibraryIndex, ToolIndex);
371 NumIndexedLibraries = Libraries.
size();
379 indexLibraries(ToolOptions, ToolIndex, LibraryIndex);
384 indexLibraryOptions();
387 return ToolIndex.
lookup(Name);
393 return cat->getName() == Category->getName();
395 "Duplicate option categories");
403 return (!
sub->getName().empty()) &&
404 (
Sub->getName() ==
sub->getName());
406 "Duplicate subcommands");
412 "SubCommand::getAll() should not be registered");
415 if (O->isPositional() || O->isConsumeAfter() || O->hasArgStr())
418 addLiteralOption(*O,
sub,
E.first);
429 RegisteredSubCommands.
end());
433 ActiveSubCommand =
nullptr;
438 RegisteredOptionCategories.
clear();
441 RegisteredSubCommands.
clear();
443 LibraryIndex.
clear();
444 NumIndexedLibraries = 0;
469 return *GlobalParser;
472template <
typename T, T TrueVal, T FalseVal>
476 if (!Arg.
data() || Arg ==
"true" || Arg ==
"1") {
481 if (Arg ==
"false" || Arg ==
"0") {
485 return O.error(
"'" + Arg +
486 "' is invalid value for boolean argument! Try 0 or 1");
498 : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
500 FullyInitialized(
false), Position(0) {
506 FullyInitialized =
true;
512 if (FullyInitialized)
534void OptionCategory::registerCategory() {
545 return *TopLevelSubCommand;
551 return *AllSubCommands;
569SubCommand::operator
bool()
const {
587 size_t EqualPos = Arg.
find(
'=');
592 return Sub.OptionsMap.lookup(Arg);
598 auto I =
Sub.OptionsMap.find(Arg.
substr(0, EqualPos));
599 if (
I ==
Sub.OptionsMap.end())
607 Arg = Arg.
substr(0, EqualPos);
612 std::string &NearestString) {
617 for (
auto *S : RegisteredSubCommands) {
619 "SubCommand::getAll() is not expected in RegisteredSubCommands");
620 if (S->getName().empty())
623 if (S->getName() == Name)
626 if (!NearestMatch && S->getName().edit_distance(Name) < 2)
631 NearestString = NearestMatch->
getName();
642 std::string &NearestString) {
648 std::pair<StringRef, StringRef> SplitArg = Arg.
split(
'=');
654 unsigned BestDistance = 0;
655 for (
const auto &[
_, O] : OptionsMap) {
661 O->getExtraOptionNames(OptionNames);
667 for (
const auto &Name : OptionNames) {
669 Flag,
true, BestDistance);
670 if (!Best || Distance < BestDistance) {
672 BestDistance = Distance;
673 if (
RHS.empty() || !PermitValue)
674 NearestString = std::string(Name);
676 NearestString = (
Twine(Name) +
"=" +
RHS).str();
699 Val = Val.
substr(Pos + 1);
715 const char *
const *argv,
int &i) {
723 return Handler->
error(
"requires a value!");
725 assert(argv &&
"null check");
750 for (; !Name.empty(); Name = Name.drop_back()) {
752 if (O && (O->getFormattingFlag() ==
cl::Prefix ||
797 return C ==
' ' ||
C ==
'\t' ||
C ==
'\r' ||
C ==
'\n';
804static bool isQuote(
char C) {
return C ==
'\"' ||
C ==
'\''; }
810 bool InToken =
false;
811 for (
size_t I = 0, E = Src.size();
I != E; ++
I) {
816 if (MarkEOLs && Src[
I] ==
'\n')
828 if (
I + 1 < E &&
C ==
'\\') {
837 while (
I != E && Src[
I] !=
C) {
839 if (Src[
I] ==
'\\' &&
I + 1 != E)
853 if (MarkEOLs &&
C ==
'\n')
887 size_t E = Src.size();
888 int BackslashCount = 0;
893 }
while (
I !=
E && Src[
I] ==
'\\');
895 bool FollowedByDoubleQuote = (
I !=
E && Src[
I] ==
'"');
896 if (FollowedByDoubleQuote) {
897 Token.
append(BackslashCount / 2,
'\\');
898 if (BackslashCount % 2 == 0)
903 Token.
append(BackslashCount,
'\\');
921 bool AlwaysCopy,
function_ref<
void()> MarkEOL,
bool InitialCommandName) {
930 bool CommandName = InitialCommandName;
933 enum {
INIT, UNQUOTED, QUOTED } State =
INIT;
935 for (
size_t I = 0,
E = Src.size();
I <
E; ++
I) {
938 assert(Token.
empty() &&
"token should be empty in initial state");
960 AddToken(AlwaysCopy ? Saver.
save(NormalChars) : NormalChars);
961 if (
I <
E && Src[
I] ==
'\n') {
963 CommandName = InitialCommandName;
967 }
else if (Src[
I] ==
'\"') {
968 Token += NormalChars;
970 }
else if (Src[
I] ==
'\\') {
971 assert(!CommandName &&
"or else we'd have treated it as a normal char");
972 Token += NormalChars;
986 AddToken(Saver.
save(Token.
str()));
988 if (Src[
I] ==
'\n') {
989 CommandName = InitialCommandName;
995 }
else if (Src[
I] ==
'\"') {
997 }
else if (Src[
I] ==
'\\' && !CommandName) {
1005 if (Src[
I] ==
'\"') {
1006 if (
I < (
E - 1) && Src[
I + 1] ==
'"') {
1015 }
else if (Src[
I] ==
'\\' && !CommandName) {
1025 AddToken(Saver.
save(Token.
str()));
1032 auto OnEOL = [&]() {
1037 true, OnEOL,
false);
1043 auto OnEOL = []() {};
1052 auto OnEOL = [&]() {
1063 for (
const char *Cur = Source.begin(); Cur != Source.end();) {
1072 while (Cur != Source.end() && *Cur !=
'\n')
1080 const char *Start = Cur;
1081 const char *LineEnd =
nullptr;
1083 bool AtTokenStart =
true;
1084 for (
const char *
End = Source.end(); Cur !=
End; ++Cur) {
1087 if (Cur + 1 !=
End) {
1090 (*Cur ==
'\r' && (Cur + 1 !=
End) && Cur[1] ==
'\n')) {
1091 Line.append(Start, Cur - 1);
1099 AtTokenStart =
false;
1109 }
else if (
C ==
'#' && AtTokenStart) {
1111 while (Cur !=
End && *Cur !=
'\n')
1118 Line.append(Start, LineEnd ? LineEnd : Cur);
1126 return (S.
size() >= 3 && S[0] ==
'\xef' && S[1] ==
'\xbb' && S[2] ==
'\xbf');
1140 TokenPos = ArgString.
find(Token, StartPos)) {
1144 if (ResponseFile.
empty())
1148 ResponseFile.
append(BasePath);
1149 StartPos = TokenPos + Token.
size();
1152 if (!ResponseFile.
empty()) {
1155 if (!Remaining.
empty())
1162Error ExpansionContext::expandResponseFile(
1163 StringRef FName, SmallVectorImpl<const char *> &NewArgv) {
1165 llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
1166 FS->getBufferForFile(FName);
1170 "': " +
EC.message());
1172 MemoryBuffer &MemBuf = *MemBufOrErr.
get();
1177 std::string UTF8Buf;
1181 "Could not convert UTF16 to UTF8");
1182 Str = StringRef(UTF8Buf);
1188 Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);
1191 Tokenizer(Str, Saver, NewArgv, MarkEOLs);
1196 if (!RelativeNames && !InConfigFile)
1200 for (
const char *&Arg : NewArgv) {
1210 StringRef ArgStr(Arg);
1212 bool ConfigInclusion =
false;
1213 if (ArgStr.consume_front(
"@")) {
1217 }
else if (ArgStr.consume_front(
"--config=")) {
1219 ConfigInclusion =
true;
1225 SmallString<128> ResponseFile;
1228 SmallString<128> FilePath;
1231 std::make_error_code(std::errc::no_such_file_or_directory),
1232 "cannot not find configuration file: " + FileName);
1233 ResponseFile.
append(FilePath);
1235 ResponseFile.
append(BasePath);
1238 Arg = Saver.save(ResponseFile.
str()).
data();
1247 struct ResponseFileRecord {
1262 for (
unsigned I = 0;
I != Argv.
size();) {
1263 while (
I == FileStack.
back().End) {
1269 const char *Arg = Argv[
I];
1271 if (Arg ==
nullptr) {
1276 if (Arg[0] !=
'@') {
1281 const char *FName = Arg + 1;
1286 if (CurrentDir.empty()) {
1287 if (
auto CWD = FS->getCurrentWorkingDirectory()) {
1291 CWD.getError(),
Twine(
"cannot get absolute path for: ") + FName);
1294 CurrDir = CurrentDir;
1297 FName = CurrDir.
c_str();
1301 if (!Res || !Res->exists()) {
1302 std::error_code EC = Res.
getError();
1303 if (!InConfigFile) {
1314 "': " + EC.message());
1319 [FileStatus,
this](
const ResponseFileRecord &RFile) ->
ErrorOr<bool> {
1331 R.getError(),
Twine(
"recursive expansion of: '") +
F.File +
"'");
1334 Twine(
"cannot open file: ") +
F.File);
1341 if (
Error Err = expandResponseFile(FName, ExpandedArgv))
1344 for (ResponseFileRecord &
Record : FileStack) {
1375 Tokenize(*EnvValue, Saver, NewArgv,
false);
1378 NewArgv.
append(Argv + 1, Argv + Argc);
1399 : Saver(
A), Tokenizer(
T), FS(FS ? FS :
vfs::getRealFileSystem().
get()) {}
1405 auto Status = FS->status(Path);
1413 CfgFilePath = FileName;
1416 if (!FileExists(CfgFilePath))
1423 for (
const StringRef &Dir : SearchDirs) {
1429 if (FileExists(CfgFilePath)) {
1443 if (std::error_code EC = FS->makeAbsolute(AbsPath))
1445 EC,
Twine(
"cannot get absolute path for " + CfgFile));
1446 CfgFile = AbsPath.
str();
1448 InConfigFile =
true;
1449 RelativeNames =
true;
1450 if (
Error Err = expandResponseFile(CfgFile, Argv))
1463 StringSaver Saver(
A);
1468 if (std::optional<std::string> EnvValue =
1475 int NewArgc =
static_cast<int>(NewArgv.
size());
1479 NewArgc, &NewArgv[0], Overview, Errs, VFS,
Context, ToolOptions);
1503 EnvVar, ToolOptions);
1507void CommandLineParser::ResetAllOptionOccurrences() {
1511 for (
auto *SC : RegisteredSubCommands) {
1515 Opts.
reserve(SC->OptionsMap.size());
1516 for (
auto &O : SC->OptionsMap)
1520 for (
Option *O : SC->PositionalOpts)
1522 if (SC->ConsumeAfterOpt)
1523 SC->ConsumeAfterOpt->reset();
1527bool CommandLineParser::ParseCommandLineOptions(
1531 assert((hasOptions() || !Tools.
empty()) &&
"No options specified!");
1533 ProgramOverview = Overview;
1534 RecognizeLibraryOptions = Context;
1535 bool IgnoreErrors = Errs;
1540 bool ErrorParsing =
false;
1551 if (
Error Err = ECtx.expandResponseFiles(newArgv)) {
1552 *Errs <<
toString(std::move(Err)) <<
'\n';
1556 argc =
static_cast<int>(newArgv.size());
1560 setToolOptions(Tools);
1561 indexLibraryOptions();
1564 unsigned NumPositionalRequired = 0;
1567 bool HasUnlimitedPositionals =
false;
1571 std::string NearestSubCommandString;
1572 bool MaybeNamedSubCommand =
1573 argc >= 2 && argv[FirstArg][0] !=
'-' && hasNamedSubCommands();
1574 if (MaybeNamedSubCommand) {
1578 LookupSubCommand(
StringRef(argv[FirstArg]), NearestSubCommandString);
1584 assert(ChosenSubCommand);
1587 auto &OptionsMap = ChosenSubCommand->
OptionsMap;
1589 if (ConsumeAfterOpt) {
1590 assert(PositionalOpts.size() > 0 &&
1591 "Cannot specify cl::ConsumeAfter without a positional argument!");
1593 if (!PositionalOpts.empty()) {
1596 bool UnboundedFound =
false;
1597 for (
size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
1598 Option *Opt = PositionalOpts[i];
1600 ++NumPositionalRequired;
1601 else if (ConsumeAfterOpt) {
1604 if (PositionalOpts.size() > 1) {
1606 Opt->
error(
"error - this positional option will never be matched, "
1607 "because it does not Require a value, and a "
1608 "cl::ConsumeAfter option is active!");
1609 ErrorParsing =
true;
1611 }
else if (UnboundedFound && !Opt->
hasArgStr()) {
1617 Opt->
error(
"error - option can never match, because "
1618 "another positional argument will match an "
1619 "unbounded number of values, and this option"
1620 " does not require a value!");
1621 *Errs << ProgramName <<
": CommandLine Error: Option '" << Opt->
ArgStr
1622 <<
"' is all messed up!\n";
1623 *Errs << PositionalOpts.size();
1624 ErrorParsing =
true;
1628 HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;
1639 Option *ActivePositionalArg =
nullptr;
1642 bool DashDashFound =
false;
1643 for (
int i = FirstArg; i < argc; ++i) {
1644 Option *Handler =
nullptr;
1645 std::string NearestHandlerString;
1647 StringRef ArgName =
"";
1653 if (argv[i][0] !=
'-' || argv[i][1] == 0 || DashDashFound) {
1655 if (ActivePositionalArg) {
1660 if (!PositionalOpts.empty()) {
1661 PositionalVals.
push_back(std::make_pair(StringRef(argv[i]), i));
1666 if (PositionalVals.
size() >= NumPositionalRequired && ConsumeAfterOpt) {
1667 for (++i; i < argc; ++i)
1668 PositionalVals.
push_back(std::make_pair(StringRef(argv[i]), i));
1675 }
else if (argv[i][0] ==
'-' && argv[i][1] ==
'-' && argv[i][2] == 0 &&
1677 DashDashFound =
true;
1679 }
else if (ActivePositionalArg &&
1684 ArgName = StringRef(argv[i] + 1);
1688 Handler = LookupOption(*ChosenSubCommand, ArgName,
Value);
1694 ArgName = StringRef(argv[i] + 1);
1698 Handler = LookupOption(*ChosenSubCommand, ArgName,
Value);
1708 lookupLibraryOption(ArgName.
split(
'=').first)) {
1709 ArrayRef<const char *> Rest(argv + i, argc - i);
1712 *Errs << ProgramName <<
": " <<
toString(std::move(
E)) <<
'\n';
1713 ErrorParsing =
true;
1731 auto ReportUnknownArgument = [&](
bool IsArg,
1732 StringRef NearestArgumentName) {
1733 *Errs << ProgramName <<
": Unknown "
1734 << (IsArg ?
"command line argument" :
"subcommand") <<
" '"
1735 << argv[i] <<
"'. Try: '" << argv[0] <<
" --help'\n";
1737 if (NearestArgumentName.empty())
1740 *Errs << ProgramName <<
": Did you mean '";
1742 *Errs << PrintArg(NearestArgumentName, 0);
1744 *Errs << NearestArgumentName;
1748 if (i > 1 || !MaybeNamedSubCommand)
1749 ReportUnknownArgument(
true, NearestHandlerString);
1751 ReportUnknownArgument(
false, NearestSubCommandString);
1753 ErrorParsing =
true;
1761 Handler->
error(
"This argument does not take a value.\n"
1762 "\tInstead, it consumes any positional arguments until "
1763 "the next recognized option.", *Errs);
1764 ErrorParsing =
true;
1766 ActivePositionalArg = Handler;
1773 if (NumPositionalRequired > PositionalVals.
size()) {
1774 *Errs << ProgramName
1775 <<
": Not enough positional command line arguments specified!\n"
1776 <<
"Must specify at least " << NumPositionalRequired
1777 <<
" positional argument" << (NumPositionalRequired > 1 ?
"s" :
"")
1778 <<
": See: " << argv[0] <<
" --help\n";
1780 ErrorParsing =
true;
1781 }
else if (!HasUnlimitedPositionals &&
1782 PositionalVals.
size() > PositionalOpts.size()) {
1783 *Errs << ProgramName <<
": Too many positional arguments specified!\n"
1784 <<
"Can specify at most " << PositionalOpts.size()
1785 <<
" positional arguments: See: " << argv[0] <<
" --help\n";
1786 ErrorParsing =
true;
1788 }
else if (!ConsumeAfterOpt) {
1790 unsigned ValNo = 0, NumVals =
static_cast<unsigned>(PositionalVals.
size());
1791 for (
Option *Opt : PositionalOpts) {
1794 PositionalVals[ValNo].second);
1796 --NumPositionalRequired;
1804 while (NumVals - ValNo > NumPositionalRequired && !
Done) {
1812 PositionalVals[ValNo].second);
1817 "positional argument processing!");
1822 assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.
size());
1824 for (
Option *Opt : PositionalOpts)
1827 Opt, PositionalVals[ValNo].first, PositionalVals[ValNo].second);
1836 if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.
empty()) {
1838 PositionalVals[ValNo].first,
1839 PositionalVals[ValNo].second);
1845 for (; ValNo != PositionalVals.
size(); ++ValNo)
1848 PositionalVals[ValNo].second);
1852 for (
const auto &Opt : OptionsMap) {
1857 Opt.second->
error(
"must be specified at least once!");
1858 ErrorParsing =
true;
1870 for (
int i = 0; i < argc; ++i)
dbgs() << argv[i] <<
' ';
1891 if (!ArgName.
data())
1893 if (ArgName.
empty())
1896 Errs <<
globalParser().ProgramName <<
": for the " << PrintArg(ArgName, 0);
1898 Errs <<
" option: " << Message <<
"\n";
1904 return handleOccurrence(pos, ArgName, Value);
1911 if (O.ValueStr.empty())
1926 size_t FirstLineIndentedBy) {
1927 assert(Indent >= FirstLineIndentedBy);
1928 std::pair<StringRef, StringRef> Split =
HelpStr.split(
'\n');
1931 while (!Split.second.empty()) {
1932 Split = Split.second.split(
'\n');
1933 outs().
indent(Indent) << Split.first <<
"\n";
1938 size_t FirstLineIndentedBy) {
1940 assert(BaseIndent >= FirstLineIndentedBy);
1941 std::pair<StringRef, StringRef> Split =
HelpStr.split(
'\n');
1942 outs().
indent(BaseIndent - FirstLineIndentedBy)
1944 while (!Split.second.empty()) {
1945 Split = Split.second.split(
'\n');
1946 outs().
indent(BaseIndent + ValHelpPrefix.
size()) << Split.first <<
"\n";
1951void alias::printOptionInfo(
size_t GlobalWidth)
const {
1967 if (!ValName.empty()) {
1968 size_t FormattingLen = 3;
1981 size_t GlobalWidth)
const {
1982 outs() << PrintArg(O.ArgStr);
1985 if (!ValName.empty()) {
1991 outs() << (O.ArgStr.size() == 1 ?
" <" :
"=<") <<
getValueStr(O, ValName)
2000 size_t GlobalWidth)
const {
2001 outs() << PrintArg(O.ArgStr);
2002 outs().
indent(GlobalWidth - O.ArgStr.size());
2022template <
typename FixedOrScalableQuantityT>
2025 FixedOrScalableQuantityT &
Value) {
2026 using ScalarTy =
typename FixedOrScalableQuantityT::ScalarTy;
2032 Value = FixedOrScalableQuantityT::getFixed(MinValue);
2038 return O.error(
"'" + Arg +
"' value invalid for " + ValueKind +
2041 Remainder = Remainder.
ltrim();
2043 return O.error(
"'" + Arg +
"' value invalid for " + ValueKind +
2046 Remainder = Remainder.
ltrim();
2048 return O.error(
"'" + Arg +
"' value invalid for " + ValueKind +
2051 Value = FixedOrScalableQuantityT::getScalable(MinValue);
2060 return O.error(
"'" + Arg +
"' value invalid for integer argument!");
2069 return O.error(
"'" + Arg +
"' value invalid for long argument!");
2078 return O.error(
"'" + Arg +
"' value invalid for llong argument!");
2088 return O.error(
"'" + Arg +
"' value invalid for uint argument!");
2095 unsigned long &
Value) {
2098 return O.error(
"'" + Arg +
"' value invalid for ulong argument!");
2106 unsigned long long &
Value) {
2109 return O.error(
"'" + Arg +
"' value invalid for ullong argument!");
2116 ElementCount &
Value) {
2125 return O.error(
"'" + Arg +
"' value invalid for floating point argument!");
2151 for (
unsigned i = 0; i != e; ++i) {
2167 return O.getValueExpectedFlag() !=
ValueOptional || !Name.empty() ||
2168 !Description.
empty();
2173 if (O.hasArgStr()) {
2185 size_t BaseSize = 0;
2196 size_t GlobalWidth)
const {
2197 if (O.hasArgStr()) {
2203 outs() << PrintArg(O.ArgStr);
2222 if (OptionName.
empty()) {
2227 if (!Description.
empty())
2233 if (!O.HelpStr.empty())
2234 outs() <<
" " << O.HelpStr <<
'\n';
2251 outs() <<
" " << PrintArg(O.ArgStr);
2252 outs().
indent(GlobalWidth - O.ArgStr.size());
2255 for (
unsigned i = 0; i != NumOpts; ++i) {
2263 for (
unsigned j = 0; j != NumOpts; ++j) {
2272 outs() <<
"= *unknown option value*\n";
2280 return OS << static_cast<int>(V);
2285#define PRINT_OPT_DIFF(T) \
2286 void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \
2287 size_t GlobalWidth) const { \
2288 printOptionName(O, GlobalWidth); \
2291 raw_string_ostream SS(Str); \
2294 outs() << "= " << Str; \
2295 size_t NumSpaces = \
2296 MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \
2297 outs().indent(NumSpaces) << " (default: "; \
2299 outs() << D.getValue(); \
2301 outs() << "*no default*"; \
2320 size_t GlobalWidth)
const {
2321 printOptionName(O, GlobalWidth);
2322 outs() <<
"= " <<
V;
2326 outs() <<
D.getValue();
2328 outs() <<
"*no default*";
2333 const Option &O, std::optional<StringRef>
V,
2334 const OptionValue<std::optional<std::string>> &
D,
2335 size_t GlobalWidth)
const {
2336 printOptionName(O, GlobalWidth);
2337 outs() <<
"= " <<
V;
2338 size_t VSize =
V.has_value() ?
V.value().size() : 0;
2341 if (
D.hasValue() &&
D.getValue().has_value())
2342 outs() <<
D.getValue();
2344 outs() <<
"*no value*";
2350 size_t GlobalWidth)
const {
2352 outs() <<
"= *cannot print option value*\n";
2360 const std::pair<const char *, Option *> *
RHS) {
2361 return strcmp(
LHS->first,
RHS->first);
2365 const std::pair<const char *, SubCommand *> *
RHS) {
2366 return strcmp(
LHS->first,
RHS->first);
2375 for (
auto I = OptMap.
begin(),
E = OptMap.
end();
I !=
E; ++
I) {
2381 if (
I->second->getOptionHiddenFlag() ==
Hidden && !ShowHidden)
2385 if (!OptionSet.
insert(
I->second).second)
2389 std::pair<const char *, Option *>(
I->first.data(),
I->second));
2399 for (
auto *S : SubMap) {
2400 if (S->getName().empty())
2402 Subs.push_back(std::make_pair(S->getName().data(), S));
2411 const bool ShowHidden;
2412 using StrOptionPairVector =
2414 using StrSubCommandPairVector =
2417 virtual void printOptions(StrOptionPairVector &Opts,
size_t MaxArgLen) {
2418 for (
const auto &Opt : Opts)
2422 void printSubCommands(StrSubCommandPairVector &Subs,
size_t MaxSubLen) {
2423 for (
const auto &S : Subs) {
2424 outs() <<
" " << S.first;
2425 if (!S.second->getDescription().empty()) {
2427 outs() <<
" - " << S.second->getDescription();
2434 explicit HelpPrinter(
bool showHidden) : ShowHidden(showHidden) {}
2435 virtual ~HelpPrinter() =
default;
2438 void operator=(
bool Value) {
2449 auto &OptionsMap =
Sub->OptionsMap;
2450 auto &PositionalOpts =
Sub->PositionalOpts;
2451 auto &ConsumeAfterOpt =
Sub->ConsumeAfterOpt;
2453 StrOptionPairVector Opts;
2454 sortOpts(OptionsMap, Opts, ShowHidden);
2456 StrSubCommandPairVector Subs;
2465 outs() <<
" [subcommand]";
2466 outs() <<
" [options]";
2468 if (!
Sub->getDescription().empty()) {
2469 outs() <<
"SUBCOMMAND '" <<
Sub->getName()
2470 <<
"': " <<
Sub->getDescription() <<
"\n\n";
2476 for (
auto *Opt : PositionalOpts) {
2483 if (ConsumeAfterOpt)
2484 outs() <<
" " << ConsumeAfterOpt->HelpStr;
2488 size_t MaxSubLen = 0;
2489 for (
const auto &
Sub : Subs)
2490 MaxSubLen = std::max(MaxSubLen, strlen(
Sub.first));
2493 outs() <<
"SUBCOMMANDS:\n\n";
2494 printSubCommands(Subs, MaxSubLen);
2497 <<
" <subcommand> --help\" to get more help on a specific "
2504 size_t MaxArgLen = 0;
2505 for (
const auto &Opt : Opts)
2509 if (ShowHidden &&
globalParser().RecognizeLibraryOptions)
2513 [&](StringRef Spelling, StringRef MetaVar, StringRef
Help) {
2518 for (
const auto &[Name,
Help] : LibraryOpts)
2521 outs() <<
"OPTIONS:\n";
2522 printOptions(Opts, MaxArgLen);
2524 if (!LibraryOpts.empty())
2525 outs() <<
"\nLibrary options:\n\n";
2526 for (
const auto &[Name,
Help] : LibraryOpts) {
2527 outs() << PrintArg(Name);
2538class CategorizedHelpPrinter :
public HelpPrinter {
2540 explicit CategorizedHelpPrinter(
bool showHidden) : HelpPrinter(showHidden) {}
2546 static int OptionCategoryCompare(OptionCategory *
const *
A,
2547 OptionCategory *
const *
B) {
2548 return (*A)->getName().compare((*B)->getName());
2552 using HelpPrinter::operator=;
2555 void printOptions(StrOptionPairVector &Opts,
size_t MaxArgLen)
override {
2556 std::vector<OptionCategory *> SortedCategories;
2557 DenseMap<OptionCategory *, std::vector<Option *>> CategorizedOptions;
2565 assert(SortedCategories.size() > 0 &&
"No option categories registered!");
2567 OptionCategoryCompare);
2572 for (
const auto &
I : Opts) {
2573 Option *Opt =
I.second;
2574 for (OptionCategory *Cat : Opt->
Categories) {
2576 "Option has an unregistered category");
2577 CategorizedOptions[Cat].push_back(Opt);
2582 for (OptionCategory *Category : SortedCategories) {
2584 const auto &CategoryOptions = CategorizedOptions[Category];
2585 if (CategoryOptions.empty())
2590 outs() << Category->getName() <<
":\n";
2593 if (!Category->getDescription().empty())
2594 outs() << Category->getDescription() <<
"\n\n";
2599 for (
const Option *Opt : CategoryOptions)
2607class HelpPrinterWrapper {
2609 HelpPrinter &UncategorizedPrinter;
2610 CategorizedHelpPrinter &CategorizedPrinter;
2613 explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,
2614 CategorizedHelpPrinter &CategorizedPrinter)
2615 : UncategorizedPrinter(UncategorizedPrinter),
2616 CategorizedPrinter(CategorizedPrinter) {}
2619 void operator=(
bool Value);
2624#if defined(__GNUC__)
2627# if defined(__OPTIMIZE__)
2628# define LLVM_IS_DEBUG_BUILD 0
2630# define LLVM_IS_DEBUG_BUILD 1
2632#elif defined(_MSC_VER)
2637# define LLVM_IS_DEBUG_BUILD 1
2639# define LLVM_IS_DEBUG_BUILD 0
2643# define LLVM_IS_DEBUG_BUILD 0
2647class VersionPrinter {
2649 void print(
const std::vector<VersionPrinterTy> &ExtraPrinters) {
2651#ifdef PACKAGE_VENDOR
2652 OS << PACKAGE_VENDOR <<
" ";
2654 OS <<
"LLVM (http://llvm.org/):\n ";
2656 OS << PACKAGE_NAME <<
" version " << PACKAGE_VERSION <<
"\n ";
2657#if LLVM_IS_DEBUG_BUILD
2658 OS <<
"DEBUG build";
2660 OS <<
"Optimized build";
2663 OS <<
" with assertions";
2669 if (!ExtraPrinters.empty()) {
2670 for (
const auto &
I : ExtraPrinters)
2674 void operator=(
bool OptionWasSpecified);
2677struct CommandLineCommonOptions {
2680 HelpPrinter UncategorizedNormalPrinter{
false};
2681 HelpPrinter UncategorizedHiddenPrinter{
true};
2682 CategorizedHelpPrinter CategorizedNormalPrinter{
false};
2683 CategorizedHelpPrinter CategorizedHiddenPrinter{
true};
2686 HelpPrinterWrapper WrappedNormalPrinter{UncategorizedNormalPrinter,
2687 CategorizedNormalPrinter};
2688 HelpPrinterWrapper WrappedHiddenPrinter{UncategorizedHiddenPrinter,
2689 CategorizedHiddenPrinter};
2699 "Display list of available options (--help-list-hidden for more)"),
2708 cl::desc(
"Display list of all available options"),
2720 cl::desc(
"Display available options (--help-hidden for more)"),
2730 cl::desc(
"Display all available options"),
2739 cl::desc(
"Print non-default options after command line parsing"),
2746 "print-all-options",
2747 cl::desc(
"Print all option values after command line parsing"),
2755 std::vector<VersionPrinterTy> ExtraVersionPrinters;
2758 VersionPrinter VersionPrinterInstance;
2761 "version",
cl::desc(
"Display the version of this program"),
2786 return GeneralCategory;
2789void VersionPrinter::operator=(
bool OptionWasSpecified) {
2790 if (!OptionWasSpecified)
2802void HelpPrinterWrapper::operator=(
bool Value) {
2809 if (
globalParser().RegisteredOptionCategories.size() > 1) {
2814 CategorizedPrinter =
true;
2816 UncategorizedPrinter =
true;
2823void CommandLineParser::printOptionValues() {
2828 sortOpts(ActiveSubCommand->OptionsMap, Opts,
true);
2831 size_t MaxArgLen = 0;
2832 for (
const auto &Opt : Opts)
2835 for (
const auto &Opt : Opts)
2841 if (!
Hidden && !Categorized)
2843 else if (!
Hidden && Categorized)
2845 else if (
Hidden && !Categorized)
2857#if LLVM_IS_DEBUG_BUILD
2863#ifdef EXPENSIVE_CHECKS
2864 "+expensive-checks",
2866#if __has_feature(address_sanitizer)
2869#if __has_feature(dataflow_sanitizer)
2872#if __has_feature(hwaddress_sanitizer)
2875#if __has_feature(memory_sanitizer)
2878#if __has_feature(thread_sanitizer)
2881#if __has_feature(undefined_behavior_sanitizer)
2884#ifdef LLVM_INTEGRATED_CRT_ALLOC
2885 "+alloc:" LLVM_INTEGRATED_CRT_ALLOC,
2893#if LLVM_VERSION_PRINTER_SHOW_BUILD_CONFIG
2894 OS <<
"Build config: ";
2918 return Sub.OptionsMap;
2928 for (
auto &
I :
Sub.OptionsMap) {
2929 bool Unrelated =
true;
2930 for (
auto &Cat :
I.second->Categories) {
2931 if (Cat == &Category || Cat == &
CommonOptions->GenericCategory)
2942 for (
auto &
I :
Sub.OptionsMap) {
2943 bool Unrelated =
true;
2944 for (
auto &Cat :
I.second->Categories) {
2964 SavedLibraries.clear();
2967 for (
size_t I = 0, E = Args.size();
I != E;) {
2976 unsigned &Consumed) {
2977 auto [It, Inserted] = Values.try_emplace(L.getDefault());
2979 It->second = L.copyDefault(Alloc);
2983 const char *
Saved[2];
2984 unsigned NumArgs = std::min<size_t>(Args.size(), 2);
2985 for (
unsigned J = 0; J != NumArgs; ++J)
2991 SavedLibraries.resize(SavedArgs.size(), &L);
3005 const char *Overview) {
3007 Overview, &
nulls());
3011 const char *Overview,
3012 char **ErrorMessage) {
3013 *ErrorMessage =
nullptr;
3017 Overview, &Stream)) {
3018 *ErrorMessage = strdup(Err.c_str());
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the StringMap class.
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static StringRef OptionPrefix
static bool RequiresValue(const Option *O)
static int SubNameCompare(const std::pair< const char *, SubCommand * > *LHS, const std::pair< const char *, SubCommand * > *RHS)
static size_t argPlusPrefixesSize(StringRef ArgName, size_t Pad=DefaultPad)
static bool shouldPrintOption(StringRef Name, StringRef Description, const Option &O)
static bool parseDouble(Option &O, StringRef Arg, double &Value)
static CommandLineParser & globalParser()
static bool parseBool(Option &O, StringRef ArgName, StringRef Arg, T &Value)
static const size_t DefaultPad
static StringRef EmptyOption
static bool parseCommandLineOptionsImpl(LibraryOptionsContext *Context, ArrayRef< const char * > Args, StringRef Overview, raw_ostream *Errs, vfs::FileSystem *VFS, const char *EnvVar, ArrayRef< const LibraryOptions * > ToolOptions={})
static bool hasUTF8ByteOrderMark(ArrayRef< char > S)
static void ExpandBasePaths(StringRef BasePath, StringSaver &Saver, const char *&Arg)
static SmallString< 8 > argPrefix(StringRef ArgName, size_t Pad=DefaultPad)
static StringRef ArgHelpPrefix
void opt_unsigned_anchor()
static bool isWindowsSpecialCharInCommandName(char C)
static StringRef getValueStr(const Option &O, StringRef DefaultMsg)
static Option * HandlePrefixedOption(StringRef &Arg, StringRef &Value, const OptionsMapTy &OptionsMap)
The specified argument string (which started with at least one '-') does not fully match an available...
static size_t getOptionPrefixesSize()
static bool ProvideOption(Option *Handler, StringRef ArgName, StringRef Value, int argc, const char *const *argv, int &i)
ProvideOption - For Value, this differentiates between an empty value ("") and a null value (StringRe...
static bool isQuote(char C)
static ManagedStatic< CommandLineCommonOptions > CommonOptions
static void initCommonOptions()
static void sortOpts(OptionsMapTy &OptMap, SmallVectorImpl< std::pair< const char *, Option * > > &Opts, bool ShowHidden)
DenseMap< StringRef, Option * > OptionsMapTy
static void tokenizeWindowsCommandLineImpl(StringRef Src, StringSaver &Saver, function_ref< void(StringRef)> AddToken, bool AlwaysCopy, function_ref< void()> MarkEOL, bool InitialCommandName)
static Option * findPrefixOption(StringRef Name, size_t &Length, const OptionsMapTy &OptionsMap)
static bool isWhitespace(char C)
static bool parseFixedOrScalableQuantity(Option &O, StringRef Arg, StringRef ValueKind, FixedOrScalableQuantityT &Value)
static size_t parseBackslash(StringRef Src, size_t I, SmallString< 128 > &Token)
Backslashes are interpreted in a rather complicated way in the Windows-style command line,...
static StringRef ArgPrefixLong
static void sortSubCommands(const SmallPtrSetImpl< SubCommand * > &SubMap, SmallVectorImpl< std::pair< const char *, SubCommand * > > &Subs)
#define PRINT_OPT_DIFF(T)
static bool isWhitespaceOrNull(char C)
static const size_t MaxOptWidth
static bool EatsUnboundedNumberOfValues(const Option *O)
static int OptNameCompare(const std::pair< const char *, Option * > *LHS, const std::pair< const char *, Option * > *RHS)
static Option * LookupNearestOption(StringRef Arg, const OptionsMapTy &OptionsMap, std::string &NearestString)
LookupNearestOption - Lookup the closest match to the option specified by the specified option on the...
static StringRef ArgPrefix
static bool isWindowsSpecialChar(char C)
static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos, StringRef ArgName, StringRef Value)
CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence() that does special handling ...
#define LLVM_EXPORT_TEMPLATE
Fixup Statepoint Caller Saved
static llvm::Error parse(GsymDataExtractor &Data, uint64_t BaseAddr, LineEntryCallback const &Callback)
static void Help(StringTable CPUNames, ArrayRef< SubtargetFeatureKV > FeatTable)
Display help for feature and mcpu choices.
Provides a library for accessing information about this process and other processes on the operating ...
This file defines the SmallPtrSet class.
This file defines the SmallString class.
Defines the virtual file system interface vfs::FileSystem.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
bool empty() const
Check if the array is empty.
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
ValueT lookup(const_arg_type_t< KeyT > Val) const
Return the entry for the specified key, or a default constructed value if no such entry exists.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Represents either an error or a value T.
std::error_code getError() const
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
size_t getBufferSize() const
const char * getBufferEnd() const
const char * getBufferStart() const
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
bool erase(PtrType Ptr)
Remove pointer from the set.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void assign(StringRef RHS)
Assign from a StringRef.
void append(StringRef RHS)
Append from a StringRef.
StringRef str() const
Explicit conversion to StringRef.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void assign(size_type NumElts, ValueParamT Elt)
reference emplace_back(ArgTypes &&... Args)
void reserve(size_type N)
iterator erase(const_iterator CI)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
iterator insert(iterator I, T &&Elt)
void push_back(const T &Elt)
LLVM_NO_SANITIZE_CFI_UNRELATED_CAST iterator begin()
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
static constexpr size_t npos
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
Check if the string is empty.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
LLVM_ABI unsigned edit_distance(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
Determine the edit distance between this string and another string.
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
constexpr size_t size() const
Get the string size.
constexpr const char * data() const
Get a pointer to the start of the string (which may not be null terminated).
StringRef ltrim(char Char) const
Return string with consecutive Char characters starting from the the left removed.
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
bool consume_front(char Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
BumpPtrAllocator & getAllocator() const
StringRef save(const char *S)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
Contains options that control response file expansion.
LLVM_ABI ExpansionContext(BumpPtrAllocator &A, TokenizerCallback T, vfs::FileSystem *FS=nullptr)
LLVM_ABI bool findConfigFile(StringRef FileName, SmallVectorImpl< char > &FilePath)
Looks for the specified configuration file.
LLVM_ABI Error expandResponseFiles(SmallVectorImpl< const char * > &Argv)
Expands constructs "@file" in the provided array of arguments recursively.
LLVM_ABI Error readConfigFile(StringRef CfgFile, SmallVectorImpl< const char * > &Argv)
Reads command line options from the given configuration file.
Error parse(const LibraryOptions &L, ArrayRef< const char * > Args, unsigned &Consumed)
void assign(const LibraryOptionsContext &Other)
The options of a library that declares them in TableGen rather than as cl::opt (see llvm/Option/Libra...
SmallPtrSet< SubCommand *, 1 > Subs
int getNumOccurrences() const
enum ValueExpected getValueExpectedFlag() const
void addCategory(OptionCategory &C)
enum FormattingFlags getFormattingFlag() const
virtual void printOptionInfo(size_t GlobalWidth) const =0
enum NumOccurrencesFlag getNumOccurrencesFlag() const
virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value)
SmallVector< OptionCategory *, 1 > Categories
bool error(const Twine &Message, StringRef ArgName=StringRef(), raw_ostream &Errs=llvm::errs())
void setArgStr(StringRef S)
unsigned getMiscFlags() const
virtual void setDefault()=0
virtual void printOptionValue(size_t GlobalWidth, bool Force) const =0
static void printEnumValHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
void removeArgument()
Unregisters this option from the CommandLine system.
static void printHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
virtual size_t getOptionWidth() const =0
Option(enum NumOccurrencesFlag OccurrencesFlag, enum OptionHidden Hidden)
StringRef getName() const
SubCommand(StringRef Name, StringRef Description="")
static LLVM_ABI SubCommand & getTopLevel()
LLVM_ABI void unregisterSubCommand()
static LLVM_ABI SubCommand & getAll()
DenseMap< StringRef, Option * > OptionsMap
LLVM_ABI void registerSubCommand()
SmallVector< Option *, 4 > PositionalOpts
void printOptionInfo(const Option &O, size_t GlobalWidth) const
virtual StringRef getValueName() const
void printOptionNoValue(const Option &O, size_t GlobalWidth) const
size_t getOptionWidth(const Option &O) const
void printOptionName(const Option &O, size_t GlobalWidth) const
virtual size_t getOptionWidth(const Option &O) const
virtual StringRef getDescription(unsigned N) const =0
virtual const GenericOptionValue & getOptionValue(unsigned N) const =0
virtual unsigned getNumOptions() const =0
virtual StringRef getOption(unsigned N) const =0
void printGenericOptionDiff(const Option &O, const GenericOptionValue &V, const GenericOptionValue &Default, size_t GlobalWidth) const
virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const
unsigned findOption(StringRef Name)
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
A raw_ostream that writes to an SmallVector or SmallString.
static LLVM_ABI std::optional< std::string > GetEnv(StringRef name)
The virtual file system interface.
The result of a status operation.
LLVM_ABI bool equivalent(const Status &Other) const
LLVM_C_ABI LLVMBool LLVMParseCommandLineOptionsWithError(int argc, const char *const *argv, const char *Overview, char **ErrorMessage)
Like LLVMParseCommandLineOptions() but returns non-zero and sets *ErrorMessage on error.
LLVM_C_ABI void LLVMParseCommandLineOptions(int argc, const char *const *argv, const char *Overview)
This function parses the given arguments using the LLVM command line parser.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr size_t NameSize
This namespace contains all of the command line option processing machinery.
LLVM_ABI iterator_range< SmallPtrSet< SubCommand *, 4 >::iterator > getRegisteredSubcommands()
Use this to get all registered SubCommands from the provided parser.
LLVM_ABI void PrintVersionMessage()
Utility function for printing version number.
LLVM_ABI bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv)
A convenience helper which supports the typical use case of expansion function call.
LLVM_ABI LibraryOptionsContext & getCAPILibraryOptions()
LLVM_ABI void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes a string of Windows command line arguments, which may contain quotes and escaped quotes.
LLVM_ABI OptionCategory & getGeneralCategory()
LLVM_ABI void addLibraryOptions(const LibraryOptions &L)
Makes ParseCommandLineOptions recognize L's options.
LLVM_ABI void ResetAllOptionOccurrences()
Reset all command line options to a state that looks as if they have never appeared on the command li...
LLVM_ABI void SetVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// Override the default (LLV...
LLVM_ABI void tokenizeConfigFile(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes content of configuration file.
LLVM_ABI DenseMap< StringRef, Option * > & getRegisteredOptions(SubCommand &Sub=SubCommand::getTopLevel())
Use this to get a map of all registered named options (e.g.
LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv)
A convenience helper which concatenates the options specified by the environment variable EnvVar and ...
LLVM_ABI void ResetCommandLineParser()
Reset the command line parser back to its initial state.
LLVM_ABI void PrintOptionValues()
LLVM_ABI void AddLiteralOption(Option &O, StringRef Name)
Adds a new option for parsing and provides the option it refers to.
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
LLVM_ABI void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver, SmallVectorImpl< StringRef > &NewArgv)
Tokenizes a Windows command line while attempting to avoid copies.
LLVM_ABI void printBuildConfig(raw_ostream &OS)
Prints the compiler build configuration.
void(*)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs) TokenizerCallback
String tokenization function type.
LLVM_ABI bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i)
Parses Arg into the option handler Handler.
static raw_ostream & operator<<(raw_ostream &OS, boolOrDefault V)
initializer< Ty > init(const Ty &Val)
std::function< void(raw_ostream &)> VersionPrinterTy
LLVM_ABI bool parseCommandLineOptions(LibraryOptionsContext &Context, ArrayRef< const char * > Args, StringRef Overview="", raw_ostream *Errs=nullptr, vfs::FileSystem *VFS=nullptr, const char *EnvVar=nullptr)
LLVM_ABI ArrayRef< StringRef > getCompilerBuildConfig()
An array of optional enabled settings in the LLVM build configuration, which may be of interest to co...
LocationClass< Ty > location(Ty &L)
LLVM_ABI bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, vfs::FileSystem *VFS=nullptr, const char *EnvVar=nullptr)
LLVM_ABI void HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub=SubCommand::getTopLevel())
Mark all options not part of this category as cl::ReallyHidden.
LLVM_ABI void AddExtraVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// Add an extra printer to u...
LLVM_ABI void PrintHelpMessage(bool Hidden=false, bool Categorized=false)
This function just prints the help message, exactly the same way as if the -help or -help-hidden opti...
LLVM_ABI void TokenizeWindowsCommandLineFull(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes a Windows full command line, including command name at the start.
LLVM_ABI void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)
Tokenizes a command line that can contain escapes and quotes.
LLVM_ABI StringRef parent_path(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get parent path.
LLVM_ABI bool has_parent_path(const Twine &path, Style style=Style::native)
Has parent path?
LLVM_ABI bool is_relative(const Twine &path, Style style=Style::native)
Is path relative?
LLVM_ABI StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get filename.
LLVM_ABI bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
LLVM_ABI IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
void initWithColorOptions()
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
LLVM_ABI raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
void interleaveComma(const Container &c, StreamT &os, UnaryFunctor each_fn)
LLVM_ABI bool hasUTF16ByteOrderMark(ArrayRef< char > SrcBytes)
Returns true if a blob of text starts with a UTF-16 big or little endian byte order mark.
void initDebugCounterOptions()
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
detail::concat_range< ValueT, RangeTs... > concat(RangeTs &&...Ranges)
Returns a concatenated range across two or more ranges.
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
bool to_float(const Twine &T, float &Num)
@ no_such_file_or_directory
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
void sort(IteratorTy Start, IteratorTy End)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
LLVM_ABI bool convertUTF16ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)
Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
void initSignalsOptions()
void initStatisticOptions()
LLVM_ABI raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
void initRandomSeedOptions()
@ Sub
Subtraction of integers.
void initGraphWriterOptions()
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
ArrayRef(const T &OneElt) -> ArrayRef< T >
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
void array_pod_sort(IteratorTy Start, IteratorTy End)
array_pod_sort - This sorts an array with the specified start and end extent.
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
@ End
Run the machine verifier once, at the end of the pipeline.