LLVM  14.0.0git
CommandLine.h
Go to the documentation of this file.
1 //===- llvm/Support/CommandLine.h - Command line handler --------*- C++ -*-===//
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 should
14 // read the library documentation located in docs/CommandLine.html or looks at
15 // the many example usages in tools/*/*.cpp
16 //
17 //===----------------------------------------------------------------------===//
18 
19 #ifndef LLVM_SUPPORT_COMMANDLINE_H
20 #define LLVM_SUPPORT_COMMANDLINE_H
21 
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/None.h"
24 #include "llvm/ADT/Optional.h"
25 #include "llvm/ADT/STLExtras.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/ADT/StringMap.h"
29 #include "llvm/ADT/StringRef.h"
30 #include "llvm/ADT/Twine.h"
35 #include <cassert>
36 #include <climits>
37 #include <cstddef>
38 #include <functional>
39 #include <initializer_list>
40 #include <string>
41 #include <type_traits>
42 #include <vector>
43 
44 namespace llvm {
45 
46 namespace vfs {
47 class FileSystem;
48 }
49 
50 class StringSaver;
51 
52 /// cl Namespace - This namespace contains all of the command line option
53 /// processing machinery. It is intentionally a short name to make qualified
54 /// usage concise.
55 namespace cl {
56 
57 //===----------------------------------------------------------------------===//
58 // ParseCommandLineOptions - Command line option processing entry point.
59 //
60 // Returns true on success. Otherwise, this will print the error message to
61 // stderr and exit if \p Errs is not set (nullptr by default), or print the
62 // error message to \p Errs and return false if \p Errs is provided.
63 //
64 // If EnvVar is not nullptr, command-line options are also parsed from the
65 // environment variable named by EnvVar. Precedence is given to occurrences
66 // from argv. This precedence is currently implemented by parsing argv after
67 // the environment variable, so it is only implemented correctly for options
68 // that give precedence to later occurrences. If your program supports options
69 // that give precedence to earlier occurrences, you will need to extend this
70 // function to support it correctly.
71 bool ParseCommandLineOptions(int argc, const char *const *argv,
72  StringRef Overview = "",
73  raw_ostream *Errs = nullptr,
74  const char *EnvVar = nullptr,
75  bool LongOptionsUseDoubleDash = false);
76 
77 // Function pointer type for printing version information.
79 
80 ///===---------------------------------------------------------------------===//
81 /// SetVersionPrinter - Override the default (LLVM specific) version printer
82 /// used to print out the version when --version is given
83 /// on the command line. This allows other systems using the
84 /// CommandLine utilities to print their own version string.
86 
87 ///===---------------------------------------------------------------------===//
88 /// AddExtraVersionPrinter - Add an extra printer to use in addition to the
89 /// default one. This can be called multiple times,
90 /// and each time it adds a new function to the list
91 /// which will be called after the basic LLVM version
92 /// printing is complete. Each can then add additional
93 /// information specific to the tool.
95 
96 // PrintOptionValues - Print option values.
97 // With -print-options print the difference between option values and defaults.
98 // With -print-all-options print all option values.
99 // (Currently not perfect, but best-effort.)
100 void PrintOptionValues();
101 
102 // Forward declaration - AddLiteralOption needs to be up here to make gcc happy.
103 class Option;
104 
105 /// Adds a new option for parsing and provides the option it refers to.
106 ///
107 /// \param O pointer to the option
108 /// \param Name the string name for the option to handle during parsing
109 ///
110 /// Literal options are used by some parsers to register special option values.
111 /// This is how the PassNameParser registers pass names for opt.
113 
114 //===----------------------------------------------------------------------===//
115 // Flags permitted to be passed to command line arguments
116 //
117 
118 enum NumOccurrencesFlag { // Flags for the number of occurrences allowed
119  Optional = 0x00, // Zero or One occurrence
120  ZeroOrMore = 0x01, // Zero or more occurrences allowed
121  Required = 0x02, // One occurrence required
122  OneOrMore = 0x03, // One or more occurrences required
123 
124  // ConsumeAfter - Indicates that this option is fed anything that follows the
125  // last positional argument required by the application (it is an error if
126  // there are zero positional arguments, and a ConsumeAfter option is used).
127  // Thus, for example, all arguments to LLI are processed until a filename is
128  // found. Once a filename is found, all of the succeeding arguments are
129  // passed, unprocessed, to the ConsumeAfter option.
130  //
132 };
133 
134 enum ValueExpected { // Is a value required for the option?
135  // zero reserved for the unspecified value
136  ValueOptional = 0x01, // The value can appear... or not
137  ValueRequired = 0x02, // The value is required to appear!
138  ValueDisallowed = 0x03 // A value may not be specified (for flags)
139 };
140 
141 enum OptionHidden { // Control whether -help shows this option
142  NotHidden = 0x00, // Option included in -help & -help-hidden
143  Hidden = 0x01, // -help doesn't, but -help-hidden does
144  ReallyHidden = 0x02 // Neither -help nor -help-hidden show this arg
145 };
146 
147 // Formatting flags - This controls special features that the option might have
148 // that cause it to be parsed differently...
149 //
150 // Prefix - This option allows arguments that are otherwise unrecognized to be
151 // matched by options that are a prefix of the actual value. This is useful for
152 // cases like a linker, where options are typically of the form '-lfoo' or
153 // '-L../../include' where -l or -L are the actual flags. When prefix is
154 // enabled, and used, the value for the flag comes from the suffix of the
155 // argument.
156 //
157 // AlwaysPrefix - Only allow the behavior enabled by the Prefix flag and reject
158 // the Option=Value form.
159 //
160 
162  NormalFormatting = 0x00, // Nothing special
163  Positional = 0x01, // Is a positional argument, no '-' required
164  Prefix = 0x02, // Can this option directly prefix its value?
165  AlwaysPrefix = 0x03 // Can this option only directly prefix its value?
166 };
167 
168 enum MiscFlags { // Miscellaneous flags to adjust argument
169  CommaSeparated = 0x01, // Should this cl::list split between commas?
170  PositionalEatsArgs = 0x02, // Should this positional cl::list eat -args?
171  Sink = 0x04, // Should this cl::list eat all unknown options?
172 
173  // Grouping - Can this option group with other options?
174  // If this is enabled, multiple letter options are allowed to bunch together
175  // with only a single hyphen for the whole group. This allows emulation
176  // of the behavior that ls uses for example: ls -la === ls -l -a
177  Grouping = 0x08,
178 
179  // Default option
181 };
182 
183 //===----------------------------------------------------------------------===//
184 // Option Category class
185 //
187 private:
188  StringRef const Name;
189  StringRef const Description;
190 
191  void registerCategory();
192 
193 public:
195  StringRef const Description = "")
196  : Name(Name), Description(Description) {
197  registerCategory();
198  }
199 
200  StringRef getName() const { return Name; }
201  StringRef getDescription() const { return Description; }
202 };
203 
204 // The general Option Category (used as default category).
205 OptionCategory &getGeneralCategory();
206 
207 //===----------------------------------------------------------------------===//
208 // SubCommand class
209 //
210 class SubCommand {
211 private:
212  StringRef Name;
213  StringRef Description;
214 
215 protected:
216  void registerSubCommand();
217  void unregisterSubCommand();
218 
219 public:
220  SubCommand(StringRef Name, StringRef Description = "")
221  : Name(Name), Description(Description) {
223  }
224  SubCommand() = default;
225 
226  void reset();
227 
228  explicit operator bool() const;
229 
230  StringRef getName() const { return Name; }
231  StringRef getDescription() const { return Description; }
232 
236 
237  Option *ConsumeAfterOpt = nullptr; // The ConsumeAfter option if it exists.
238 };
239 
240 // A special subcommand representing no subcommand
242 
243 // A special subcommand that can be used to put an option into all subcommands.
245 
246 //===----------------------------------------------------------------------===//
247 // Option Base class
248 //
249 class Option {
250  friend class alias;
251 
252  // handleOccurrences - Overriden by subclasses to handle the value passed into
253  // an argument. Should return true if there was an error processing the
254  // argument and the program should exit.
255  //
256  virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
257  StringRef Arg) = 0;
258 
259  virtual enum ValueExpected getValueExpectedFlagDefault() const {
260  return ValueOptional;
261  }
262 
263  // Out of line virtual function to provide home for the class.
264  virtual void anchor();
265 
266  uint16_t NumOccurrences; // The number of times specified
267  // Occurrences, HiddenFlag, and Formatting are all enum types but to avoid
268  // problems with signed enums in bitfields.
269  uint16_t Occurrences : 3; // enum NumOccurrencesFlag
270  // not using the enum type for 'Value' because zero is an implementation
271  // detail representing the non-value
272  uint16_t Value : 2;
273  uint16_t HiddenFlag : 2; // enum OptionHidden
274  uint16_t Formatting : 2; // enum FormattingFlags
275  uint16_t Misc : 5;
276  uint16_t FullyInitialized : 1; // Has addArgument been called?
277  uint16_t Position; // Position of last occurrence of the option
278  uint16_t AdditionalVals; // Greater than 0 for multi-valued option.
279 
280 public:
281  StringRef ArgStr; // The argument string itself (ex: "help", "o")
282  StringRef HelpStr; // The descriptive text message for -help
283  StringRef ValueStr; // String describing what the value of this option is
285  Categories; // The Categories this option belongs to
286  SmallPtrSet<SubCommand *, 1> Subs; // The subcommands this option belongs to.
287 
289  return (enum NumOccurrencesFlag)Occurrences;
290  }
291 
292  inline enum ValueExpected getValueExpectedFlag() const {
293  return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
294  }
295 
296  inline enum OptionHidden getOptionHiddenFlag() const {
297  return (enum OptionHidden)HiddenFlag;
298  }
299 
300  inline enum FormattingFlags getFormattingFlag() const {
301  return (enum FormattingFlags)Formatting;
302  }
303 
304  inline unsigned getMiscFlags() const { return Misc; }
305  inline unsigned getPosition() const { return Position; }
306  inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
307 
308  // hasArgStr - Return true if the argstr != ""
309  bool hasArgStr() const { return !ArgStr.empty(); }
310  bool isPositional() const { return getFormattingFlag() == cl::Positional; }
311  bool isSink() const { return getMiscFlags() & cl::Sink; }
312  bool isDefaultOption() const { return getMiscFlags() & cl::DefaultOption; }
313 
314  bool isConsumeAfter() const {
316  }
317 
318  bool isInAllSubCommands() const {
320  }
321 
322  //-------------------------------------------------------------------------===
323  // Accessor functions set by OptionModifiers
324  //
325  void setArgStr(StringRef S);
328  void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
329  void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
330  void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
331  void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
332  void setMiscFlag(enum MiscFlags M) { Misc |= M; }
333  void setPosition(unsigned pos) { Position = pos; }
335  void addSubCommand(SubCommand &S) { Subs.insert(&S); }
336 
337 protected:
338  explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
339  enum OptionHidden Hidden)
340  : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
341  HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0),
342  FullyInitialized(false), Position(0), AdditionalVals(0) {
343  Categories.push_back(&getGeneralCategory());
344  }
345 
346  inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
347 
348 public:
349  virtual ~Option() = default;
350 
351  // addArgument - Register this argument with the commandline system.
352  //
353  void addArgument();
354 
355  /// Unregisters this option from the CommandLine system.
356  ///
357  /// This option must have been the last option registered.
358  /// For testing purposes only.
359  void removeArgument();
360 
361  // Return the width of the option tag for printing...
362  virtual size_t getOptionWidth() const = 0;
363 
364  // printOptionInfo - Print out information about this option. The
365  // to-be-maintained width is specified.
366  //
367  virtual void printOptionInfo(size_t GlobalWidth) const = 0;
368 
369  virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
370 
371  virtual void setDefault() = 0;
372 
373  // Prints the help string for an option.
374  //
375  // This maintains the Indent for multi-line descriptions.
376  // FirstLineIndentedBy is the count of chars of the first line
377  // i.e. the one containing the --<option name>.
378  static void printHelpStr(StringRef HelpStr, size_t Indent,
379  size_t FirstLineIndentedBy);
380 
381  // Prints the help string for an enum value.
382  //
383  // This maintains the Indent for multi-line descriptions.
384  // FirstLineIndentedBy is the count of chars of the first line
385  // i.e. the one containing the =<value>.
386  static void printEnumValHelpStr(StringRef HelpStr, size_t Indent,
387  size_t FirstLineIndentedBy);
388 
390 
391  // addOccurrence - Wrapper around handleOccurrence that enforces Flags.
392  //
393  virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
394  bool MultiArg = false);
395 
396  // Prints option name followed by message. Always returns true.
397  bool error(const Twine &Message, StringRef ArgName = StringRef(), raw_ostream &Errs = llvm::errs());
398  bool error(const Twine &Message, raw_ostream &Errs) {
399  return error(Message, StringRef(), Errs);
400  }
401 
402  inline int getNumOccurrences() const { return NumOccurrences; }
403  void reset();
404 };
405 
406 //===----------------------------------------------------------------------===//
407 // Command line option modifiers that can be used to modify the behavior of
408 // command line option parsers...
409 //
410 
411 // desc - Modifier to set the description shown in the -help output...
412 struct desc {
414 
415  desc(StringRef Str) : Desc(Str) {}
416 
417  void apply(Option &O) const { O.setDescription(Desc); }
418 };
419 
420 // value_desc - Modifier to set the value description shown in the -help
421 // output...
422 struct value_desc {
424 
425  value_desc(StringRef Str) : Desc(Str) {}
426 
427  void apply(Option &O) const { O.setValueStr(Desc); }
428 };
429 
430 // init - Specify a default (initial) value for the command line argument, if
431 // the default constructor for the argument type does not give you what you
432 // want. This is only valid on "opt" arguments, not on "list" arguments.
433 //
434 template <class Ty> struct initializer {
435  const Ty &Init;
436  initializer(const Ty &Val) : Init(Val) {}
437 
438  template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
439 };
440 
441 template <class Ty> initializer<Ty> init(const Ty &Val) {
442  return initializer<Ty>(Val);
443 }
444 
445 // location - Allow the user to specify which external variable they want to
446 // store the results of the command line argument processing into, if they don't
447 // want to store it in the option itself.
448 //
449 template <class Ty> struct LocationClass {
450  Ty &Loc;
451 
452  LocationClass(Ty &L) : Loc(L) {}
453 
454  template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
455 };
456 
457 template <class Ty> LocationClass<Ty> location(Ty &L) {
458  return LocationClass<Ty>(L);
459 }
460 
461 // cat - Specifiy the Option category for the command line argument to belong
462 // to.
463 struct cat {
465 
467 
468  template <class Opt> void apply(Opt &O) const { O.addCategory(Category); }
469 };
470 
471 // sub - Specify the subcommand that this option belongs to.
472 struct sub {
474 
475  sub(SubCommand &S) : Sub(S) {}
476 
477  template <class Opt> void apply(Opt &O) const { O.addSubCommand(Sub); }
478 };
479 
480 // Specify a callback function to be called when an option is seen.
481 // Can be used to set other options automatically.
482 template <typename R, typename Ty> struct cb {
484 
485  cb(std::function<R(Ty)> CB) : CB(CB) {}
486 
487  template <typename Opt> void apply(Opt &O) const { O.setCallback(CB); }
488 };
489 
490 namespace detail {
491 template <typename F>
492 struct callback_traits : public callback_traits<decltype(&F::operator())> {};
493 
494 template <typename R, typename C, typename... Args>
495 struct callback_traits<R (C::*)(Args...) const> {
496  using result_type = R;
497  using arg_type = std::tuple_element_t<0, std::tuple<Args...>>;
498  static_assert(sizeof...(Args) == 1, "callback function must have one and only one parameter");
499  static_assert(std::is_same<result_type, void>::value,
500  "callback return type must be void");
501  static_assert(std::is_lvalue_reference<arg_type>::value &&
502  std::is_const<std::remove_reference_t<arg_type>>::value,
503  "callback arg_type must be a const lvalue reference");
504 };
505 } // namespace detail
506 
507 template <typename F>
510 callback(F CB) {
511  using result_type = typename detail::callback_traits<F>::result_type;
512  using arg_type = typename detail::callback_traits<F>::arg_type;
513  return cb<result_type, arg_type>(CB);
514 }
515 
516 //===----------------------------------------------------------------------===//
517 // OptionValue class
518 
519 // Support value comparison outside the template.
521  virtual bool compare(const GenericOptionValue &V) const = 0;
522 
523 protected:
524  GenericOptionValue() = default;
525  GenericOptionValue(const GenericOptionValue&) = default;
526  GenericOptionValue &operator=(const GenericOptionValue &) = default;
527  ~GenericOptionValue() = default;
528 
529 private:
530  virtual void anchor();
531 };
532 
533 template <class DataType> struct OptionValue;
534 
535 // The default value safely does nothing. Option value printing is only
536 // best-effort.
537 template <class DataType, bool isClass>
539  // Temporary storage for argument passing.
541 
542  bool hasValue() const { return false; }
543 
544  const DataType &getValue() const { llvm_unreachable("no default value"); }
545 
546  // Some options may take their value from a different data type.
547  template <class DT> void setValue(const DT & /*V*/) {}
548 
549  bool compare(const DataType & /*V*/) const { return false; }
550 
551  bool compare(const GenericOptionValue & /*V*/) const override {
552  return false;
553  }
554 
555 protected:
556  ~OptionValueBase() = default;
557 };
558 
559 // Simple copy of the option value.
560 template <class DataType> class OptionValueCopy : public GenericOptionValue {
561  DataType Value;
562  bool Valid = false;
563 
564 protected:
565  OptionValueCopy(const OptionValueCopy&) = default;
566  OptionValueCopy &operator=(const OptionValueCopy &) = default;
567  ~OptionValueCopy() = default;
568 
569 public:
570  OptionValueCopy() = default;
571 
572  bool hasValue() const { return Valid; }
573 
574  const DataType &getValue() const {
575  assert(Valid && "invalid option value");
576  return Value;
577  }
578 
579  void setValue(const DataType &V) {
580  Valid = true;
581  Value = V;
582  }
583 
584  bool compare(const DataType &V) const { return Valid && (Value != V); }
585 
586  bool compare(const GenericOptionValue &V) const override {
588  static_cast<const OptionValueCopy<DataType> &>(V);
589  if (!VC.hasValue())
590  return false;
591  return compare(VC.getValue());
592  }
593 };
594 
595 // Non-class option values.
596 template <class DataType>
597 struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
598  using WrapperType = DataType;
599 
600 protected:
601  OptionValueBase() = default;
602  OptionValueBase(const OptionValueBase&) = default;
603  OptionValueBase &operator=(const OptionValueBase &) = default;
604  ~OptionValueBase() = default;
605 };
606 
607 // Top-level option class.
608 template <class DataType>
609 struct OptionValue final
610  : OptionValueBase<DataType, std::is_class<DataType>::value> {
611  OptionValue() = default;
612 
613  OptionValue(const DataType &V) { this->setValue(V); }
614 
615  // Some options may take their value from a different data type.
616  template <class DT> OptionValue<DataType> &operator=(const DT &V) {
617  this->setValue(V);
618  return *this;
619  }
620 };
621 
622 // Other safe-to-copy-by-value common option types.
624 template <>
626  : OptionValueCopy<cl::boolOrDefault> {
628 
629  OptionValue() = default;
630 
631  OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
632 
634  setValue(V);
635  return *this;
636  }
637 
638 private:
639  void anchor() override;
640 };
641 
642 template <>
643 struct OptionValue<std::string> final : OptionValueCopy<std::string> {
645 
646  OptionValue() = default;
647 
648  OptionValue(const std::string &V) { this->setValue(V); }
649 
650  OptionValue<std::string> &operator=(const std::string &V) {
651  setValue(V);
652  return *this;
653  }
654 
655 private:
656  void anchor() override;
657 };
658 
659 //===----------------------------------------------------------------------===//
660 // Enum valued command line option
661 //
662 
663 // This represents a single enum value, using "int" as the underlying type.
666  int Value;
668 };
669 
670 #define clEnumVal(ENUMVAL, DESC) \
671  llvm::cl::OptionEnumValue { #ENUMVAL, int(ENUMVAL), DESC }
672 #define clEnumValN(ENUMVAL, FLAGNAME, DESC) \
673  llvm::cl::OptionEnumValue { FLAGNAME, int(ENUMVAL), DESC }
674 
675 // values - For custom data types, allow specifying a group of values together
676 // as the values that go into the mapping that the option handler uses.
677 //
678 class ValuesClass {
679  // Use a vector instead of a map, because the lists should be short,
680  // the overhead is less, and most importantly, it keeps them in the order
681  // inserted so we can print our option out nicely.
683 
684 public:
685  ValuesClass(std::initializer_list<OptionEnumValue> Options)
686  : Values(Options) {}
687 
688  template <class Opt> void apply(Opt &O) const {
689  for (const auto &Value : Values)
690  O.getParser().addLiteralOption(Value.Name, Value.Value,
691  Value.Description);
692  }
693 };
694 
695 /// Helper to build a ValuesClass by forwarding a variable number of arguments
696 /// as an initializer list to the ValuesClass constructor.
697 template <typename... OptsTy> ValuesClass values(OptsTy... Options) {
698  return ValuesClass({Options...});
699 }
700 
701 //===----------------------------------------------------------------------===//
702 // parser class - Parameterizable parser for different data types. By default,
703 // known data types (string, int, bool) have specialized parsers, that do what
704 // you would expect. The default parser, used for data types that are not
705 // built-in, uses a mapping table to map specific options to values, which is
706 // used, among other things, to handle enum types.
707 
708 //--------------------------------------------------
709 // generic_parser_base - This class holds all the non-generic code that we do
710 // not need replicated for every instance of the generic parser. This also
711 // allows us to put stuff into CommandLine.cpp
712 //
714 protected:
716  public:
718  : Name(name), HelpStr(helpStr) {}
721  };
722 
723 public:
725 
726  virtual ~generic_parser_base() = default;
727  // Base class should have virtual-destructor
728 
729  // getNumOptions - Virtual function implemented by generic subclass to
730  // indicate how many entries are in Values.
731  //
732  virtual unsigned getNumOptions() const = 0;
733 
734  // getOption - Return option name N.
735  virtual StringRef getOption(unsigned N) const = 0;
736 
737  // getDescription - Return description N
738  virtual StringRef getDescription(unsigned N) const = 0;
739 
740  // Return the width of the option tag for printing...
741  virtual size_t getOptionWidth(const Option &O) const;
742 
743  virtual const GenericOptionValue &getOptionValue(unsigned N) const = 0;
744 
745  // printOptionInfo - Print out information about this option. The
746  // to-be-maintained width is specified.
747  //
748  virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;
749 
750  void printGenericOptionDiff(const Option &O, const GenericOptionValue &V,
751  const GenericOptionValue &Default,
752  size_t GlobalWidth) const;
753 
754  // printOptionDiff - print the value of an option and it's default.
755  //
756  // Template definition ensures that the option and default have the same
757  // DataType (via the same AnyOptionValue).
758  template <class AnyOptionValue>
759  void printOptionDiff(const Option &O, const AnyOptionValue &V,
760  const AnyOptionValue &Default,
761  size_t GlobalWidth) const {
762  printGenericOptionDiff(O, V, Default, GlobalWidth);
763  }
764 
765  void initialize() {}
766 
768  // If there has been no argstr specified, that means that we need to add an
769  // argument for every possible option. This ensures that our options are
770  // vectored to us.
771  if (!Owner.hasArgStr())
772  for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
773  OptionNames.push_back(getOption(i));
774  }
775 
777  // If there is an ArgStr specified, then we are of the form:
778  //
779  // -opt=O2 or -opt O2 or -optO2
780  //
781  // In which case, the value is required. Otherwise if an arg str has not
782  // been specified, we are of the form:
783  //
784  // -O2 or O2 or -la (where -l and -a are separate options)
785  //
786  // If this is the case, we cannot allow a value.
787  //
788  if (Owner.hasArgStr())
789  return ValueRequired;
790  else
791  return ValueDisallowed;
792  }
793 
794  // findOption - Return the option number corresponding to the specified
795  // argument string. If the option is not found, getNumOptions() is returned.
796  //
797  unsigned findOption(StringRef Name);
798 
799 protected:
801 };
802 
803 // Default parser implementation - This implementation depends on having a
804 // mapping of recognized options to values of some sort. In addition to this,
805 // each entry in the mapping also tracks a help message that is printed with the
806 // command line option for -help. Because this is a simple mapping parser, the
807 // data type can be any unsupported type.
808 //
809 template <class DataType> class parser : public generic_parser_base {
810 protected:
811  class OptionInfo : public GenericOptionInfo {
812  public:
813  OptionInfo(StringRef name, DataType v, StringRef helpStr)
814  : GenericOptionInfo(name, helpStr), V(v) {}
815 
817  };
819 
820 public:
822 
823  using parser_data_type = DataType;
824 
825  // Implement virtual functions needed by generic_parser_base
826  unsigned getNumOptions() const override { return unsigned(Values.size()); }
827  StringRef getOption(unsigned N) const override { return Values[N].Name; }
828  StringRef getDescription(unsigned N) const override {
829  return Values[N].HelpStr;
830  }
831 
832  // getOptionValue - Return the value of option name N.
833  const GenericOptionValue &getOptionValue(unsigned N) const override {
834  return Values[N].V;
835  }
836 
837  // parse - Return true on error.
838  bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
839  StringRef ArgVal;
840  if (Owner.hasArgStr())
841  ArgVal = Arg;
842  else
843  ArgVal = ArgName;
844 
845  for (size_t i = 0, e = Values.size(); i != e; ++i)
846  if (Values[i].Name == ArgVal) {
847  V = Values[i].V.getValue();
848  return false;
849  }
850 
851  return O.error("Cannot find option named '" + ArgVal + "'!");
852  }
853 
854  /// addLiteralOption - Add an entry to the mapping table.
855  ///
856  template <class DT>
857  void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
858  assert(findOption(Name) == Values.size() && "Option already exists!");
859  OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
860  Values.push_back(X);
862  }
863 
864  /// removeLiteralOption - Remove the specified option.
865  ///
867  unsigned N = findOption(Name);
868  assert(N != Values.size() && "Option not found!");
869  Values.erase(Values.begin() + N);
870  }
871 };
872 
873 //--------------------------------------------------
874 // basic_parser - Super class of parsers to provide boilerplate code
875 //
876 class basic_parser_impl { // non-template implementation of basic_parser<t>
877 public:
879 
880  virtual ~basic_parser_impl() {}
881 
883  return ValueRequired;
884  }
885 
887 
888  void initialize() {}
889 
890  // Return the width of the option tag for printing...
891  size_t getOptionWidth(const Option &O) const;
892 
893  // printOptionInfo - Print out information about this option. The
894  // to-be-maintained width is specified.
895  //
896  void printOptionInfo(const Option &O, size_t GlobalWidth) const;
897 
898  // printOptionNoValue - Print a placeholder for options that don't yet support
899  // printOptionDiff().
900  void printOptionNoValue(const Option &O, size_t GlobalWidth) const;
901 
902  // getValueName - Overload in subclass to provide a better default value.
903  virtual StringRef getValueName() const { return "value"; }
904 
905  // An out-of-line virtual method to provide a 'home' for this class.
906  virtual void anchor();
907 
908 protected:
909  // A helper for basic_parser::printOptionDiff.
910  void printOptionName(const Option &O, size_t GlobalWidth) const;
911 };
912 
913 // basic_parser - The real basic parser is just a template wrapper that provides
914 // a typedef for the provided data type.
915 //
916 template <class DataType> class basic_parser : public basic_parser_impl {
917 public:
918  using parser_data_type = DataType;
920 
922 };
923 
924 //--------------------------------------------------
925 // parser<bool>
926 //
927 
928 extern template class basic_parser<bool>;
929 
930 template <> class parser<bool> : public basic_parser<bool> {
931 public:
933 
934  // parse - Return true on error.
935  bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
936 
937  void initialize() {}
938 
939  enum ValueExpected getValueExpectedFlagDefault() const {
940  return ValueOptional;
941  }
942 
943  // getValueName - Do not print =<value> at all.
944  StringRef getValueName() const override { return StringRef(); }
945 
946  void printOptionDiff(const Option &O, bool V, OptVal Default,
947  size_t GlobalWidth) const;
948 
949  // An out-of-line virtual method to provide a 'home' for this class.
950  void anchor() override;
951 };
952 
953 //--------------------------------------------------
954 // parser<boolOrDefault>
955 
956 extern template class basic_parser<boolOrDefault>;
957 
959 public:
961 
962  // parse - Return true on error.
963  bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
964 
965  enum ValueExpected getValueExpectedFlagDefault() const {
966  return ValueOptional;
967  }
968 
969  // getValueName - Do not print =<value> at all.
970  StringRef getValueName() const override { return StringRef(); }
971 
972  void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
973  size_t GlobalWidth) const;
974 
975  // An out-of-line virtual method to provide a 'home' for this class.
976  void anchor() override;
977 };
978 
979 //--------------------------------------------------
980 // parser<int>
981 //
982 
983 extern template class basic_parser<int>;
984 
985 template <> class parser<int> : public basic_parser<int> {
986 public:
988 
989  // parse - Return true on error.
990  bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
991 
992  // getValueName - Overload in subclass to provide a better default value.
993  StringRef getValueName() const override { return "int"; }
994 
995  void printOptionDiff(const Option &O, int V, OptVal Default,
996  size_t GlobalWidth) const;
997 
998  // An out-of-line virtual method to provide a 'home' for this class.
999  void anchor() override;
1000 };
1001 
1002 //--------------------------------------------------
1003 // parser<long>
1004 //
1005 
1006 extern template class basic_parser<long>;
1007 
1008 template <> class parser<long> final : public basic_parser<long> {
1009 public:
1011 
1012  // parse - Return true on error.
1013  bool parse(Option &O, StringRef ArgName, StringRef Arg, long &Val);
1014 
1015  // getValueName - Overload in subclass to provide a better default value.
1016  StringRef getValueName() const override { return "long"; }
1017 
1018  void printOptionDiff(const Option &O, long V, OptVal Default,
1019  size_t GlobalWidth) const;
1020 
1021  // An out-of-line virtual method to provide a 'home' for this class.
1022  void anchor() override;
1023 };
1024 
1025 //--------------------------------------------------
1026 // parser<long long>
1027 //
1028 
1029 extern template class basic_parser<long long>;
1030 
1031 template <> class parser<long long> : public basic_parser<long long> {
1032 public:
1034 
1035  // parse - Return true on error.
1036  bool parse(Option &O, StringRef ArgName, StringRef Arg, long long &Val);
1037 
1038  // getValueName - Overload in subclass to provide a better default value.
1039  StringRef getValueName() const override { return "long"; }
1040 
1041  void printOptionDiff(const Option &O, long long V, OptVal Default,
1042  size_t GlobalWidth) const;
1043 
1044  // An out-of-line virtual method to provide a 'home' for this class.
1045  void anchor() override;
1046 };
1047 
1048 //--------------------------------------------------
1049 // parser<unsigned>
1050 //
1051 
1052 extern template class basic_parser<unsigned>;
1053 
1054 template <> class parser<unsigned> : public basic_parser<unsigned> {
1055 public:
1057 
1058  // parse - Return true on error.
1059  bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
1060 
1061  // getValueName - Overload in subclass to provide a better default value.
1062  StringRef getValueName() const override { return "uint"; }
1063 
1064  void printOptionDiff(const Option &O, unsigned V, OptVal Default,
1065  size_t GlobalWidth) const;
1066 
1067  // An out-of-line virtual method to provide a 'home' for this class.
1068  void anchor() override;
1069 };
1070 
1071 //--------------------------------------------------
1072 // parser<unsigned long>
1073 //
1074 
1075 extern template class basic_parser<unsigned long>;
1076 
1077 template <>
1079 public:
1081 
1082  // parse - Return true on error.
1083  bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long &Val);
1084 
1085  // getValueName - Overload in subclass to provide a better default value.
1086  StringRef getValueName() const override { return "ulong"; }
1087 
1088  void printOptionDiff(const Option &O, unsigned long V, OptVal Default,
1089  size_t GlobalWidth) const;
1090 
1091  // An out-of-line virtual method to provide a 'home' for this class.
1092  void anchor() override;
1093 };
1094 
1095 //--------------------------------------------------
1096 // parser<unsigned long long>
1097 //
1098 
1099 extern template class basic_parser<unsigned long long>;
1100 
1101 template <>
1103 public:
1105 
1106  // parse - Return true on error.
1107  bool parse(Option &O, StringRef ArgName, StringRef Arg,
1108  unsigned long long &Val);
1109 
1110  // getValueName - Overload in subclass to provide a better default value.
1111  StringRef getValueName() const override { return "ulong"; }
1112 
1113  void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
1114  size_t GlobalWidth) const;
1115 
1116  // An out-of-line virtual method to provide a 'home' for this class.
1117  void anchor() override;
1118 };
1119 
1120 //--------------------------------------------------
1121 // parser<double>
1122 //
1123 
1124 extern template class basic_parser<double>;
1125 
1126 template <> class parser<double> : public basic_parser<double> {
1127 public:
1129 
1130  // parse - Return true on error.
1131  bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
1132 
1133  // getValueName - Overload in subclass to provide a better default value.
1134  StringRef getValueName() const override { return "number"; }
1135 
1136  void printOptionDiff(const Option &O, double V, OptVal Default,
1137  size_t GlobalWidth) const;
1138 
1139  // An out-of-line virtual method to provide a 'home' for this class.
1140  void anchor() override;
1141 };
1142 
1143 //--------------------------------------------------
1144 // parser<float>
1145 //
1146 
1147 extern template class basic_parser<float>;
1148 
1149 template <> class parser<float> : public basic_parser<float> {
1150 public:
1152 
1153  // parse - Return true on error.
1154  bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
1155 
1156  // getValueName - Overload in subclass to provide a better default value.
1157  StringRef getValueName() const override { return "number"; }
1158 
1159  void printOptionDiff(const Option &O, float V, OptVal Default,
1160  size_t GlobalWidth) const;
1161 
1162  // An out-of-line virtual method to provide a 'home' for this class.
1163  void anchor() override;
1164 };
1165 
1166 //--------------------------------------------------
1167 // parser<std::string>
1168 //
1169 
1170 extern template class basic_parser<std::string>;
1171 
1173 public:
1175 
1176  // parse - Return true on error.
1177  bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
1178  Value = Arg.str();
1179  return false;
1180  }
1181 
1182  // getValueName - Overload in subclass to provide a better default value.
1183  StringRef getValueName() const override { return "string"; }
1184 
1185  void printOptionDiff(const Option &O, StringRef V, const OptVal &Default,
1186  size_t GlobalWidth) const;
1187 
1188  // An out-of-line virtual method to provide a 'home' for this class.
1189  void anchor() override;
1190 };
1191 
1192 //--------------------------------------------------
1193 // parser<char>
1194 //
1195 
1196 extern template class basic_parser<char>;
1197 
1198 template <> class parser<char> : public basic_parser<char> {
1199 public:
1201 
1202  // parse - Return true on error.
1204  Value = Arg[0];
1205  return false;
1206  }
1207 
1208  // getValueName - Overload in subclass to provide a better default value.
1209  StringRef getValueName() const override { return "char"; }
1210 
1211  void printOptionDiff(const Option &O, char V, OptVal Default,
1212  size_t GlobalWidth) const;
1213 
1214  // An out-of-line virtual method to provide a 'home' for this class.
1215  void anchor() override;
1216 };
1217 
1218 //--------------------------------------------------
1219 // PrintOptionDiff
1220 //
1221 // This collection of wrappers is the intermediary between class opt and class
1222 // parser to handle all the template nastiness.
1223 
1224 // This overloaded function is selected by the generic parser.
1225 template <class ParserClass, class DT>
1226 void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
1227  const OptionValue<DT> &Default, size_t GlobalWidth) {
1228  OptionValue<DT> OV = V;
1229  P.printOptionDiff(O, OV, Default, GlobalWidth);
1230 }
1231 
1232 // This is instantiated for basic parsers when the parsed value has a different
1233 // type than the option value. e.g. HelpPrinter.
1234 template <class ParserDT, class ValDT> struct OptionDiffPrinter {
1235  void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
1236  const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
1237  P.printOptionNoValue(O, GlobalWidth);
1238  }
1239 };
1240 
1241 // This is instantiated for basic parsers when the parsed value has the same
1242 // type as the option value.
1243 template <class DT> struct OptionDiffPrinter<DT, DT> {
1244  void print(const Option &O, const parser<DT> &P, const DT &V,
1245  const OptionValue<DT> &Default, size_t GlobalWidth) {
1246  P.printOptionDiff(O, V, Default, GlobalWidth);
1247  }
1248 };
1249 
1250 // This overloaded function is selected by the basic parser, which may parse a
1251 // different type than the option type.
1252 template <class ParserClass, class ValDT>
1254  const Option &O,
1256  const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {
1257 
1259  printer.print(O, static_cast<const ParserClass &>(P), V, Default,
1260  GlobalWidth);
1261 }
1262 
1263 //===----------------------------------------------------------------------===//
1264 // applicator class - This class is used because we must use partial
1265 // specialization to handle literal string arguments specially (const char* does
1266 // not correctly respond to the apply method). Because the syntax to use this
1267 // is a pain, we have the 'apply' method below to handle the nastiness...
1268 //
1269 template <class Mod> struct applicator {
1270  template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
1271 };
1272 
1273 // Handle const char* as a special case...
1274 template <unsigned n> struct applicator<char[n]> {
1275  template <class Opt> static void opt(StringRef Str, Opt &O) {
1276  O.setArgStr(Str);
1277  }
1278 };
1279 template <unsigned n> struct applicator<const char[n]> {
1280  template <class Opt> static void opt(StringRef Str, Opt &O) {
1281  O.setArgStr(Str);
1282  }
1283 };
1284 template <> struct applicator<StringRef > {
1285  template <class Opt> static void opt(StringRef Str, Opt &O) {
1286  O.setArgStr(Str);
1287  }
1288 };
1289 
1291  static void opt(NumOccurrencesFlag N, Option &O) {
1292  O.setNumOccurrencesFlag(N);
1293  }
1294 };
1295 
1296 template <> struct applicator<ValueExpected> {
1297  static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
1298 };
1299 
1300 template <> struct applicator<OptionHidden> {
1301  static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
1302 };
1303 
1304 template <> struct applicator<FormattingFlags> {
1305  static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
1306 };
1307 
1308 template <> struct applicator<MiscFlags> {
1309  static void opt(MiscFlags MF, Option &O) {
1310  assert((MF != Grouping || O.ArgStr.size() == 1) &&
1311  "cl::Grouping can only apply to single charater Options.");
1312  O.setMiscFlag(MF);
1313  }
1314 };
1315 
1316 // apply method - Apply modifiers to an option in a type safe way.
1317 template <class Opt, class Mod, class... Mods>
1318 void apply(Opt *O, const Mod &M, const Mods &... Ms) {
1320  apply(O, Ms...);
1321 }
1322 
1323 template <class Opt, class Mod> void apply(Opt *O, const Mod &M) {
1325 }
1326 
1327 //===----------------------------------------------------------------------===//
1328 // opt_storage class
1329 
1330 // Default storage class definition: external storage. This implementation
1331 // assumes the user will specify a variable to store the data into with the
1332 // cl::location(x) modifier.
1333 //
1334 template <class DataType, bool ExternalStorage, bool isClass>
1336  DataType *Location = nullptr; // Where to store the object...
1337  OptionValue<DataType> Default;
1338 
1339  void check_location() const {
1340  assert(Location && "cl::location(...) not specified for a command "
1341  "line option with external storage, "
1342  "or cl::init specified before cl::location()!!");
1343  }
1344 
1345 public:
1346  opt_storage() = default;
1347 
1348  bool setLocation(Option &O, DataType &L) {
1349  if (Location)
1350  return O.error("cl::location(x) specified more than once!");
1351  Location = &L;
1352  Default = L;
1353  return false;
1354  }
1355 
1356  template <class T> void setValue(const T &V, bool initial = false) {
1357  check_location();
1358  *Location = V;
1359  if (initial)
1360  Default = V;
1361  }
1362 
1363  DataType &getValue() {
1364  check_location();
1365  return *Location;
1366  }
1367  const DataType &getValue() const {
1368  check_location();
1369  return *Location;
1370  }
1371 
1372  operator DataType() const { return this->getValue(); }
1373 
1374  const OptionValue<DataType> &getDefault() const { return Default; }
1375 };
1376 
1377 // Define how to hold a class type object, such as a string. Since we can
1378 // inherit from a class, we do so. This makes us exactly compatible with the
1379 // object in all cases that it is used.
1380 //
1381 template <class DataType>
1382 class opt_storage<DataType, false, true> : public DataType {
1383 public:
1385 
1386  template <class T> void setValue(const T &V, bool initial = false) {
1387  DataType::operator=(V);
1388  if (initial)
1389  Default = V;
1390  }
1391 
1392  DataType &getValue() { return *this; }
1393  const DataType &getValue() const { return *this; }
1394 
1395  const OptionValue<DataType> &getDefault() const { return Default; }
1396 };
1397 
1398 // Define a partial specialization to handle things we cannot inherit from. In
1399 // this case, we store an instance through containment, and overload operators
1400 // to get at the value.
1401 //
1402 template <class DataType> class opt_storage<DataType, false, false> {
1403 public:
1404  DataType Value;
1406 
1407  // Make sure we initialize the value with the default constructor for the
1408  // type.
1409  opt_storage() : Value(DataType()), Default(DataType()) {}
1410 
1411  template <class T> void setValue(const T &V, bool initial = false) {
1412  Value = V;
1413  if (initial)
1414  Default = V;
1415  }
1416  DataType &getValue() { return Value; }
1417  DataType getValue() const { return Value; }
1418 
1419  const OptionValue<DataType> &getDefault() const { return Default; }
1420 
1421  operator DataType() const { return getValue(); }
1422 
1423  // If the datatype is a pointer, support -> on it.
1424  DataType operator->() const { return Value; }
1425 };
1426 
1427 //===----------------------------------------------------------------------===//
1428 // opt - A scalar command line option.
1429 //
1430 template <class DataType, bool ExternalStorage = false,
1431  class ParserClass = parser<DataType>>
1432 class opt : public Option,
1433  public opt_storage<DataType, ExternalStorage,
1434  std::is_class<DataType>::value> {
1435  ParserClass Parser;
1436 
1437  bool handleOccurrence(unsigned pos, StringRef ArgName,
1438  StringRef Arg) override {
1439  typename ParserClass::parser_data_type Val =
1440  typename ParserClass::parser_data_type();
1441  if (Parser.parse(*this, ArgName, Arg, Val))
1442  return true; // Parse error!
1443  this->setValue(Val);
1444  this->setPosition(pos);
1445  Callback(Val);
1446  return false;
1447  }
1448 
1449  enum ValueExpected getValueExpectedFlagDefault() const override {
1450  return Parser.getValueExpectedFlagDefault();
1451  }
1452 
1453  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1454  return Parser.getExtraOptionNames(OptionNames);
1455  }
1456 
1457  // Forward printing stuff to the parser...
1458  size_t getOptionWidth() const override {
1459  return Parser.getOptionWidth(*this);
1460  }
1461 
1462  void printOptionInfo(size_t GlobalWidth) const override {
1463  Parser.printOptionInfo(*this, GlobalWidth);
1464  }
1465 
1466  void printOptionValue(size_t GlobalWidth, bool Force) const override {
1467  if (Force || this->getDefault().compare(this->getValue())) {
1468  cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
1469  this->getDefault(), GlobalWidth);
1470  }
1471  }
1472 
1473  template <class T,
1474  class = std::enable_if_t<std::is_assignable<T &, T>::value>>
1475  void setDefaultImpl() {
1476  const OptionValue<DataType> &V = this->getDefault();
1477  if (V.hasValue())
1478  this->setValue(V.getValue());
1479  }
1480 
1481  template <class T,
1482  class = std::enable_if_t<!std::is_assignable<T &, T>::value>>
1483  void setDefaultImpl(...) {}
1484 
1485  void setDefault() override { setDefaultImpl<DataType>(); }
1486 
1487  void done() {
1488  addArgument();
1489  Parser.initialize();
1490  }
1491 
1492 public:
1493  // Command line options should not be copyable
1494  opt(const opt &) = delete;
1495  opt &operator=(const opt &) = delete;
1496 
1497  // setInitialValue - Used by the cl::init modifier...
1498  void setInitialValue(const DataType &V) { this->setValue(V, true); }
1499 
1500  ParserClass &getParser() { return Parser; }
1501 
1502  template <class T> DataType &operator=(const T &Val) {
1503  this->setValue(Val);
1504  Callback(Val);
1505  return this->getValue();
1506  }
1507 
1508  template <class... Mods>
1509  explicit opt(const Mods &... Ms)
1510  : Option(llvm::cl::Optional, NotHidden), Parser(*this) {
1511  apply(this, Ms...);
1512  done();
1513  }
1514 
1516  std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1517  Callback = CB;
1518  }
1519 
1520  std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1521  [](const typename ParserClass::parser_data_type &) {};
1522 };
1523 
1524 extern template class opt<unsigned>;
1525 extern template class opt<int>;
1526 extern template class opt<std::string>;
1527 extern template class opt<char>;
1528 extern template class opt<bool>;
1529 
1530 //===----------------------------------------------------------------------===//
1531 // list_storage class
1532 
1533 // Default storage class definition: external storage. This implementation
1534 // assumes the user will specify a variable to store the data into with the
1535 // cl::location(x) modifier.
1536 //
1537 template <class DataType, class StorageClass> class list_storage {
1538  StorageClass *Location = nullptr; // Where to store the object...
1539 
1540 public:
1541  list_storage() = default;
1542 
1543  void clear() {}
1544 
1546  if (Location)
1547  return O.error("cl::location(x) specified more than once!");
1548  Location = &L;
1549  return false;
1550  }
1551 
1552  template <class T> void addValue(const T &V) {
1553  assert(Location != 0 && "cl::location(...) not specified for a command "
1554  "line option with external storage!");
1555  Location->push_back(V);
1556  }
1557 };
1558 
1559 // Define how to hold a class type object, such as a string.
1560 // Originally this code inherited from std::vector. In transitioning to a new
1561 // API for command line options we should change this. The new implementation
1562 // of this list_storage specialization implements the minimum subset of the
1563 // std::vector API required for all the current clients.
1564 //
1565 // FIXME: Reduce this API to a more narrow subset of std::vector
1566 //
1567 template <class DataType> class list_storage<DataType, bool> {
1568  std::vector<DataType> Storage;
1569 
1570 public:
1571  using iterator = typename std::vector<DataType>::iterator;
1572 
1573  iterator begin() { return Storage.begin(); }
1574  iterator end() { return Storage.end(); }
1575 
1576  using const_iterator = typename std::vector<DataType>::const_iterator;
1577 
1578  const_iterator begin() const { return Storage.begin(); }
1579  const_iterator end() const { return Storage.end(); }
1580 
1581  using size_type = typename std::vector<DataType>::size_type;
1582 
1583  size_type size() const { return Storage.size(); }
1584 
1585  bool empty() const { return Storage.empty(); }
1586 
1587  void push_back(const DataType &value) { Storage.push_back(value); }
1588  void push_back(DataType &&value) { Storage.push_back(value); }
1589 
1590  using reference = typename std::vector<DataType>::reference;
1591  using const_reference = typename std::vector<DataType>::const_reference;
1592 
1593  reference operator[](size_type pos) { return Storage[pos]; }
1594  const_reference operator[](size_type pos) const { return Storage[pos]; }
1595 
1596  void clear() {
1597  Storage.clear();
1598  }
1599 
1600  iterator erase(const_iterator pos) { return Storage.erase(pos); }
1602  return Storage.erase(first, last);
1603  }
1604 
1605  iterator erase(iterator pos) { return Storage.erase(pos); }
1607  return Storage.erase(first, last);
1608  }
1609 
1610  iterator insert(const_iterator pos, const DataType &value) {
1611  return Storage.insert(pos, value);
1612  }
1613  iterator insert(const_iterator pos, DataType &&value) {
1614  return Storage.insert(pos, value);
1615  }
1616 
1617  iterator insert(iterator pos, const DataType &value) {
1618  return Storage.insert(pos, value);
1619  }
1620  iterator insert(iterator pos, DataType &&value) {
1621  return Storage.insert(pos, value);
1622  }
1623 
1624  reference front() { return Storage.front(); }
1625  const_reference front() const { return Storage.front(); }
1626 
1627  operator std::vector<DataType> &() { return Storage; }
1628  operator ArrayRef<DataType>() const { return Storage; }
1629  std::vector<DataType> *operator&() { return &Storage; }
1630  const std::vector<DataType> *operator&() const { return &Storage; }
1631 
1632  template <class T> void addValue(const T &V) { Storage.push_back(V); }
1633 };
1634 
1635 //===----------------------------------------------------------------------===//
1636 // list - A list of command line options.
1637 //
1638 template <class DataType, class StorageClass = bool,
1639  class ParserClass = parser<DataType>>
1640 class list : public Option, public list_storage<DataType, StorageClass> {
1641  std::vector<unsigned> Positions;
1642  ParserClass Parser;
1643 
1644  enum ValueExpected getValueExpectedFlagDefault() const override {
1645  return Parser.getValueExpectedFlagDefault();
1646  }
1647 
1648  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1649  return Parser.getExtraOptionNames(OptionNames);
1650  }
1651 
1652  bool handleOccurrence(unsigned pos, StringRef ArgName,
1653  StringRef Arg) override {
1654  typename ParserClass::parser_data_type Val =
1655  typename ParserClass::parser_data_type();
1656  if (Parser.parse(*this, ArgName, Arg, Val))
1657  return true; // Parse Error!
1659  setPosition(pos);
1660  Positions.push_back(pos);
1661  Callback(Val);
1662  return false;
1663  }
1664 
1665  // Forward printing stuff to the parser...
1666  size_t getOptionWidth() const override {
1667  return Parser.getOptionWidth(*this);
1668  }
1669 
1670  void printOptionInfo(size_t GlobalWidth) const override {
1671  Parser.printOptionInfo(*this, GlobalWidth);
1672  }
1673 
1674  // Unimplemented: list options don't currently store their default value.
1675  void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1676  }
1677 
1678  void setDefault() override {
1679  Positions.clear();
1681  }
1682 
1683  void done() {
1684  addArgument();
1685  Parser.initialize();
1686  }
1687 
1688 public:
1689  // Command line options should not be copyable
1690  list(const list &) = delete;
1691  list &operator=(const list &) = delete;
1692 
1693  ParserClass &getParser() { return Parser; }
1694 
1695  unsigned getPosition(unsigned optnum) const {
1696  assert(optnum < this->size() && "Invalid option index");
1697  return Positions[optnum];
1698  }
1699 
1701 
1702  template <class... Mods>
1703  explicit list(const Mods &... Ms)
1704  : Option(ZeroOrMore, NotHidden), Parser(*this) {
1705  apply(this, Ms...);
1706  done();
1707  }
1708 
1710  std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1711  Callback = CB;
1712  }
1713 
1714  std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1715  [](const typename ParserClass::parser_data_type &) {};
1716 };
1717 
1718 // multi_val - Modifier to set the number of additional values.
1719 struct multi_val {
1720  unsigned AdditionalVals;
1721  explicit multi_val(unsigned N) : AdditionalVals(N) {}
1722 
1723  template <typename D, typename S, typename P>
1724  void apply(list<D, S, P> &L) const {
1726  }
1727 };
1728 
1729 //===----------------------------------------------------------------------===//
1730 // bits_storage class
1731 
1732 // Default storage class definition: external storage. This implementation
1733 // assumes the user will specify a variable to store the data into with the
1734 // cl::location(x) modifier.
1735 //
1736 template <class DataType, class StorageClass> class bits_storage {
1737  unsigned *Location = nullptr; // Where to store the bits...
1738 
1739  template <class T> static unsigned Bit(const T &V) {
1740  unsigned BitPos = reinterpret_cast<unsigned>(V);
1741  assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1742  "enum exceeds width of bit vector!");
1743  return 1 << BitPos;
1744  }
1745 
1746 public:
1747  bits_storage() = default;
1748 
1749  bool setLocation(Option &O, unsigned &L) {
1750  if (Location)
1751  return O.error("cl::location(x) specified more than once!");
1752  Location = &L;
1753  return false;
1754  }
1755 
1756  template <class T> void addValue(const T &V) {
1757  assert(Location != 0 && "cl::location(...) not specified for a command "
1758  "line option with external storage!");
1759  *Location |= Bit(V);
1760  }
1761 
1762  unsigned getBits() { return *Location; }
1763 
1764  template <class T> bool isSet(const T &V) {
1765  return (*Location & Bit(V)) != 0;
1766  }
1767 };
1768 
1769 // Define how to hold bits. Since we can inherit from a class, we do so.
1770 // This makes us exactly compatible with the bits in all cases that it is used.
1771 //
1772 template <class DataType> class bits_storage<DataType, bool> {
1773  unsigned Bits; // Where to store the bits...
1774 
1775  template <class T> static unsigned Bit(const T &V) {
1776  unsigned BitPos = (unsigned)V;
1777  assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
1778  "enum exceeds width of bit vector!");
1779  return 1 << BitPos;
1780  }
1781 
1782 public:
1783  template <class T> void addValue(const T &V) { Bits |= Bit(V); }
1784 
1785  unsigned getBits() { return Bits; }
1786 
1787  template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
1788 };
1789 
1790 //===----------------------------------------------------------------------===//
1791 // bits - A bit vector of command options.
1792 //
1793 template <class DataType, class Storage = bool,
1794  class ParserClass = parser<DataType>>
1795 class bits : public Option, public bits_storage<DataType, Storage> {
1796  std::vector<unsigned> Positions;
1797  ParserClass Parser;
1798 
1799  enum ValueExpected getValueExpectedFlagDefault() const override {
1800  return Parser.getValueExpectedFlagDefault();
1801  }
1802 
1803  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
1804  return Parser.getExtraOptionNames(OptionNames);
1805  }
1806 
1807  bool handleOccurrence(unsigned pos, StringRef ArgName,
1808  StringRef Arg) override {
1809  typename ParserClass::parser_data_type Val =
1810  typename ParserClass::parser_data_type();
1811  if (Parser.parse(*this, ArgName, Arg, Val))
1812  return true; // Parse Error!
1813  this->addValue(Val);
1814  setPosition(pos);
1815  Positions.push_back(pos);
1816  Callback(Val);
1817  return false;
1818  }
1819 
1820  // Forward printing stuff to the parser...
1821  size_t getOptionWidth() const override {
1822  return Parser.getOptionWidth(*this);
1823  }
1824 
1825  void printOptionInfo(size_t GlobalWidth) const override {
1826  Parser.printOptionInfo(*this, GlobalWidth);
1827  }
1828 
1829  // Unimplemented: bits options don't currently store their default values.
1830  void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1831  }
1832 
1833  void setDefault() override {}
1834 
1835  void done() {
1836  addArgument();
1837  Parser.initialize();
1838  }
1839 
1840 public:
1841  // Command line options should not be copyable
1842  bits(const bits &) = delete;
1843  bits &operator=(const bits &) = delete;
1844 
1845  ParserClass &getParser() { return Parser; }
1846 
1847  unsigned getPosition(unsigned optnum) const {
1848  assert(optnum < this->size() && "Invalid option index");
1849  return Positions[optnum];
1850  }
1851 
1852  template <class... Mods>
1853  explicit bits(const Mods &... Ms)
1854  : Option(ZeroOrMore, NotHidden), Parser(*this) {
1855  apply(this, Ms...);
1856  done();
1857  }
1858 
1860  std::function<void(const typename ParserClass::parser_data_type &)> CB) {
1861  Callback = CB;
1862  }
1863 
1864  std::function<void(const typename ParserClass::parser_data_type &)> Callback =
1865  [](const typename ParserClass::parser_data_type &) {};
1866 };
1867 
1868 //===----------------------------------------------------------------------===//
1869 // Aliased command line option (alias this name to a preexisting name)
1870 //
1871 
1872 class alias : public Option {
1873  Option *AliasFor;
1874 
1875  bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
1876  StringRef Arg) override {
1877  return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
1878  }
1879 
1880  bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
1881  bool MultiArg = false) override {
1882  return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
1883  }
1884 
1885  // Handle printing stuff...
1886  size_t getOptionWidth() const override;
1887  void printOptionInfo(size_t GlobalWidth) const override;
1888 
1889  // Aliases do not need to print their values.
1890  void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
1891  }
1892 
1893  void setDefault() override { AliasFor->setDefault(); }
1894 
1895  ValueExpected getValueExpectedFlagDefault() const override {
1896  return AliasFor->getValueExpectedFlag();
1897  }
1898 
1899  void done() {
1900  if (!hasArgStr())
1901  error("cl::alias must have argument name specified!");
1902  if (!AliasFor)
1903  error("cl::alias must have an cl::aliasopt(option) specified!");
1904  if (!Subs.empty())
1905  error("cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!");
1906  Subs = AliasFor->Subs;
1907  Categories = AliasFor->Categories;
1908  addArgument();
1909  }
1910 
1911 public:
1912  // Command line options should not be copyable
1913  alias(const alias &) = delete;
1914  alias &operator=(const alias &) = delete;
1915 
1917  if (AliasFor)
1918  error("cl::alias must only have one cl::aliasopt(...) specified!");
1919  AliasFor = &O;
1920  }
1921 
1922  template <class... Mods>
1923  explicit alias(const Mods &... Ms)
1924  : Option(Optional, Hidden), AliasFor(nullptr) {
1925  apply(this, Ms...);
1926  done();
1927  }
1928 };
1929 
1930 // aliasfor - Modifier to set the option an alias aliases.
1931 struct aliasopt {
1933 
1934  explicit aliasopt(Option &O) : Opt(O) {}
1935 
1936  void apply(alias &A) const { A.setAliasFor(Opt); }
1937 };
1938 
1939 // extrahelp - provide additional help at the end of the normal help
1940 // output. All occurrences of cl::extrahelp will be accumulated and
1941 // printed to stderr at the end of the regular help, just before
1942 // exit is called.
1943 struct extrahelp {
1945 
1946  explicit extrahelp(StringRef help);
1947 };
1948 
1949 void PrintVersionMessage();
1950 
1951 /// This function just prints the help message, exactly the same way as if the
1952 /// -help or -help-hidden option had been given on the command line.
1953 ///
1954 /// \param Hidden if true will print hidden options
1955 /// \param Categorized if true print options in categories
1956 void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
1957 
1958 //===----------------------------------------------------------------------===//
1959 // Public interface for accessing registered options.
1960 //
1961 
1962 /// Use this to get a StringMap to all registered named options
1963 /// (e.g. -help).
1964 ///
1965 /// \return A reference to the StringMap used by the cl APIs to parse options.
1966 ///
1967 /// Access to unnamed arguments (i.e. positional) are not provided because
1968 /// it is expected that the client already has access to these.
1969 ///
1970 /// Typical usage:
1971 /// \code
1972 /// main(int argc,char* argv[]) {
1973 /// StringMap<llvm::cl::Option*> &opts = llvm::cl::getRegisteredOptions();
1974 /// assert(opts.count("help") == 1)
1975 /// opts["help"]->setDescription("Show alphabetical help information")
1976 /// // More code
1977 /// llvm::cl::ParseCommandLineOptions(argc,argv);
1978 /// //More code
1979 /// }
1980 /// \endcode
1981 ///
1982 /// This interface is useful for modifying options in libraries that are out of
1983 /// the control of the client. The options should be modified before calling
1984 /// llvm::cl::ParseCommandLineOptions().
1985 ///
1986 /// Hopefully this API can be deprecated soon. Any situation where options need
1987 /// to be modified by tools or libraries should be handled by sane APIs rather
1988 /// than just handing around a global list.
1990 
1991 /// Use this to get all registered SubCommands from the provided parser.
1992 ///
1993 /// \return A range of all SubCommand pointers registered with the parser.
1994 ///
1995 /// Typical usage:
1996 /// \code
1997 /// main(int argc, char* argv[]) {
1998 /// llvm::cl::ParseCommandLineOptions(argc, argv);
1999 /// for (auto* S : llvm::cl::getRegisteredSubcommands()) {
2000 /// if (*S) {
2001 /// std::cout << "Executing subcommand: " << S->getName() << std::endl;
2002 /// // Execute some function based on the name...
2003 /// }
2004 /// }
2005 /// }
2006 /// \endcode
2007 ///
2008 /// This interface is useful for defining subcommands in libraries and
2009 /// the dispatch from a single point (like in the main function).
2012 
2013 //===----------------------------------------------------------------------===//
2014 // Standalone command line processing utilities.
2015 //
2016 
2017 /// Tokenizes a command line that can contain escapes and quotes.
2018 //
2019 /// The quoting rules match those used by GCC and other tools that use
2020 /// libiberty's buildargv() or expandargv() utilities, and do not match bash.
2021 /// They differ from buildargv() on treatment of backslashes that do not escape
2022 /// a special character to make it possible to accept most Windows file paths.
2023 ///
2024 /// \param [in] Source The string to be split on whitespace with quotes.
2025 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
2026 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
2027 /// lines and end of the response file to be marked with a nullptr string.
2028 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
2031  bool MarkEOLs = false);
2032 
2033 /// Tokenizes a Windows command line which may contain quotes and escaped
2034 /// quotes.
2035 ///
2036 /// See MSDN docs for CommandLineToArgvW for information on the quoting rules.
2037 /// http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx
2038 ///
2039 /// \param [in] Source The string to be split on whitespace with quotes.
2040 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
2041 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
2042 /// lines and end of the response file to be marked with a nullptr string.
2043 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
2046  bool MarkEOLs = false);
2047 
2048 /// Tokenizes a Windows command line while attempting to avoid copies. If no
2049 /// quoting or escaping was used, this produces substrings of the original
2050 /// string. If a token requires unquoting, it will be allocated with the
2051 /// StringSaver.
2053  SmallVectorImpl<StringRef> &NewArgv);
2054 
2055 /// String tokenization function type. Should be compatible with either
2056 /// Windows or Unix command line tokenizers.
2057 using TokenizerCallback = void (*)(StringRef Source, StringSaver &Saver,
2059  bool MarkEOLs);
2060 
2061 /// Tokenizes content of configuration file.
2062 ///
2063 /// \param [in] Source The string representing content of config file.
2064 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
2065 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
2066 /// \param [in] MarkEOLs Added for compatibility with TokenizerCallback.
2067 ///
2068 /// It works like TokenizeGNUCommandLine with ability to skip comment lines.
2069 ///
2072  bool MarkEOLs = false);
2073 
2074 /// Reads command line options from the given configuration file.
2075 ///
2076 /// \param [in] CfgFileName Path to configuration file.
2077 /// \param [in] Saver Objects that saves allocated strings.
2078 /// \param [out] Argv Array to which the read options are added.
2079 /// \return true if the file was successfully read.
2080 ///
2081 /// It reads content of the specified file, tokenizes it and expands "@file"
2082 /// commands resolving file names in them relative to the directory where
2083 /// CfgFilename resides.
2084 ///
2085 bool readConfigFile(StringRef CfgFileName, StringSaver &Saver,
2087 
2088 /// Expand response files on a command line recursively using the given
2089 /// StringSaver and tokenization strategy. Argv should contain the command line
2090 /// before expansion and will be modified in place. If requested, Argv will
2091 /// also be populated with nullptrs indicating where each response file line
2092 /// ends, which is useful for the "/link" argument that needs to consume all
2093 /// remaining arguments only until the next end of line, when in a response
2094 /// file.
2095 ///
2096 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
2097 /// \param [in] Tokenizer Tokenization strategy. Typically Unix or Windows.
2098 /// \param [in,out] Argv Command line into which to expand response files.
2099 /// \param [in] MarkEOLs Mark end of lines and the end of the response file
2100 /// with nullptrs in the Argv vector.
2101 /// \param [in] RelativeNames true if names of nested response files must be
2102 /// resolved relative to including file.
2103 /// \param [in] FS File system used for all file access when running the tool.
2104 /// \param [in] CurrentDir Path used to resolve relative rsp files. If set to
2105 /// None, process' cwd is used instead.
2106 /// \return true if all @files were expanded successfully or there were none.
2107 bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
2108  SmallVectorImpl<const char *> &Argv, bool MarkEOLs,
2109  bool RelativeNames,
2112 
2113 /// An overload of ExpandResponseFiles() that uses
2114 /// llvm::vfs::getRealFileSystem().
2115 bool ExpandResponseFiles(
2116  StringSaver &Saver, TokenizerCallback Tokenizer,
2117  SmallVectorImpl<const char *> &Argv, bool MarkEOLs = false,
2118  bool RelativeNames = false,
2120 
2121 /// A convenience helper which concatenates the options specified by the
2122 /// environment variable EnvVar and command line options, then expands response
2123 /// files recursively. The tokenizer is a predefined GNU or Windows one.
2124 /// \return true if all @files were expanded successfully or there were none.
2125 bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
2126  StringSaver &Saver,
2128 
2129 /// Mark all options not part of this category as cl::ReallyHidden.
2130 ///
2131 /// \param Category the category of options to keep displaying
2132 ///
2133 /// Some tools (like clang-format) like to be able to hide all options that are
2134 /// not specific to the tool. This function allows a tool to specify a single
2135 /// option category to display in the -help output.
2137  SubCommand &Sub = *TopLevelSubCommand);
2138 
2139 /// Mark all options not part of the categories as cl::ReallyHidden.
2140 ///
2141 /// \param Categories the categories of options to keep displaying.
2142 ///
2143 /// Some tools (like clang-format) like to be able to hide all options that are
2144 /// not specific to the tool. This function allows a tool to specify a single
2145 /// option category to display in the -help output.
2147  SubCommand &Sub = *TopLevelSubCommand);
2148 
2149 /// Reset all command line options to a state that looks as if they have
2150 /// never appeared on the command line. This is useful for being able to parse
2151 /// a command line multiple times (especially useful for writing tests).
2153 
2154 /// Reset the command line parser back to its initial state. This
2155 /// removes
2156 /// all options, categories, and subcommands and returns the parser to a state
2157 /// where no options are supported.
2158 void ResetCommandLineParser();
2159 
2160 /// Parses `Arg` into the option handler `Handler`.
2161 bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
2162 
2163 } // end namespace cl
2164 
2165 } // end namespace llvm
2166 
2167 #endif // LLVM_SUPPORT_COMMANDLINE_H
llvm::cl::MiscFlags
MiscFlags
Definition: CommandLine.h:168
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
llvm::cl::basic_parser_impl::getExtraOptionNames
void getExtraOptionNames(SmallVectorImpl< StringRef > &)
Definition: CommandLine.h:886
llvm::cl::Option::getPosition
unsigned getPosition() const
Definition: CommandLine.h:305
llvm::cl::AddExtraVersionPrinter
void AddExtraVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// AddExtraVersionPrinter - ...
Definition: CommandLine.cpp:2639
llvm::cl::generic_parser_base
Definition: CommandLine.h:713
llvm::cl::SubCommand::reset
void reset()
Definition: CommandLine.cpp:503
llvm::cl::DefaultOption
@ DefaultOption
Definition: CommandLine.h:180
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::value_desc::Desc
StringRef Desc
Definition: CommandLine.h:423
llvm::cl::cb::apply
void apply(Opt &O) const
Definition: CommandLine.h:487
llvm::cl::opt_storage< DataType, false, true >::getDefault
const OptionValue< DataType > & getDefault() const
Definition: CommandLine.h:1395
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 is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::cl::list_storage< DataType, bool >::erase
iterator erase(iterator first, iterator last)
Definition: CommandLine.h:1606
llvm::cl::OptionDiffPrinter< DT, DT >::print
void print(const Option &O, const parser< DT > &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
Definition: CommandLine.h:1244
llvm::cl::parser::getDescription
StringRef getDescription(unsigned N) const override
Definition: CommandLine.h:828
llvm::cl::SubCommand::OptionsMap
StringMap< Option * > OptionsMap
Definition: CommandLine.h:235
llvm::cl::list::list
list(const list &)=delete
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::cl::aliasopt::aliasopt
aliasopt(Option &O)
Definition: CommandLine.h:1934
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
llvm::cl::Option::Categories
SmallVector< OptionCategory *, 1 > Categories
Definition: CommandLine.h:285
Optional.h
llvm::cl::parser::getNumOptions
unsigned getNumOptions() const override
Definition: CommandLine.h:826
llvm::cl::opt::operator=
DataType & operator=(const T &Val)
Definition: CommandLine.h:1502
llvm::cl::basic_parser_impl::getValueExpectedFlagDefault
enum ValueExpected getValueExpectedFlagDefault() const
Definition: CommandLine.h:882
llvm::X86AS::FS
@ FS
Definition: X86.h:188
llvm::cl::opt_storage< DataType, false, false >::operator->
DataType operator->() const
Definition: CommandLine.h:1424
llvm::cl::basic_parser_impl::anchor
virtual void anchor()
Definition: CommandLine.cpp:86
llvm::cl::value_desc::apply
void apply(Option &O) const
Definition: CommandLine.h:427
llvm::cl::cat::Category
OptionCategory & Category
Definition: CommandLine.h:464
llvm::cl::alias::alias
alias(const Mods &... Ms)
Definition: CommandLine.h:1923
llvm::cl::desc::desc
desc(StringRef Str)
Definition: CommandLine.h:415
llvm::cl::list_storage< DataType, bool >::reference
typename std::vector< DataType >::reference reference
Definition: CommandLine.h:1590
llvm::cl::parser< unsigned long long >::parser
parser(Option &O)
Definition: CommandLine.h:1104
llvm::cl::parser< unsigned long long >
Definition: CommandLine.h:1102
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::cl::OptionHidden
OptionHidden
Definition: CommandLine.h:141
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::parser::OptionInfo::OptionInfo
OptionInfo(StringRef name, DataType v, StringRef helpStr)
Definition: CommandLine.h:813
llvm::cl::opt_storage< DataType, false, false >::getValue
DataType & getValue()
Definition: CommandLine.h:1416
llvm::cl::location
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:457
llvm::cl::list_storage< DataType, bool >::operator&
std::vector< DataType > * operator&()
Definition: CommandLine.h:1629
llvm::cl::Option::getOptionHiddenFlag
enum OptionHidden getOptionHiddenFlag() const
Definition: CommandLine.h:296
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
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::parser< boolOrDefault >
Definition: CommandLine.h:958
llvm::cl::bits_storage::addValue
void addValue(const T &V)
Definition: CommandLine.h:1756
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::cl::applicator< StringRef >::opt
static void opt(StringRef Str, Opt &O)
Definition: CommandLine.h:1285
llvm::cl::list::operator=
list & operator=(const list &)=delete
llvm::cl::list_storage< DataType, bool >::const_iterator
typename std::vector< DataType >::const_iterator const_iterator
Definition: CommandLine.h:1576
llvm::cl::parser< bool >::initialize
void initialize()
Definition: CommandLine.h:937
llvm::cl::opt::getParser
ParserClass & getParser()
Definition: CommandLine.h:1500
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::list_storage< DataType, bool >::insert
iterator insert(const_iterator pos, DataType &&value)
Definition: CommandLine.h:1613
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::initializer::Init
const Ty & Init
Definition: CommandLine.h:435
llvm::cl::Option::error
bool error(const Twine &Message, StringRef ArgName=StringRef(), raw_ostream &Errs=llvm::errs())
Definition: CommandLine.cpp:1684
llvm::cl::basic_parser_impl::initialize
void initialize()
Definition: CommandLine.h:888
llvm::cl::OptionValueBase::WrapperType
OptionValue< DataType > WrapperType
Definition: CommandLine.h:540
llvm::cl::bits_storage
Definition: CommandLine.h:1736
llvm::cl::list_storage< DataType, bool >::size_type
typename std::vector< DataType >::size_type size_type
Definition: CommandLine.h:1581
ErrorHandling.h
llvm::cl::list_storage< DataType, bool >::erase
iterator erase(iterator pos)
Definition: CommandLine.h:1605
llvm::cl::LocationClass
Definition: CommandLine.h:449
llvm::cl::CommaSeparated
@ CommaSeparated
Definition: CommandLine.h:169
llvm::cl::parser< unsigned long >
Definition: CommandLine.h:1078
llvm::cl::parser::parser
parser(Option &O)
Definition: CommandLine.h:821
ManagedStatic.h
llvm::cl::ValueOptional
@ ValueOptional
Definition: CommandLine.h:136
llvm::cl::multi_val::AdditionalVals
unsigned AdditionalVals
Definition: CommandLine.h:1720
llvm::cl::list_storage< DataType, bool >
Definition: CommandLine.h:1567
llvm::cl::ResetCommandLineParser
void ResetCommandLineParser()
Reset the command line parser back to its initial state.
Definition: CommandLine.cpp:2684
llvm::cl::cb
Definition: CommandLine.h:482
llvm::cl::Option::printOptionInfo
virtual void printOptionInfo(size_t GlobalWidth) const =0
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::cl::SubCommand::SubCommand
SubCommand(StringRef Name, StringRef Description="")
Definition: CommandLine.h:220
llvm::cl::printOptionDiff
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
Definition: CommandLine.h:1226
llvm::cl::parser< std::string >::parser
parser(Option &O)
Definition: CommandLine.h:1174
llvm::cl::parser< int >
Definition: CommandLine.h:985
llvm::cl::cb::cb
cb(std::function< R(Ty)> CB)
Definition: CommandLine.h:485
llvm::cl::OptionValueCopy::compare
bool compare(const GenericOptionValue &V) const override
Definition: CommandLine.h:586
llvm::cl::list_storage::addValue
void addValue(const T &V)
Definition: CommandLine.h:1552
llvm::cl::basic_parser_impl::basic_parser_impl
basic_parser_impl(Option &)
Definition: CommandLine.h:878
llvm::tgtok::Bits
@ Bits
Definition: TGLexer.h:50
llvm::cl::list_storage< DataType, bool >::clear
void clear()
Definition: CommandLine.h:1596
llvm::PassInfo
PassInfo class - An instance of this class exists for every pass known by the system,...
Definition: PassInfo.h:30
llvm::Optional
Definition: APInt.h:33
llvm::cl::Option::setMiscFlag
void setMiscFlag(enum MiscFlags M)
Definition: CommandLine.h:332
llvm::cl::list_storage< DataType, bool >::push_back
void push_back(DataType &&value)
Definition: CommandLine.h:1588
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::cl::GenericOptionValue
Definition: CommandLine.h:520
llvm::cl::opt::opt
opt(const Mods &... Ms)
Definition: CommandLine.h:1509
llvm::cl::bits_storage::bits_storage
bits_storage()=default
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::list::setCallback
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
Definition: CommandLine.h:1709
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::desc::apply
void apply(Option &O) const
Definition: CommandLine.h:417
llvm::cl::desc::Desc
StringRef Desc
Definition: CommandLine.h:413
llvm::cl::SubCommand::unregisterSubCommand
void unregisterSubCommand()
Definition: CommandLine.cpp:499
llvm::cl::OptionEnumValue::Value
int Value
Definition: CommandLine.h:666
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
llvm::cl::GenericOptionValue::GenericOptionValue
GenericOptionValue()=default
llvm::cl::VersionPrinterTy
std::function< void(raw_ostream &)> VersionPrinterTy
Definition: CommandLine.h:78
STLExtras.h
llvm::cl::cat::apply
void apply(Opt &O) const
Definition: CommandLine.h:468
llvm::cl::generic_parser_base::initialize
void initialize()
Definition: CommandLine.h:765
llvm::cl::parser< boolOrDefault >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:970
llvm::cl::bits::getPosition
unsigned getPosition(unsigned optnum) const
Definition: CommandLine.h:1847
llvm::cl::detail::callback_traits< R(C::*)(Args...) const >::arg_type
std::tuple_element_t< 0, std::tuple< Args... > > arg_type
Definition: CommandLine.h:497
llvm::cl::opt_storage::getValue
const DataType & getValue() const
Definition: CommandLine.h:1367
llvm::cl::ValueRequired
@ ValueRequired
Definition: CommandLine.h:137
llvm::cl::OptionValueCopy::hasValue
bool hasValue() const
Definition: CommandLine.h:572
llvm::cl::Option::printEnumValHelpStr
static void printEnumValHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
Definition: CommandLine.cpp:1749
llvm::cl::list_storage< DataType, bool >::erase
iterator erase(const_iterator pos)
Definition: CommandLine.h:1600
llvm::cl::ReallyHidden
@ ReallyHidden
Definition: CommandLine.h:144
llvm::cl::ValueExpected
ValueExpected
Definition: CommandLine.h:134
llvm::cl::initializer
Definition: CommandLine.h:434
llvm::cl::list_storage< DataType, bool >::end
iterator end()
Definition: CommandLine.h:1574
llvm::cl::OptionValue< cl::boolOrDefault >::operator=
OptionValue< cl::boolOrDefault > & operator=(const cl::boolOrDefault &V)
Definition: CommandLine.h:633
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:207
llvm::cl::generic_parser_base::printOptionInfo
virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const
Definition: CommandLine.cpp:1984
llvm::cl::Option::setValueExpectedFlag
void setValueExpectedFlag(enum ValueExpected Val)
Definition: CommandLine.h:329
llvm::cl::Option::hasArgStr
bool hasArgStr() const
Definition: CommandLine.h:309
llvm::cl::bits_storage::getBits
unsigned getBits()
Definition: CommandLine.h:1762
llvm::cl::parser< double >
Definition: CommandLine.h:1126
llvm::cl::generic_parser_base::GenericOptionInfo::GenericOptionInfo
GenericOptionInfo(StringRef name, StringRef helpStr)
Definition: CommandLine.h:717
llvm::cl::parser::getOptionValue
const GenericOptionValue & getOptionValue(unsigned N) const override
Definition: CommandLine.h:833
llvm::cl::applicator< NumOccurrencesFlag >
Definition: CommandLine.h:1290
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::cl::SubCommand::SubCommand
SubCommand()=default
llvm::cl::OptionValue::operator=
OptionValue< DataType > & operator=(const DT &V)
Definition: CommandLine.h:616
llvm::cl::sub::Sub
SubCommand & Sub
Definition: CommandLine.h:473
llvm::cl::OptionValueBase::setValue
void setValue(const DT &)
Definition: CommandLine.h:547
llvm::cl::basic_parser
Definition: CommandLine.h:916
llvm::cl::GenericOptionValue::~GenericOptionValue
~GenericOptionValue()=default
llvm::cl::apply
void apply(Opt *O, const Mod &M, const Mods &... Ms)
Definition: CommandLine.h:1318
llvm::cl::OptionEnumValue::Description
StringRef Description
Definition: CommandLine.h:667
llvm::AArch64CC::VC
@ VC
Definition: AArch64BaseInfo.h:262
llvm::cl::OptionValueCopy::~OptionValueCopy
~OptionValueCopy()=default
llvm::cl::generic_parser_base::findOption
unsigned findOption(StringRef Name)
Definition: CommandLine.cpp:1937
llvm::cl::parser::removeLiteralOption
void removeLiteralOption(StringRef Name)
removeLiteralOption - Remove the specified option.
Definition: CommandLine.h:866
llvm::cl::list_storage< DataType, bool >::end
const_iterator end() const
Definition: CommandLine.h:1579
llvm::cl::parser< double >::parser
parser(Option &O)
Definition: CommandLine.h:1128
llvm::cl::aliasopt
Definition: CommandLine.h:1931
llvm::cl::OptionValueCopy::compare
bool compare(const DataType &V) const
Definition: CommandLine.h:584
llvm::cl::OptionValueCopy::operator=
OptionValueCopy & operator=(const OptionValueCopy &)=default
llvm::cl::Option::getExtraOptionNames
virtual void getExtraOptionNames(SmallVectorImpl< StringRef > &)
Definition: CommandLine.h:389
llvm::cl::parser< unsigned >::parser
parser(Option &O)
Definition: CommandLine.h:1056
llvm::cl::Option::reset
void reset()
Definition: CommandLine.cpp:474
llvm::cl::OptionValueBase::compare
bool compare(const DataType &) const
Definition: CommandLine.h:549
llvm::cl::bits::operator=
bits & operator=(const bits &)=delete
llvm::cl::OptionDiffPrinter
Definition: CommandLine.h:1234
llvm::cl::opt_storage< DataType, false, false >::opt_storage
opt_storage()
Definition: CommandLine.h:1409
llvm::cl::applicator< char[n]>
Definition: CommandLine.h:1274
llvm::cl::parser< bool >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:944
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::sub::sub
sub(SubCommand &S)
Definition: CommandLine.h:475
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::cl::Option::setFormattingFlag
void setFormattingFlag(enum FormattingFlags V)
Definition: CommandLine.h:331
llvm::cl::PositionalEatsArgs
@ PositionalEatsArgs
Definition: CommandLine.h:170
llvm::cl::Option::getFormattingFlag
enum FormattingFlags getFormattingFlag() const
Definition: CommandLine.h:300
llvm::cl::parser< char >::parse
bool parse(Option &, StringRef, StringRef Arg, char &Value)
Definition: CommandLine.h:1203
llvm::cl::NotHidden
@ NotHidden
Definition: CommandLine.h:142
llvm::cl::NumOccurrencesFlag
NumOccurrencesFlag
Definition: CommandLine.h:118
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::cl::detail::callback_traits
Definition: CommandLine.h:492
llvm::cl::opt::operator=
opt & operator=(const opt &)=delete
llvm::ManagedStatic
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:83
llvm::cl::Option::isConsumeAfter
bool isConsumeAfter() const
Definition: CommandLine.h:314
llvm::cl::parser< boolOrDefault >::parser
parser(Option &O)
Definition: CommandLine.h:960
llvm::cl::generic_parser_base::getOption
virtual StringRef getOption(unsigned N) const =0
false
Definition: StackSlotColoring.cpp:142
llvm::cl::Positional
@ Positional
Definition: CommandLine.h:163
llvm::cl::ConsumeAfter
@ ConsumeAfter
Definition: CommandLine.h:131
llvm::cl::aliasopt::Opt
Option & Opt
Definition: CommandLine.h:1932
llvm::cl::parser< float >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1157
llvm::cl::OptionValueBase< DataType, false >::WrapperType
DataType WrapperType
Definition: CommandLine.h:598
llvm::cl::bits::Callback
std::function< void(const typename ParserClass::parser_data_type &)> Callback
Definition: CommandLine.h:1864
llvm::cl::generic_parser_base::getExtraOptionNames
void getExtraOptionNames(SmallVectorImpl< StringRef > &OptionNames)
Definition: CommandLine.h:767
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::cl::parser< long >::parser
parser(Option &O)
Definition: CommandLine.h:1010
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::cl::generic_parser_base::GenericOptionInfo
Definition: CommandLine.h:715
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::cl::Option::alias
friend class alias
Definition: CommandLine.h:250
llvm::cl::Option::getNumOccurrences
int getNumOccurrences() const
Definition: CommandLine.h:402
llvm::cl::applicator< FormattingFlags >
Definition: CommandLine.h:1304
llvm::cl::list_storage< DataType, bool >::addValue
void addValue(const T &V)
Definition: CommandLine.h:1632
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::cl::list_storage< DataType, bool >::begin
const_iterator begin() const
Definition: CommandLine.h:1578
SmallPtrSet.h
llvm::cl::OptionValueCopy
Definition: CommandLine.h:560
llvm::cl::OneOrMore
@ OneOrMore
Definition: CommandLine.h:122
StringMap.h
llvm::cl::generic_parser_base::GenericOptionInfo::Name
StringRef Name
Definition: CommandLine.h:719
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::cl::multi_val::multi_val
multi_val(unsigned N)
Definition: CommandLine.h:1721
llvm::cl::AllSubCommands
ManagedStatic< SubCommand > AllSubCommands
Definition: CommandLine.cpp:493
llvm::cl::Option::setValueStr
void setValueStr(StringRef S)
Definition: CommandLine.h:327
llvm::cl::SubCommand::getDescription
StringRef getDescription() const
Definition: CommandLine.h:231
llvm::None
const NoneType None
Definition: None.h:23
llvm::cl::applicator< OptionHidden >
Definition: CommandLine.h:1300
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::cl::Option::addArgument
void addArgument()
Definition: CommandLine.cpp:447
llvm::cl::parser< unsigned long long >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1111
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::cl::bits_storage< DataType, bool >::getBits
unsigned getBits()
Definition: CommandLine.h:1785
llvm::cl::list_storage::setLocation
bool setLocation(Option &O, StorageClass &L)
Definition: CommandLine.h:1545
llvm::cl::list::list
list(const Mods &... Ms)
Definition: CommandLine.h:1703
llvm::cl::generic_parser_base::Owner
Option & Owner
Definition: CommandLine.h:800
llvm::cl::opt::opt
opt(const opt &)=delete
llvm::cl::OptionValue< cl::boolOrDefault >
Definition: CommandLine.h:625
llvm::cl::ZeroOrMore
@ ZeroOrMore
Definition: CommandLine.h:120
llvm::cl::Option::ArgStr
StringRef ArgStr
Definition: CommandLine.h:281
llvm::cl::ValuesClass::apply
void apply(Opt &O) const
Definition: CommandLine.h:688
llvm::Value::Value
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:53
llvm::XCOFF::StorageClass
StorageClass
Definition: XCOFF.h:126
llvm::cl::Option::setDescription
void setDescription(StringRef S)
Definition: CommandLine.h:326
llvm::cl::opt
Definition: CommandLine.h:1432
llvm::cl::opt_storage::setLocation
bool setLocation(Option &O, DataType &L)
Definition: CommandLine.h:1348
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:206
llvm::cl::Option
Definition: CommandLine.h:249
llvm::cl::list_storage< DataType, bool >::operator[]
reference operator[](size_type pos)
Definition: CommandLine.h:1593
llvm::cl::OptionValue::OptionValue
OptionValue()=default
llvm::cl::OptionValueBase::compare
bool compare(const GenericOptionValue &) const override
Definition: CommandLine.h:551
llvm::cl::OptionCategory::getDescription
StringRef getDescription() const
Definition: CommandLine.h:201
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::cl::list::getParser
ParserClass & getParser()
Definition: CommandLine.h:1693
llvm::cl::applicator::opt
static void opt(const Mod &M, Opt &O)
Definition: CommandLine.h:1270
llvm::cl::SubCommand::SinkOpts
SmallVector< Option *, 4 > SinkOpts
Definition: CommandLine.h:234
llvm::cl::values
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:697
llvm::cl::BOU_UNSET
@ BOU_UNSET
Definition: CommandLine.h:623
llvm::cl::parser< unsigned long >::parser
parser(Option &O)
Definition: CommandLine.h:1080
llvm::cl::OptionDiffPrinter< DT, DT >
Definition: CommandLine.h:1243
llvm::cl::generic_parser_base::GenericOptionInfo::HelpStr
StringRef HelpStr
Definition: CommandLine.h:720
llvm::cl::extrahelp
Definition: CommandLine.h:1943
llvm::cl::cat::cat
cat(OptionCategory &c)
Definition: CommandLine.h:466
llvm::cl::Option::getValueExpectedFlag
enum ValueExpected getValueExpectedFlag() const
Definition: CommandLine.h:292
llvm::cl::parser< double >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1134
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::cl::opt::setInitialValue
void setInitialValue(const DataType &V)
Definition: CommandLine.h:1498
llvm::cl::parser< std::string >::parse
bool parse(Option &, StringRef, StringRef Arg, std::string &Value)
Definition: CommandLine.h:1177
llvm::cl::basic_parser_impl
Definition: CommandLine.h:876
llvm::cl::OptionValue< std::string >::OptionValue
OptionValue(const std::string &V)
Definition: CommandLine.h:648
llvm::cl::parser< char >
Definition: CommandLine.h:1198
llvm::cl::list_storage< DataType, bool >::empty
bool empty() const
Definition: CommandLine.h:1585
llvm::cl::opt_storage< DataType, false, true >::getValue
const DataType & getValue() const
Definition: CommandLine.h:1393
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::cl::OptionDiffPrinter::print
void print(const Option &O, const parser< ParserDT > &P, const ValDT &, const OptionValue< ValDT > &, size_t GlobalWidth)
Definition: CommandLine.h:1235
llvm::cl::Grouping
@ Grouping
Definition: CommandLine.h:177
llvm::cl::OptionValue< std::string >::operator=
OptionValue< std::string > & operator=(const std::string &V)
Definition: CommandLine.h:650
llvm::cl::list::Callback
std::function< void(const typename ParserClass::parser_data_type &)> Callback
Definition: CommandLine.h:1714
llvm::cl::list_storage
Definition: CommandLine.h:1537
llvm::cl::parser< long long >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1039
llvm::cl::Option::setNumAdditionalVals
void setNumAdditionalVals(unsigned n)
Definition: CommandLine.h:346
llvm::cl::ValuesClass
Definition: CommandLine.h:678
llvm::cl::parser< unsigned >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1062
llvm::cl::SetVersionPrinter
void SetVersionPrinter(VersionPrinterTy func)
===------------------------------------------------------------------—===// SetVersionPrinter - Overr...
Definition: CommandLine.cpp:2635
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:441
llvm::cl::SubCommand
Definition: CommandLine.h:210
llvm::cl::parser< long long >::parser
parser(Option &O)
Definition: CommandLine.h:1033
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:1665
ArrayRef.h
llvm::cl::applicator< ValueExpected >
Definition: CommandLine.h:1296
llvm::cl::ProvidePositionalOption
bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i)
Parses Arg into the option handler Handler.
Definition: CommandLine.cpp:709
llvm::cl::list_storage< DataType, bool >::begin
iterator begin()
Definition: CommandLine.h:1573
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::cl::parser::addLiteralOption
void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr)
addLiteralOption - Add an entry to the mapping table.
Definition: CommandLine.h:857
llvm::cl::basic_parser_impl::~basic_parser_impl
virtual ~basic_parser_impl()
Definition: CommandLine.h:880
llvm::cl::OptionValueBase
Definition: CommandLine.h:538
llvm::cl::cb::CB
std::function< R(Ty)> CB
Definition: CommandLine.h:483
llvm::cl::bits_storage::isSet
bool isSet(const T &V)
Definition: CommandLine.h:1764
llvm::cl::ValueDisallowed
@ ValueDisallowed
Definition: CommandLine.h:138
llvm::cl::parser< int >::parser
parser(Option &O)
Definition: CommandLine.h:987
llvm::ScaledNumbers::compare
int compare(DigitsT LDigits, int16_t LScale, DigitsT RDigits, int16_t RScale)
Compare two scaled numbers.
Definition: ScaledNumber.h:251
llvm::cl::opt_storage< DataType, false, false >::Value
DataType Value
Definition: CommandLine.h:1404
llvm::cl::OptionEnumValue
Definition: CommandLine.h:664
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::LocationClass::LocationClass
LocationClass(Ty &L)
Definition: CommandLine.h:452
llvm::cl::opt_storage::opt_storage
opt_storage()=default
llvm::cl::Option::setDefault
virtual void setDefault()=0
iterator_range.h
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::cl::list::getPosition
unsigned getPosition(unsigned optnum) const
Definition: CommandLine.h:1695
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::cl::OptionValueBase::getValue
const DataType & getValue() const
Definition: CommandLine.h:544
llvm::cl::bits
Definition: CommandLine.h:1795
llvm::cl::applicator< MiscFlags >
Definition: CommandLine.h:1308
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::cl::applicator< FormattingFlags >::opt
static void opt(FormattingFlags FF, Option &O)
Definition: CommandLine.h:1305
llvm::cl::OptionValueBase::~OptionValueBase
~OptionValueBase()=default
llvm::cl::boolOrDefault
boolOrDefault
Definition: CommandLine.h:623
llvm::cl::parser< float >
Definition: CommandLine.h:1149
llvm::cl::bits::bits
bits(const Mods &... Ms)
Definition: CommandLine.h:1853
llvm::cl::basic_parser_impl::getValueName
virtual StringRef getValueName() const
Definition: CommandLine.h:903
llvm::cl::bits_storage::setLocation
bool setLocation(Option &O, unsigned &L)
Definition: CommandLine.h:1749
llvm::cl::parser::getOption
StringRef getOption(unsigned N) const override
Definition: CommandLine.h:827
llvm::cl::FormattingFlags
FormattingFlags
Definition: CommandLine.h:161
llvm::StringSaver
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
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:1581
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::cl::list_storage< DataType, bool >::insert
iterator insert(iterator pos, const DataType &value)
Definition: CommandLine.h:1617
llvm::cl::opt::setCallback
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
Definition: CommandLine.h:1515
llvm::Sched::Source
@ Source
Definition: TargetLowering.h:100
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::cl::basic_parser< bool >::parser_data_type
bool parser_data_type
Definition: CommandLine.h:918
None.h
llvm::cl::parser< bool >::parser
parser(Option &O)
Definition: CommandLine.h:932
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
llvm::cl::list_storage< DataType, bool >::insert
iterator insert(iterator pos, DataType &&value)
Definition: CommandLine.h:1620
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
llvm::cl::list_storage< DataType, bool >::erase
iterator erase(const_iterator first, const_iterator last)
Definition: CommandLine.h:1601
llvm::cl::Sink
@ Sink
Definition: CommandLine.h:171
llvm::cl::alias
Definition: CommandLine.h:1872
llvm::cl::Option::~Option
virtual ~Option()=default
llvm::cl::TokenizerCallback
void(*)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs) TokenizerCallback
String tokenization function type.
Definition: CommandLine.h:2059
parse
static llvm::Error parse(DataExtractor &Data, uint64_t BaseAddr, LineEntryCallback const &Callback)
Definition: LineTable.cpp:54
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::cl::applicator< const char[n]>::opt
static void opt(StringRef Str, Opt &O)
Definition: CommandLine.h:1280
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::cl::parser::OptionInfo::V
OptionValue< DataType > V
Definition: CommandLine.h:816
llvm::cl::OptionCategory::OptionCategory
OptionCategory(StringRef const Name, StringRef const Description="")
Definition: CommandLine.h:194
llvm::cl::parser< unsigned long >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1086
llvm::Init
Definition: Record.h:275
llvm::cl::Option::getOptionWidth
virtual size_t getOptionWidth() const =0
llvm::cl::value_desc::value_desc
value_desc(StringRef Str)
Definition: CommandLine.h:425
llvm::cl::opt_storage< DataType, false, true >::getValue
DataType & getValue()
Definition: CommandLine.h:1392
llvm::cl::LocationClass::Loc
Ty & Loc
Definition: CommandLine.h:450
llvm::cl::generic_parser_base::getDescription
virtual StringRef getDescription(unsigned N) const =0
llvm::cl::OptionValue< cl::boolOrDefault >::OptionValue
OptionValue(const cl::boolOrDefault &V)
Definition: CommandLine.h:631
llvm::cl::Option::Subs
SmallPtrSet< SubCommand *, 1 > Subs
Definition: CommandLine.h:286
llvm::cl::opt_storage< DataType, false, true >::setValue
void setValue(const T &V, bool initial=false)
Definition: CommandLine.h:1386
llvm::cl::Option::printOptionValue
virtual void printOptionValue(size_t GlobalWidth, bool Force) const =0
llvm::cl::OptionValueCopy::setValue
void setValue(const DataType &V)
Definition: CommandLine.h:579
llvm::cl::AlwaysPrefix
@ AlwaysPrefix
Definition: CommandLine.h:165
llvm::cl::bits_storage< DataType, bool >::isSet
bool isSet(const T &V)
Definition: CommandLine.h:1787
llvm::cl::initializer::initializer
initializer(const Ty &Val)
Definition: CommandLine.h:436
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:78
llvm::cl::opt_storage< DataType, false, true >::Default
OptionValue< DataType > Default
Definition: CommandLine.h:1384
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::cl::opt_storage< DataType, false, false >::getDefault
const OptionValue< DataType > & getDefault() const
Definition: CommandLine.h:1419
llvm::cl::bits::getParser
ParserClass & getParser()
Definition: CommandLine.h:1845
llvm::cl::Option::isInAllSubCommands
bool isInAllSubCommands() const
Definition: CommandLine.h:318
llvm::vfs::FileSystem
The virtual file system interface.
Definition: VirtualFileSystem.h:253
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
std
Definition: BitVector.h:838
uint16_t
llvm::cl::bits::setCallback
void setCallback(std::function< void(const typename ParserClass::parser_data_type &)> CB)
Definition: CommandLine.h:1859
llvm::cl::Option::isPositional
bool isPositional() const
Definition: CommandLine.h:310
llvm::cl::generic_parser_base::~generic_parser_base
virtual ~generic_parser_base()=default
llvm::cl::basic_parser_impl::getOptionWidth
size_t getOptionWidth(const Option &O) const
Definition: CommandLine.cpp:1776
llvm::cl::alias::setAliasFor
void setAliasFor(Option &O)
Definition: CommandLine.h:1916
llvm::cl::OptionCategory::getName
StringRef getName() const
Definition: CommandLine.h:200
llvm::cl::GenericOptionValue::operator=
GenericOptionValue & operator=(const GenericOptionValue &)=default
llvm::cl::parser::Values
SmallVector< OptionInfo, 8 > Values
Definition: CommandLine.h:818
llvm::cl::list_storage< DataType, bool >::size
size_type size() const
Definition: CommandLine.h:1583
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::cl::detail::callback_traits< R(C::*)(Args...) const >::result_type
R result_type
Definition: CommandLine.h:496
llvm::cl::multi_val::apply
void apply(list< D, S, P > &L) const
Definition: CommandLine.h:1724
llvm::cl::list_storage::clear
void clear()
Definition: CommandLine.h:1543
llvm::cl::opt_storage
Definition: CommandLine.h:1335
llvm::cl::NormalFormatting
@ NormalFormatting
Definition: CommandLine.h:162
llvm::cl::Option::printHelpStr
static void printHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
Definition: CommandLine.cpp:1737
llvm::cl::applicator< char[n]>::opt
static void opt(StringRef Str, Opt &O)
Definition: CommandLine.h:1275
llvm::cl::value_desc
Definition: CommandLine.h:422
llvm::cl::parser< unsigned >
Definition: CommandLine.h:1054
llvm::cl::Option::setNumOccurrencesFlag
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val)
Definition: CommandLine.h:328
llvm::cl::list::setNumAdditionalVals
void setNumAdditionalVals(unsigned n)
Definition: CommandLine.h:1700
llvm::cl::basic_parser_impl::printOptionName
void printOptionName(const Option &O, size_t GlobalWidth) const
Definition: CommandLine.cpp:1809
llvm::cl::OptionValueCopy::getValue
const DataType & getValue() const
Definition: CommandLine.h:574
llvm::cl::opt_storage< DataType, false, false >::getValue
DataType getValue() const
Definition: CommandLine.h:1417
llvm::cl::multi_val
Definition: CommandLine.h:1719
llvm::cl::list_storage< DataType, bool >::iterator
typename std::vector< DataType >::iterator iterator
Definition: CommandLine.h:1571
llvm::cl::Option::addSubCommand
void addSubCommand(SubCommand &S)
Definition: CommandLine.h:335
llvm::cl::Option::setPosition
void setPosition(unsigned pos)
Definition: CommandLine.h:333
llvm::cl::aliasopt::apply
void apply(alias &A) const
Definition: CommandLine.h:1936
llvm::cl::BOU_TRUE
@ BOU_TRUE
Definition: CommandLine.h:623
llvm::cl::parser< long long >
Definition: CommandLine.h:1031
llvm::cl::applicator< OptionHidden >::opt
static void opt(OptionHidden OH, Option &O)
Definition: CommandLine.h:1301
llvm::cl::parser< long >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1016
llvm::cl::OptionValueCopy::OptionValueCopy
OptionValueCopy()=default
llvm::cl::initializer::apply
void apply(Opt &O) const
Definition: CommandLine.h:438
SmallVector.h
llvm::cl::parser< std::string >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1183
llvm::cl::OptionValue< std::string >
Definition: CommandLine.h:643
llvm::cl::parser< int >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:993
llvm::cl::Option::getNumOccurrencesFlag
enum NumOccurrencesFlag getNumOccurrencesFlag() const
Definition: CommandLine.h:288
llvm::cl::list_storage< DataType, bool >::front
const_reference front() const
Definition: CommandLine.h:1625
N
#define N
llvm::cl::opt_storage::getValue
DataType & getValue()
Definition: CommandLine.h:1363
llvm::cl::OptionValueBase::hasValue
bool hasValue() const
Definition: CommandLine.h:542
llvm::cl::cat
Definition: CommandLine.h:463
llvm::cl::generic_parser_base::generic_parser_base
generic_parser_base(Option &O)
Definition: CommandLine.h:724
llvm::cl::generic_parser_base::getOptionWidth
virtual size_t getOptionWidth(const Option &O) const
Definition: CommandLine.cpp:1961
llvm::cl::Option::ValueStr
StringRef ValueStr
Definition: CommandLine.h:283
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::cl::applicator< const char[n]>
Definition: CommandLine.h:1279
llvm::cl::OptionEnumValue::Name
StringRef Name
Definition: CommandLine.h:665
llvm::cl::list_storage< DataType, bool >::insert
iterator insert(const_iterator pos, const DataType &value)
Definition: CommandLine.h:1610
llvm::SmallVectorImpl< StringRef >
llvm::cl::applicator< ValueExpected >::opt
static void opt(ValueExpected VE, Option &O)
Definition: CommandLine.h:1297
llvm::cl::parser< std::string >
Definition: CommandLine.h:1172
llvm::cl::list_storage< DataType, bool >::operator&
const std::vector< DataType > * operator&() const
Definition: CommandLine.h:1630
llvm::cl::parser< char >::parser
parser(Option &O)
Definition: CommandLine.h:1200
llvm::cl::parser::OptionInfo
Definition: CommandLine.h:811
llvm::cl::Option::addCategory
void addCategory(OptionCategory &C)
Definition: CommandLine.cpp:463
llvm::cl::parser< float >::parser
parser(Option &O)
Definition: CommandLine.h:1151
llvm::cl::parser< bool >
Definition: CommandLine.h:930
llvm::cl::callback
cb< typename detail::callback_traits< F >::result_type, typename detail::callback_traits< F >::arg_type > callback(F CB)
Definition: CommandLine.h:510
llvm::cl::Option::Option
Option(enum NumOccurrencesFlag OccurrencesFlag, enum OptionHidden Hidden)
Definition: CommandLine.h:338
llvm::cl::Option::isSink
bool isSink() const
Definition: CommandLine.h:311
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::cl::GenericOptionValue::compare
virtual bool compare(const GenericOptionValue &V) const =0
llvm::cl::desc
Definition: CommandLine.h:412
llvm::cl::generic_parser_base::getValueExpectedFlagDefault
enum ValueExpected getValueExpectedFlagDefault() const
Definition: CommandLine.h:776
llvm::cl::Option::isDefaultOption
bool isDefaultOption() const
Definition: CommandLine.h:312
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::cl::applicator< StringRef >
Definition: CommandLine.h:1284
llvm::cl::list_storage< DataType, bool >::operator[]
const_reference operator[](size_type pos) const
Definition: CommandLine.h:1594
llvm::cl::extrahelp::morehelp
StringRef morehelp
Definition: CommandLine.h:1944
llvm::cl::ValuesClass::ValuesClass
ValuesClass(std::initializer_list< OptionEnumValue > Options)
Definition: CommandLine.h:685
raw_ostream.h
llvm::cl::applicator
Definition: CommandLine.h:1269
n
The same transformation can work with an even modulo with the addition of a and shrink the compare RHS by the same amount Unless the target supports that transformation probably isn t worthwhile The transformation can also easily be made to work with non zero equality for n
Definition: README.txt:685
llvm::cl::bits_storage< DataType, bool >::addValue
void addValue(const T &V)
Definition: CommandLine.h:1783
llvm::cl::LocationClass::apply
void apply(Opt &O) const
Definition: CommandLine.h:454
llvm::cl::applicator< NumOccurrencesFlag >::opt
static void opt(NumOccurrencesFlag N, Option &O)
Definition: CommandLine.h:1291
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::basic_parser::basic_parser
basic_parser(Option &O)
Definition: CommandLine.h:921
llvm::cl::getGeneralCategory
OptionCategory & getGeneralCategory()
Definition: CommandLine.cpp:2555
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1883
llvm::cl::OptionValue::OptionValue
OptionValue(const DataType &V)
Definition: CommandLine.h:613
llvm::cl::alias::operator=
alias & operator=(const alias &)=delete
llvm::cl::list_storage< DataType, bool >::push_back
void push_back(const DataType &value)
Definition: CommandLine.h:1587
llvm::cl::opt_storage::getDefault
const OptionValue< DataType > & getDefault() const
Definition: CommandLine.h:1374
llvm::cl::basic_parser_impl::printOptionInfo
void printOptionInfo(const Option &O, size_t GlobalWidth) const
Definition: CommandLine.cpp:1792
llvm::cl::opt::Callback
std::function< void(const typename ParserClass::parser_data_type &)> Callback
Definition: CommandLine.h:1520
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::cl::bits::bits
bits(const bits &)=delete
llvm::cl::parser< long >
Definition: CommandLine.h:1008
llvm::cl::sub::apply
void apply(Opt &O) const
Definition: CommandLine.h:477
llvm::cl::Option::error
bool error(const Twine &Message, raw_ostream &Errs)
Definition: CommandLine.h:398
llvm::cl::list_storage< DataType, bool >::const_reference
typename std::vector< DataType >::const_reference const_reference
Definition: CommandLine.h:1591
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::applicator< MiscFlags >::opt
static void opt(MiscFlags MF, Option &O)
Definition: CommandLine.h:1309
llvm::cl::SubCommand::getName
StringRef getName() const
Definition: CommandLine.h:230
llvm::cl::opt_storage< DataType, false, false >::setValue
void setValue(const T &V, bool initial=false)
Definition: CommandLine.h:1411
llvm::cl::opt_storage< DataType, false, false >::Default
OptionValue< DataType > Default
Definition: CommandLine.h:1405
SpecialSubKind::string
@ string
llvm::cl::opt_storage::setValue
void setValue(const T &V, bool initial=false)
Definition: CommandLine.h:1356
llvm::cl::list_storage< DataType, bool >::front
reference front()
Definition: CommandLine.h:1624
llvm::cl::parser< char >::getValueName
StringRef getValueName() const override
Definition: CommandLine.h:1209
llvm::cl::OptionCategory
Definition: CommandLine.h:186
llvm::cl::Option::setHiddenFlag
void setHiddenFlag(enum OptionHidden Val)
Definition: CommandLine.h:330
llvm::cl::list
Definition: CommandLine.h:1640