LLVM  6.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 bool OptTable::addValues(const char *Option, const char *Values) {
251  for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
252  Info &In = OptionInfos[I];
253  if (optionMatches(In, Option)) {
254  In.Values = Values;
255  return true;
256  }
257  }
258  return false;
259 }
260 
261 Arg *OptTable::ParseOneArg(const ArgList &Args, unsigned &Index,
262  unsigned FlagsToInclude,
263  unsigned FlagsToExclude) const {
264  unsigned Prev = Index;
265  const char *Str = Args.getArgString(Index);
266 
267  // Anything that doesn't start with PrefixesUnion is an input, as is '-'
268  // itself.
269  if (isInput(PrefixesUnion, Str))
270  return new Arg(getOption(TheInputOptionID), Str, Index++, Str);
271 
272  const Info *Start = OptionInfos.data() + FirstSearchableIndex;
273  const Info *End = OptionInfos.data() + OptionInfos.size();
274  StringRef Name = StringRef(Str).ltrim(PrefixChars);
275 
276  // Search for the first next option which could be a prefix.
277  Start = std::lower_bound(Start, End, Name.data());
278 
279  // Options are stored in sorted order, with '\0' at the end of the
280  // alphabet. Since the only options which can accept a string must
281  // prefix it, we iteratively search for the next option which could
282  // be a prefix.
283  //
284  // FIXME: This is searching much more than necessary, but I am
285  // blanking on the simplest way to make it fast. We can solve this
286  // problem when we move to TableGen.
287  for (; Start != End; ++Start) {
288  unsigned ArgSize = 0;
289  // Scan for first option which is a proper prefix.
290  for (; Start != End; ++Start)
291  if ((ArgSize = matchOption(Start, Str, IgnoreCase)))
292  break;
293  if (Start == End)
294  break;
295 
296  Option Opt(Start, this);
297 
298  if (FlagsToInclude && !Opt.hasFlag(FlagsToInclude))
299  continue;
300  if (Opt.hasFlag(FlagsToExclude))
301  continue;
302 
303  // See if this option matches.
304  if (Arg *A = Opt.accept(Args, Index, ArgSize))
305  return A;
306 
307  // Otherwise, see if this argument was missing values.
308  if (Prev != Index)
309  return nullptr;
310  }
311 
312  // If we failed to find an option and this arg started with /, then it's
313  // probably an input path.
314  if (Str[0] == '/')
315  return new Arg(getOption(TheInputOptionID), Str, Index++, Str);
316 
317  return new Arg(getOption(TheUnknownOptionID), Str, Index++, Str);
318 }
319 
321  unsigned &MissingArgIndex,
322  unsigned &MissingArgCount,
323  unsigned FlagsToInclude,
324  unsigned FlagsToExclude) const {
325  InputArgList Args(ArgArr.begin(), ArgArr.end());
326 
327  // FIXME: Handle '@' args (or at least error on them).
328 
329  MissingArgIndex = MissingArgCount = 0;
330  unsigned Index = 0, End = ArgArr.size();
331  while (Index < End) {
332  // Ingore nullptrs, they are response file's EOL markers
333  if (Args.getArgString(Index) == nullptr) {
334  ++Index;
335  continue;
336  }
337  // Ignore empty arguments (other things may still take them as arguments).
338  StringRef Str = Args.getArgString(Index);
339  if (Str == "") {
340  ++Index;
341  continue;
342  }
343 
344  unsigned Prev = Index;
345  Arg *A = ParseOneArg(Args, Index, FlagsToInclude, FlagsToExclude);
346  assert(Index > Prev && "Parser failed to consume argument.");
347 
348  // Check for missing argument error.
349  if (!A) {
350  assert(Index >= End && "Unexpected parser error.");
351  assert(Index - Prev - 1 && "No missing arguments!");
352  MissingArgIndex = Prev;
353  MissingArgCount = Index - Prev - 1;
354  break;
355  }
356 
357  Args.append(A);
358  }
359 
360  return Args;
361 }
362 
363 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
364  const Option O = Opts.getOption(Id);
365  std::string Name = O.getPrefixedName();
366 
367  // Add metavar, if used.
368  switch (O.getKind()) {
370  llvm_unreachable("Invalid option with help text.");
371 
373  if (const char *MetaVarName = Opts.getOptionMetaVar(Id)) {
374  // For MultiArgs, metavar is full list of all argument names.
375  Name += ' ';
376  Name += MetaVarName;
377  }
378  else {
379  // For MultiArgs<N>, if metavar not supplied, print <value> N times.
380  for (unsigned i=0, e=O.getNumArgs(); i< e; ++i) {
381  Name += " <value>";
382  }
383  }
384  break;
385 
386  case Option::FlagClass:
387  break;
388 
389  case Option::ValuesClass:
390  break;
391 
394  Name += ' ';
398  if (const char *MetaVarName = Opts.getOptionMetaVar(Id))
399  Name += MetaVarName;
400  else
401  Name += "<value>";
402  break;
403  }
404 
405  return Name;
406 }
407 
408 namespace {
409 struct OptionInfo {
410  std::string Name;
411  StringRef HelpText;
412 };
413 } // namespace
414 
416  std::vector<OptionInfo> &OptionHelp) {
417  OS << Title << ":\n";
418 
419  // Find the maximum option length.
420  unsigned OptionFieldWidth = 0;
421  for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {
422  // Limit the amount of padding we are willing to give up for alignment.
423  unsigned Length = OptionHelp[i].Name.size();
424  if (Length <= 23)
425  OptionFieldWidth = std::max(OptionFieldWidth, Length);
426  }
427 
428  const unsigned InitialPad = 2;
429  for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {
430  const std::string &Option = OptionHelp[i].Name;
431  int Pad = OptionFieldWidth - int(Option.size());
432  OS.indent(InitialPad) << Option;
433 
434  // Break on long option names.
435  if (Pad < 0) {
436  OS << "\n";
437  Pad = OptionFieldWidth + InitialPad;
438  }
439  OS.indent(Pad + 1) << OptionHelp[i].HelpText << '\n';
440  }
441 }
442 
443 static const char *getOptionHelpGroup(const OptTable &Opts, OptSpecifier Id) {
444  unsigned GroupID = Opts.getOptionGroupID(Id);
445 
446  // If not in a group, return the default help group.
447  if (!GroupID)
448  return "OPTIONS";
449 
450  // Abuse the help text of the option groups to store the "help group"
451  // name.
452  //
453  // FIXME: Split out option groups.
454  if (const char *GroupHelp = Opts.getOptionHelpText(GroupID))
455  return GroupHelp;
456 
457  // Otherwise keep looking.
458  return getOptionHelpGroup(Opts, GroupID);
459 }
460 
461 void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
462  bool ShowHidden, bool ShowAllAliases) const {
463  PrintHelp(OS, Name, Title, /*Include*/ 0, /*Exclude*/
464  (ShowHidden ? 0 : HelpHidden), ShowAllAliases);
465 }
466 
467 void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
468  unsigned FlagsToInclude, unsigned FlagsToExclude,
469  bool ShowAllAliases) const {
470  OS << "OVERVIEW: " << Title << "\n";
471  OS << '\n';
472  OS << "USAGE: " << Name << " [options] <inputs>\n";
473  OS << '\n';
474 
475  // Render help text into a map of group-name to a list of (option, help)
476  // pairs.
477  using helpmap_ty = std::map<std::string, std::vector<OptionInfo>>;
478  helpmap_ty GroupedOptionHelp;
479 
480  for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
481  unsigned Id = i + 1;
482 
483  // FIXME: Split out option groups.
485  continue;
486 
487  unsigned Flags = getInfo(Id).Flags;
488  if (FlagsToInclude && !(Flags & FlagsToInclude))
489  continue;
490  if (Flags & FlagsToExclude)
491  continue;
492 
493  // If an alias doesn't have a help text, show a help text for the aliased
494  // option instead.
495  const char *HelpText = getOptionHelpText(Id);
496  if (!HelpText && ShowAllAliases) {
497  const Option Alias = getOption(Id).getAlias();
498  if (Alias.isValid())
499  HelpText = getOptionHelpText(Alias.getID());
500  }
501 
502  if (HelpText) {
503  const char *HelpGroup = getOptionHelpGroup(*this, Id);
504  const std::string &OptName = getOptionHelpName(*this, Id);
505  GroupedOptionHelp[HelpGroup].push_back({OptName, HelpText});
506  }
507  }
508 
509  for (helpmap_ty::iterator it = GroupedOptionHelp .begin(),
510  ie = GroupedOptionHelp.end(); it != ie; ++it) {
511  if (it != GroupedOptionHelp .begin())
512  OS << "\n";
513  PrintHelpOptionList(OS, it->first, it->second);
514  }
515 
516  OS.flush();
517 }
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:62
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:235
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:320
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 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:261
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
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
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:443
OptionClass getKind() const
Definition: Option.h:93
#define P(N)
friend const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:244
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
#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
std::vector< std::string > suggestValueCompletions(StringRef Option, StringRef Arg) const
Find possible value for given flags.
Definition: OptTable.cpp:210
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:415
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
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.
auto lower_bound(R &&Range, ForwardIt I) -> decltype(std::begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:859
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:319
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:467
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:250
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:363
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:322
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:821
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