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