LLVM  7.0.0svn
OptTable.cpp
Go to the documentation of this file.
1 //===- OptTable.cpp - Option Table Implementation -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/StringRef.h"
12 #include "llvm/ADT/StringSet.h"
13 #include "llvm/Option/Arg.h"
14 #include "llvm/Option/ArgList.h"
15 #include "llvm/Option/Option.h"
17 #include "llvm/Option/OptTable.h"
18 #include "llvm/Support/Compiler.h"
21 #include <algorithm>
22 #include <cassert>
23 #include <cctype>
24 #include <cstring>
25 #include <map>
26 #include <string>
27 #include <utility>
28 #include <vector>
29 
30 using namespace llvm;
31 using namespace llvm::opt;
32 
33 namespace llvm {
34 namespace opt {
35 
36 // Ordering on Info. The ordering is *almost* case-insensitive lexicographic,
37 // with an exception. '\0' comes at the end of the alphabet instead of the
38 // beginning (thus options precede any other options which prefix them).
39 static int StrCmpOptionNameIgnoreCase(const char *A, const char *B) {
40  const char *X = A, *Y = B;
41  char a = tolower(*A), b = tolower(*B);
42  while (a == b) {
43  if (a == '\0')
44  return 0;
45 
46  a = tolower(*++X);
47  b = tolower(*++Y);
48  }
49 
50  if (a == '\0') // A is a prefix of B.
51  return 1;
52  if (b == '\0') // B is a prefix of A.
53  return -1;
54 
55  // Otherwise lexicographic.
56  return (a < b) ? -1 : 1;
57 }
58 
59 #ifndef NDEBUG
60 static int StrCmpOptionName(const char *A, const char *B) {
61  if (int N = StrCmpOptionNameIgnoreCase(A, B))
62  return N;
63  return strcmp(A, B);
64 }
65 
66 static inline bool operator<(const OptTable::Info &A, const OptTable::Info &B) {
67  if (&A == &B)
68  return false;
69 
70  if (int N = StrCmpOptionName(A.Name, B.Name))
71  return N < 0;
72 
73  for (const char * const *APre = A.Prefixes,
74  * const *BPre = B.Prefixes;
75  *APre != nullptr && *BPre != nullptr; ++APre, ++BPre){
76  if (int N = StrCmpOptionName(*APre, *BPre))
77  return N < 0;
78  }
79 
80  // Names are the same, check that classes are in order; exactly one
81  // should be joined, and it should succeed the other.
83  "Unexpected classes for options with same name.");
84  return B.Kind == Option::JoinedClass;
85 }
86 #endif
87 
88 // Support lower_bound between info and an option name.
89 static inline bool operator<(const OptTable::Info &I, const char *Name) {
90  return StrCmpOptionNameIgnoreCase(I.Name, Name) < 0;
91 }
92 
93 } // end namespace opt
94 } // end namespace llvm
95 
96 OptSpecifier::OptSpecifier(const Option *Opt) : ID(Opt->getID()) {}
97 
98 OptTable::OptTable(ArrayRef<Info> OptionInfos, bool IgnoreCase)
99  : OptionInfos(OptionInfos), IgnoreCase(IgnoreCase) {
100  // Explicitly zero initialize the error to work around a bug in array
101  // value-initialization on MinGW with gcc 4.3.5.
102 
103  // Find start of normal options.
104  for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
105  unsigned Kind = getInfo(i + 1).Kind;
106  if (Kind == Option::InputClass) {
107  assert(!TheInputOptionID && "Cannot have multiple input options!");
108  TheInputOptionID = getInfo(i + 1).ID;
109  } else if (Kind == Option::UnknownClass) {
110  assert(!TheUnknownOptionID && "Cannot have multiple unknown options!");
111  TheUnknownOptionID = getInfo(i + 1).ID;
112  } else if (Kind != Option::GroupClass) {
113  FirstSearchableIndex = i;
114  break;
115  }
116  }
117  assert(FirstSearchableIndex != 0 && "No searchable options?");
118 
119 #ifndef NDEBUG
120  // Check that everything after the first searchable option is a
121  // regular option class.
122  for (unsigned i = FirstSearchableIndex, e = getNumOptions(); i != e; ++i) {
124  assert((Kind != Option::InputClass && Kind != Option::UnknownClass &&
125  Kind != Option::GroupClass) &&
126  "Special options should be defined first!");
127  }
128 
129  // Check that options are in order.
130  for (unsigned i = FirstSearchableIndex + 1, e = getNumOptions(); i != e; ++i){
131  if (!(getInfo(i) < getInfo(i + 1))) {
132  getOption(i).dump();
133  getOption(i + 1).dump();
134  llvm_unreachable("Options are not in order!");
135  }
136  }
137 #endif
138 
139  // Build prefixes.
140  for (unsigned i = FirstSearchableIndex + 1, e = getNumOptions() + 1;
141  i != e; ++i) {
142  if (const char *const *P = getInfo(i).Prefixes) {
143  for (; *P != nullptr; ++P) {
144  PrefixesUnion.insert(*P);
145  }
146  }
147  }
148 
149  // Build prefix chars.
150  for (StringSet<>::const_iterator I = PrefixesUnion.begin(),
151  E = PrefixesUnion.end(); I != E; ++I) {
152  StringRef Prefix = I->getKey();
153  for (StringRef::const_iterator C = Prefix.begin(), CE = Prefix.end();
154  C != CE; ++C)
155  if (!is_contained(PrefixChars, *C))
156  PrefixChars.push_back(*C);
157  }
158 }
159 
160 OptTable::~OptTable() = default;
161 
163  unsigned id = Opt.getID();
164  if (id == 0)
165  return Option(nullptr, nullptr);
166  assert((unsigned) (id - 1) < getNumOptions() && "Invalid ID.");
167  return Option(&getInfo(id), this);
168 }
169 
170 static bool isInput(const StringSet<> &Prefixes, StringRef Arg) {
171  if (Arg == "-")
172  return true;
173  for (StringSet<>::const_iterator I = Prefixes.begin(),
174  E = Prefixes.end(); I != E; ++I)
175  if (Arg.startswith(I->getKey()))
176  return false;
177  return true;
178 }
179 
180 /// \returns Matched size. 0 means no match.
181 static unsigned matchOption(const OptTable::Info *I, StringRef Str,
182  bool IgnoreCase) {
183  for (const char * const *Pre = I->Prefixes; *Pre != nullptr; ++Pre) {
184  StringRef Prefix(*Pre);
185  if (Str.startswith(Prefix)) {
186  StringRef Rest = Str.substr(Prefix.size());
187  bool Matched = IgnoreCase
188  ? Rest.startswith_lower(I->Name)
189  : Rest.startswith(I->Name);
190  if (Matched)
191  return Prefix.size() + StringRef(I->Name).size();
192  }
193  }
194  return 0;
195 }
196 
197 // Returns true if one of the Prefixes + In.Names matches Option
199  if (In.Prefixes)
200  for (size_t I = 0; In.Prefixes[I]; I++)
201  if (Option == std::string(In.Prefixes[I]) + In.Name)
202  return true;
203  return false;
204 }
205 
206 // This function is for flag value completion.
207 // Eg. When "-stdlib=" and "l" was passed to this function, it will return
208 // appropiriate values for stdlib, which starts with l.
209 std::vector<std::string>
211  // Search all options and return possible values.
212  for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
213  const Info &In = OptionInfos[I];
214  if (!In.Values || !optionMatches(In, Option))
215  continue;
216 
217  SmallVector<StringRef, 8> Candidates;
218  StringRef(In.Values).split(Candidates, ",", -1, false);
219 
220  std::vector<std::string> Result;
221  for (StringRef Val : Candidates)
222  if (Val.startswith(Arg))
223  Result.push_back(Val);
224  return Result;
225  }
226  return {};
227 }
228 
229 std::vector<std::string>
230 OptTable::findByPrefix(StringRef Cur, unsigned short DisableFlags) const {
231  std::vector<std::string> Ret;
232  for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
233  const Info &In = OptionInfos[I];
234  if (!In.Prefixes || (!In.HelpText && !In.GroupID))
235  continue;
236  if (In.Flags & DisableFlags)
237  continue;
238 
239  for (int I = 0; In.Prefixes[I]; I++) {
240  std::string S = std::string(In.Prefixes[I]) + std::string(In.Name) + "\t";
241  if (In.HelpText)
242  S += In.HelpText;
243  if (StringRef(S).startswith(Cur))
244  Ret.push_back(S);
245  }
246  }
247  return Ret;
248 }
249 
250 unsigned OptTable::findNearest(StringRef Option, std::string &NearestString,
251  unsigned FlagsToInclude, unsigned FlagsToExclude,
252  unsigned MinimumLength) const {
253  assert(!Option.empty());
254 
255  // Consider each option as a candidate, finding the closest match.
256  unsigned BestDistance = UINT_MAX;
257  for (const Info &CandidateInfo :
258  ArrayRef<Info>(OptionInfos).drop_front(FirstSearchableIndex)) {
259  StringRef CandidateName = CandidateInfo.Name;
260 
261  // Ignore option candidates with empty names, such as "--", or names
262  // that do not meet the minimum length.
263  if (CandidateName.empty() || CandidateName.size() < MinimumLength)
264  continue;
265 
266  // If FlagsToInclude were specified, ignore options that don't include
267  // those flags.
268  if (FlagsToInclude && !(CandidateInfo.Flags & FlagsToInclude))
269  continue;
270  // Ignore options that contain the FlagsToExclude.
271  if (CandidateInfo.Flags & FlagsToExclude)
272  continue;
273 
274  // Ignore positional argument option candidates (which do not
275  // have prefixes).
276  if (!CandidateInfo.Prefixes)
277  continue;
278  // Find the most appropriate prefix. For example, if a user asks for
279  // "--helm", suggest "--help" over "-help".
280  StringRef Prefix = CandidateInfo.Prefixes[0];
281  for (int P = 1; CandidateInfo.Prefixes[P]; P++) {
282  if (Option.startswith(CandidateInfo.Prefixes[P]))
283  Prefix = CandidateInfo.Prefixes[P];
284  }
285 
286  // Check if the candidate ends with a character commonly used when
287  // delimiting an option from its value, such as '=' or ':'. If it does,
288  // attempt to split the given option based on that delimiter.
289  std::string Delimiter = "";
290  char Last = CandidateName.back();
291  if (Last == '=' || Last == ':')
292  Delimiter = std::string(1, Last);
293 
294  StringRef LHS, RHS;
295  if (Delimiter.empty())
296  LHS = Option;
297  else
298  std::tie(LHS, RHS) = Option.split(Last);
299 
300  std::string NormalizedName =
301  (LHS.drop_front(Prefix.size()) + Delimiter).str();
302  unsigned Distance =
303  CandidateName.edit_distance(NormalizedName, /*AllowReplacements=*/true,
304  /*MaxEditDistance=*/BestDistance);
305  if (Distance < BestDistance) {
306  BestDistance = Distance;
307  NearestString = (Prefix + CandidateName + RHS).str();
308  }
309  }
310  return BestDistance;
311 }
312 
313 bool OptTable::addValues(const char *Option, const char *Values) {
314  for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
315  Info &In = OptionInfos[I];
316  if (optionMatches(In, Option)) {
317  In.Values = Values;
318  return true;
319  }
320  }
321  return false;
322 }
323 
324 Arg *OptTable::ParseOneArg(const ArgList &Args, unsigned &Index,
325  unsigned FlagsToInclude,
326  unsigned FlagsToExclude) const {
327  unsigned Prev = Index;
328  const char *Str = Args.getArgString(Index);
329 
330  // Anything that doesn't start with PrefixesUnion is an input, as is '-'
331  // itself.
332  if (isInput(PrefixesUnion, Str))
333  return new Arg(getOption(TheInputOptionID), Str, Index++, Str);
334 
335  const Info *Start = OptionInfos.data() + FirstSearchableIndex;
336  const Info *End = OptionInfos.data() + OptionInfos.size();
337  StringRef Name = StringRef(Str).ltrim(PrefixChars);
338 
339  // Search for the first next option which could be a prefix.
340  Start = std::lower_bound(Start, End, Name.data());
341 
342  // Options are stored in sorted order, with '\0' at the end of the
343  // alphabet. Since the only options which can accept a string must
344  // prefix it, we iteratively search for the next option which could
345  // be a prefix.
346  //
347  // FIXME: This is searching much more than necessary, but I am
348  // blanking on the simplest way to make it fast. We can solve this
349  // problem when we move to TableGen.
350  for (; Start != End; ++Start) {
351  unsigned ArgSize = 0;
352  // Scan for first option which is a proper prefix.
353  for (; Start != End; ++Start)
354  if ((ArgSize = matchOption(Start, Str, IgnoreCase)))
355  break;
356  if (Start == End)
357  break;
358 
359  Option Opt(Start, this);
360 
361  if (FlagsToInclude && !Opt.hasFlag(FlagsToInclude))
362  continue;
363  if (Opt.hasFlag(FlagsToExclude))
364  continue;
365 
366  // See if this option matches.
367  if (Arg *A = Opt.accept(Args, Index, ArgSize))
368  return A;
369 
370  // Otherwise, see if this argument was missing values.
371  if (Prev != Index)
372  return nullptr;
373  }
374 
375  // If we failed to find an option and this arg started with /, then it's
376  // probably an input path.
377  if (Str[0] == '/')
378  return new Arg(getOption(TheInputOptionID), Str, Index++, Str);
379 
380  return new Arg(getOption(TheUnknownOptionID), Str, Index++, Str);
381 }
382 
384  unsigned &MissingArgIndex,
385  unsigned &MissingArgCount,
386  unsigned FlagsToInclude,
387  unsigned FlagsToExclude) const {
388  InputArgList Args(ArgArr.begin(), ArgArr.end());
389 
390  // FIXME: Handle '@' args (or at least error on them).
391 
392  MissingArgIndex = MissingArgCount = 0;
393  unsigned Index = 0, End = ArgArr.size();
394  while (Index < End) {
395  // Ingore nullptrs, they are response file's EOL markers
396  if (Args.getArgString(Index) == nullptr) {
397  ++Index;
398  continue;
399  }
400  // Ignore empty arguments (other things may still take them as arguments).
401  StringRef Str = Args.getArgString(Index);
402  if (Str == "") {
403  ++Index;
404  continue;
405  }
406 
407  unsigned Prev = Index;
408  Arg *A = ParseOneArg(Args, Index, FlagsToInclude, FlagsToExclude);
409  assert(Index > Prev && "Parser failed to consume argument.");
410 
411  // Check for missing argument error.
412  if (!A) {
413  assert(Index >= End && "Unexpected parser error.");
414  assert(Index - Prev - 1 && "No missing arguments!");
415  MissingArgIndex = Prev;
416  MissingArgCount = Index - Prev - 1;
417  break;
418  }
419 
420  Args.append(A);
421  }
422 
423  return Args;
424 }
425 
426 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
427  const Option O = Opts.getOption(Id);
428  std::string Name = O.getPrefixedName();
429 
430  // Add metavar, if used.
431  switch (O.getKind()) {
433  llvm_unreachable("Invalid option with help text.");
434 
436  if (const char *MetaVarName = Opts.getOptionMetaVar(Id)) {
437  // For MultiArgs, metavar is full list of all argument names.
438  Name += ' ';
439  Name += MetaVarName;
440  }
441  else {
442  // For MultiArgs<N>, if metavar not supplied, print <value> N times.
443  for (unsigned i=0, e=O.getNumArgs(); i< e; ++i) {
444  Name += " <value>";
445  }
446  }
447  break;
448 
449  case Option::FlagClass:
450  break;
451 
452  case Option::ValuesClass:
453  break;
454 
457  Name += ' ';
461  if (const char *MetaVarName = Opts.getOptionMetaVar(Id))
462  Name += MetaVarName;
463  else
464  Name += "<value>";
465  break;
466  }
467 
468  return Name;
469 }
470 
471 namespace {
472 struct OptionInfo {
473  std::string Name;
474  StringRef HelpText;
475 };
476 } // namespace
477 
479  std::vector<OptionInfo> &OptionHelp) {
480  OS << Title << ":\n";
481 
482  // Find the maximum option length.
483  unsigned OptionFieldWidth = 0;
484  for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {
485  // Limit the amount of padding we are willing to give up for alignment.
486  unsigned Length = OptionHelp[i].Name.size();
487  if (Length <= 23)
488  OptionFieldWidth = std::max(OptionFieldWidth, Length);
489  }
490 
491  const unsigned InitialPad = 2;
492  for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {
493  const std::string &Option = OptionHelp[i].Name;
494  int Pad = OptionFieldWidth - int(Option.size());
495  OS.indent(InitialPad) << Option;
496 
497  // Break on long option names.
498  if (Pad < 0) {
499  OS << "\n";
500  Pad = OptionFieldWidth + InitialPad;
501  }
502  OS.indent(Pad + 1) << OptionHelp[i].HelpText << '\n';
503  }
504 }
505 
506 static const char *getOptionHelpGroup(const OptTable &Opts, OptSpecifier Id) {
507  unsigned GroupID = Opts.getOptionGroupID(Id);
508 
509  // If not in a group, return the default help group.
510  if (!GroupID)
511  return "OPTIONS";
512 
513  // Abuse the help text of the option groups to store the "help group"
514  // name.
515  //
516  // FIXME: Split out option groups.
517  if (const char *GroupHelp = Opts.getOptionHelpText(GroupID))
518  return GroupHelp;
519 
520  // Otherwise keep looking.
521  return getOptionHelpGroup(Opts, GroupID);
522 }
523 
524 void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
525  bool ShowHidden, bool ShowAllAliases) const {
526  PrintHelp(OS, Name, Title, /*Include*/ 0, /*Exclude*/
527  (ShowHidden ? 0 : HelpHidden), ShowAllAliases);
528 }
529 
530 void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
531  unsigned FlagsToInclude, unsigned FlagsToExclude,
532  bool ShowAllAliases) const {
533  OS << "OVERVIEW: " << Title << "\n";
534  OS << '\n';
535  OS << "USAGE: " << Name << " [options] <inputs>\n";
536  OS << '\n';
537 
538  // Render help text into a map of group-name to a list of (option, help)
539  // pairs.
540  using helpmap_ty = std::map<std::string, std::vector<OptionInfo>>;
541  helpmap_ty GroupedOptionHelp;
542 
543  for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
544  unsigned Id = i + 1;
545 
546  // FIXME: Split out option groups.
548  continue;
549 
550  unsigned Flags = getInfo(Id).Flags;
551  if (FlagsToInclude && !(Flags & FlagsToInclude))
552  continue;
553  if (Flags & FlagsToExclude)
554  continue;
555 
556  // If an alias doesn't have a help text, show a help text for the aliased
557  // option instead.
558  const char *HelpText = getOptionHelpText(Id);
559  if (!HelpText && ShowAllAliases) {
560  const Option Alias = getOption(Id).getAlias();
561  if (Alias.isValid())
562  HelpText = getOptionHelpText(Alias.getID());
563  }
564 
565  if (HelpText) {
566  const char *HelpGroup = getOptionHelpGroup(*this, Id);
567  const std::string &OptName = getOptionHelpName(*this, Id);
568  GroupedOptionHelp[HelpGroup].push_back({OptName, HelpText});
569  }
570  }
571 
572  for (helpmap_ty::iterator it = GroupedOptionHelp .begin(),
573  ie = GroupedOptionHelp.end(); it != ie; ++it) {
574  if (it != GroupedOptionHelp .begin())
575  OS << "\n";
576  PrintHelpOptionList(OS, it->first, it->second);
577  }
578 
579  OS.flush();
580 }
uint64_t CallInst * C
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
LLVM_NODISCARD bool startswith_lower(StringRef Prefix) const
Check if this string starts with the given Prefix, ignoring case.
Definition: StringRef.cpp:47
unsigned getNumOptions() const
Return the total number of option classes.
Definition: OptTable.h:90
unsigned short GroupID
Definition: OptTable.h:53
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:236
unsigned short Flags
Definition: OptTable.h:52
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
std::string getPrefixedName() const
Get the name of this option with the default prefix.
Definition: Option.h:133
static bool operator<(const OptTable::Info &A, const OptTable::Info &B)
Definition: OptTable.cpp:66
iterator begin() const
Definition: ArrayRef.h:137
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static unsigned matchOption(const OptTable::Info *I, StringRef Str, bool IgnoreCase)
Definition: OptTable.cpp:181
InputArgList ParseArgs(ArrayRef< const char *> Args, unsigned &MissingArgIndex, unsigned &MissingArgCount, unsigned FlagsToInclude=0, unsigned FlagsToExclude=0) const
Parse an list of arguments into an InputArgList.
Definition: OptTable.cpp:383
unsigned getOptionGroupID(OptSpecifier id) const
Get the group id for the given option.
Definition: OptTable.h:109
void dump() const
Definition: Option.cpp:90
raw_ostream & indent(unsigned NumSpaces)
indent - Insert &#39;NumSpaces&#39; spaces.
LLVM_NODISCARD StringRef ltrim(char Char) const
Return string with consecutive Char characters starting from the the left removed.
Definition: StringRef.h:808
LLVM_NODISCARD unsigned edit_distance(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
Determine the edit distance between this string and another string.
Definition: StringRef.cpp:95
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
std::vector< std::string > findByPrefix(StringRef Cur, unsigned short DisableFlags) const
Find flags from OptTable which starts with Cur.
Definition: OptTable.cpp:230
unsigned getID() const
Definition: OptSpecifier.h:30
Arg * ParseOneArg(const ArgList &Args, unsigned &Index, unsigned FlagsToInclude=0, unsigned FlagsToExclude=0) const
Parse a single argument; returning the new argument and updating Index.
Definition: OptTable.cpp:324
static bool startswith(StringRef Magic, const char(&S)[N])
Definition: Magic.cpp:29
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
static int getID(struct InternalInstruction *insn, const void *miiArg)
static bool optionMatches(const OptTable::Info &In, StringRef Option)
Definition: OptTable.cpp:198
unsigned char Kind
Definition: OptTable.h:50
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
OptTable(ArrayRef< Info > OptionInfos, bool IgnoreCase=false)
Definition: OptTable.cpp:98
auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:910
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
static const char * getOptionHelpGroup(const OptTable &Opts, OptSpecifier Id)
Definition: OptTable.cpp:506
OptionClass getKind() const
Definition: Option.h:93
#define P(N)
friend const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:245
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Option - Abstract representation for a single form of driver argument.
Definition: Option.h:52
Definition: Arg.h:27
A concrete instance of a particular driver option.
Definition: Arg.h:35
Provide access to the Option info table.
Definition: OptTable.h:39
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
bool hasFlag(unsigned Val) const
Test if this option has the flag Val.
Definition: Option.h:171
const char * HelpText
Definition: OptTable.h:47
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
const char *const * Prefixes
A null terminated array of prefix strings to apply to name while matching.
Definition: OptTable.h:45
const Option getOption(OptSpecifier Opt) const
Get the given Opt&#39;s Option instance, lazily creating it if necessary.
Definition: OptTable.cpp:162
bool isValid() const
Definition: Option.h:84
static const unsigned End
static int StrCmpOptionName(const char *A, const char *B)
Definition: OptTable.cpp:60
const char * Values
Definition: OptTable.h:56
LLVM_NODISCARD char back() const
back - Get the last character in the string.
Definition: StringRef.h:149
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::pair< typename base::iterator, bool > insert(StringRef Key)
Definition: StringSet.h:38
const Option getAlias() const
Definition: Option.h:110
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:645
std::vector< std::string > suggestValueCompletions(StringRef Option, StringRef Arg) const
Find possible value for given flags.
Definition: OptTable.cpp:210
unsigned findNearest(StringRef Option, std::string &NearestString, unsigned FlagsToInclude=0, unsigned FlagsToExclude=0, unsigned MinimumLength=4) const
Find the OptTable option that most closely matches the given string.
Definition: OptTable.cpp:250
virtual const char * getArgString(unsigned Index) const =0
getArgString - Return the input argument string at Index.
static void PrintHelpOptionList(raw_ostream &OS, StringRef Title, std::vector< OptionInfo > &OptionHelp)
Definition: OptTable.cpp:478
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:727
static int StrCmpOptionNameIgnoreCase(const char *A, const char *B)
Definition: OptTable.cpp:39
iterator end() const
Definition: ArrayRef.h:138
unsigned getNumArgs() const
Definition: Option.h:139
unsigned getOptionKind(OptSpecifier id) const
Get the kind of the given option.
Definition: OptTable.h:104
Defines the llvm::Arg class for parsed arguments.
iterator begin() const
Definition: StringRef.h:106
amdgpu Simplify well known AMD library false Value Value * Arg
OptSpecifier - Wrapper class for abstracting references to option IDs.
Definition: OptSpecifier.h:19
iterator begin()
Definition: StringMap.h:317
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:188
void PrintHelp(raw_ostream &OS, const char *Name, const char *Title, unsigned FlagsToInclude, unsigned FlagsToExclude, bool ShowAllAliases) const
Render the help text for an option table.
Definition: OptTable.cpp:530
Entry for a single option instance in the option data table.
Definition: OptTable.h:42
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
bool addValues(const char *Option, const char *Values)
Add Values to Option&#39;s Values class.
Definition: OptTable.cpp:313
const char * getOptionHelpText(OptSpecifier id) const
Get the help text to use to describe this option.
Definition: OptTable.h:114
static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id)
Definition: OptTable.cpp:426
const unsigned Kind
const char * getOptionMetaVar(OptSpecifier id) const
Get the meta-variable name to use when describing this options values in the help text...
Definition: OptTable.h:120
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned getID() const
Definition: Option.h:88
static bool isInput(const StringSet<> &Prefixes, StringRef Arg)
Definition: OptTable.cpp:170
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:235
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:28
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
hexagon cext opt
ArgList - Ordered collection of driver arguments.
Definition: ArgList.h:120
iterator end() const
Definition: StringRef.h:108
iterator end()
Definition: StringMap.h:320
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:873
Arg * accept(const ArgList &Args, unsigned &Index, unsigned ArgSize) const
accept - Potentially accept the current argument, returning a new Arg instance, or 0 if the option do...
Definition: Option.cpp:109