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