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