LLVM 17.0.0git
Option.cpp
Go to the documentation of this file.
1//===- Option.cpp - Abstract Driver Options -------------------------------===//
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
10#include "llvm/ADT/Twine.h"
11#include "llvm/Config/llvm-config.h"
12#include "llvm/Option/Arg.h"
13#include "llvm/Option/ArgList.h"
14#include "llvm/Option/Option.h"
17#include "llvm/Support/Debug.h"
20#include <cassert>
21#include <cstring>
22
23using namespace llvm;
24using namespace llvm::opt;
25
27 : Info(info), Owner(owner) {
28 // Multi-level aliases are not supported. This just simplifies option
29 // tracking, it is not an inherent limitation.
30 assert((!Info || !getAlias().isValid() || !getAlias().getAlias().isValid()) &&
31 "Multi-level aliases are not supported.");
32
33 if (Info && getAliasArgs()) {
34 assert(getAlias().isValid() && "Only alias options can have alias args.");
35 assert(getKind() == FlagClass && "Only Flag aliases can have alias args.");
37 "Cannot provide alias args to a flag option.");
38 }
39}
40
41void Option::print(raw_ostream &O) const {
42 O << "<";
43 switch (getKind()) {
44#define P(N) case N: O << #N; break
48 P(FlagClass);
58#undef P
59 }
60
61 if (!Info->Prefixes.empty()) {
62 O << " Prefixes:[";
63 for (size_t I = 0, N = Info->Prefixes.size(); I != N; ++I)
64 O << '"' << Info->Prefixes[I] << (I == N - 1 ? "\"" : "\", ");
65 O << ']';
66 }
67
68 O << " Name:\"" << getName() << '"';
69
70 const Option Group = getGroup();
71 if (Group.isValid()) {
72 O << " Group:";
73 Group.print(O);
74 }
75
76 const Option Alias = getAlias();
77 if (Alias.isValid()) {
78 O << " Alias:";
79 Alias.print(O);
80 }
81
82 if (getKind() == MultiArgClass)
83 O << " NumArgs:" << getNumArgs();
84
85 O << ">\n";
86}
87
88#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
90#endif
91
93 // Aliases are never considered in matching, look through them.
94 const Option Alias = getAlias();
95 if (Alias.isValid())
96 return Alias.matches(Opt);
97
98 // Check exact match.
99 if (getID() == Opt.getID())
100 return true;
101
102 const Option Group = getGroup();
103 if (Group.isValid())
104 return Group.matches(Opt);
105 return false;
106}
107
108std::unique_ptr<Arg> Option::acceptInternal(const ArgList &Args,
109 StringRef Spelling,
110 unsigned &Index) const {
111 const size_t SpellingSize = Spelling.size();
112 const size_t ArgStringSize = StringRef(Args.getArgString(Index)).size();
113 switch (getKind()) {
114 case FlagClass: {
115 if (SpellingSize != ArgStringSize)
116 return nullptr;
117 return std::make_unique<Arg>(*this, Spelling, Index++);
118 }
119 case JoinedClass: {
120 const char *Value = Args.getArgString(Index) + SpellingSize;
121 return std::make_unique<Arg>(*this, Spelling, Index++, Value);
122 }
123 case CommaJoinedClass: {
124 // Always matches.
125 const char *Str = Args.getArgString(Index) + SpellingSize;
126 auto A = std::make_unique<Arg>(*this, Spelling, Index++);
127
128 // Parse out the comma separated values.
129 const char *Prev = Str;
130 for (;; ++Str) {
131 char c = *Str;
132
133 if (!c || c == ',') {
134 if (Prev != Str) {
135 char *Value = new char[Str - Prev + 1];
136 memcpy(Value, Prev, Str - Prev);
137 Value[Str - Prev] = '\0';
138 A->getValues().push_back(Value);
139 }
140
141 if (!c)
142 break;
143
144 Prev = Str + 1;
145 }
146 }
147 A->setOwnsValues(true);
148
149 return A;
150 }
151 case SeparateClass:
152 // Matches iff this is an exact match.
153 if (SpellingSize != ArgStringSize)
154 return nullptr;
155
156 Index += 2;
157 if (Index > Args.getNumInputArgStrings() ||
158 Args.getArgString(Index - 1) == nullptr)
159 return nullptr;
160
161 return std::make_unique<Arg>(*this, Spelling, Index - 2,
162 Args.getArgString(Index - 1));
163 case MultiArgClass: {
164 // Matches iff this is an exact match.
165 if (SpellingSize != ArgStringSize)
166 return nullptr;
167
168 Index += 1 + getNumArgs();
169 if (Index > Args.getNumInputArgStrings())
170 return nullptr;
171
172 auto A = std::make_unique<Arg>(*this, Spelling, Index - 1 - getNumArgs(),
173 Args.getArgString(Index - getNumArgs()));
174 for (unsigned i = 1; i != getNumArgs(); ++i)
175 A->getValues().push_back(Args.getArgString(Index - getNumArgs() + i));
176 return A;
177 }
179 // If this is not an exact match, it is a joined arg.
180 if (SpellingSize != ArgStringSize) {
181 const char *Value = Args.getArgString(Index) + SpellingSize;
182 return std::make_unique<Arg>(*this, Spelling, Index++, Value);
183 }
184
185 // Otherwise it must be separate.
186 Index += 2;
187 if (Index > Args.getNumInputArgStrings() ||
188 Args.getArgString(Index - 1) == nullptr)
189 return nullptr;
190
191 return std::make_unique<Arg>(*this, Spelling, Index - 2,
192 Args.getArgString(Index - 1));
193 }
195 // Always matches.
196 Index += 2;
197 if (Index > Args.getNumInputArgStrings() ||
198 Args.getArgString(Index - 1) == nullptr)
199 return nullptr;
200
201 return std::make_unique<Arg>(*this, Spelling, Index - 2,
202 Args.getArgString(Index - 2) + SpellingSize,
203 Args.getArgString(Index - 1));
204 case RemainingArgsClass: {
205 // Matches iff this is an exact match.
206 if (SpellingSize != ArgStringSize)
207 return nullptr;
208 auto A = std::make_unique<Arg>(*this, Spelling, Index++);
209 while (Index < Args.getNumInputArgStrings() &&
210 Args.getArgString(Index) != nullptr)
211 A->getValues().push_back(Args.getArgString(Index++));
212 return A;
213 }
215 auto A = std::make_unique<Arg>(*this, Spelling, Index);
216 if (SpellingSize != ArgStringSize) {
217 // An inexact match means there is a joined arg.
218 A->getValues().push_back(Args.getArgString(Index) + SpellingSize);
219 }
220 Index++;
221 while (Index < Args.getNumInputArgStrings() &&
222 Args.getArgString(Index) != nullptr)
223 A->getValues().push_back(Args.getArgString(Index++));
224 return A;
225 }
226
227 default:
228 llvm_unreachable("Invalid option kind!");
229 }
230}
231
232std::unique_ptr<Arg> Option::accept(const ArgList &Args, StringRef CurArg,
233 bool GroupedShortOption,
234 unsigned &Index) const {
235 auto A(GroupedShortOption && getKind() == FlagClass
236 ? std::make_unique<Arg>(*this, CurArg, Index)
237 : acceptInternal(Args, CurArg, Index));
238 if (!A)
239 return nullptr;
240
241 const Option &UnaliasedOption = getUnaliasedOption();
242 if (getID() == UnaliasedOption.getID())
243 return A;
244
245 // "A" is an alias for a different flag. For most clients it's more convenient
246 // if this function returns unaliased Args, so create an unaliased arg for
247 // returning.
248
249 // This creates a completely new Arg object for the unaliased Arg because
250 // the alias and the unaliased arg can have different Kinds and different
251 // Values (due to AliasArgs<>).
252
253 // Get the spelling from the unaliased option.
254 StringRef UnaliasedSpelling = Args.MakeArgString(
255 Twine(UnaliasedOption.getPrefix()) + Twine(UnaliasedOption.getName()));
256
257 // It's a bit weird that aliased and unaliased arg share one index, but
258 // the index is mostly use as a memory optimization in render().
259 // Due to this, ArgList::getArgString(A->getIndex()) will return the spelling
260 // of the aliased arg always, while A->getSpelling() returns either the
261 // unaliased or the aliased arg, depending on which Arg object it's called on.
262 auto UnaliasedA =
263 std::make_unique<Arg>(UnaliasedOption, UnaliasedSpelling, A->getIndex());
264 Arg *RawA = A.get();
265 UnaliasedA->setAlias(std::move(A));
266
267 if (getKind() != FlagClass) {
268 // Values are usually owned by the ArgList. The exception are
269 // CommaJoined flags, where the Arg owns the values. For aliased flags,
270 // make the unaliased Arg the owner of the values.
271 // FIXME: There aren't many uses of CommaJoined -- try removing
272 // CommaJoined in favor of just calling StringRef::split(',') instead.
273 UnaliasedA->getValues() = RawA->getValues();
274 UnaliasedA->setOwnsValues(RawA->getOwnsValues());
275 RawA->setOwnsValues(false);
276 return UnaliasedA;
277 }
278
279 // FlagClass aliases can have AliasArgs<>; add those to the unaliased arg.
280 if (const char *Val = getAliasArgs()) {
281 while (*Val != '\0') {
282 UnaliasedA->getValues().push_back(Val);
283
284 // Move past the '\0' to the next argument.
285 Val += strlen(Val) + 1;
286 }
287 }
288 if (UnaliasedOption.getKind() == JoinedClass && !getAliasArgs())
289 // A Flag alias for a Joined option must provide an argument.
290 UnaliasedA->getValues().push_back("");
291 return UnaliasedA;
292}
Defines the llvm::Arg class for parsed arguments.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:492
lazy value info
#define I(x, y, z)
Definition: MD5.cpp:58
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVM Value Representation.
Definition: Value.h:74
ArgList - Ordered collection of driver arguments.
Definition: ArgList.h:116
A concrete instance of a particular driver option.
Definition: Arg.h:34
bool getOwnsValues() const
Definition: Arg.h:103
SmallVectorImpl< const char * > & getValues()
Definition: Arg.h:117
void setOwnsValues(bool Value) const
Definition: Arg.h:104
OptSpecifier - Wrapper class for abstracting references to option IDs.
Definition: OptSpecifier.h:18
unsigned getID() const
Definition: OptSpecifier.h:29
Provide access to the Option info table.
Definition: OptTable.h:40
Option - Abstract representation for a single form of driver argument.
Definition: Option.h:51
const Option getAlias() const
Definition: Option.h:109
void dump() const
Definition: Option.cpp:89
unsigned getNumArgs() const
Definition: Option.h:151
const char * getAliasArgs() const
Get the alias arguments as a \0 separated list.
Definition: Option.h:117
const Option getGroup() const
Definition: Option.h:103
const Option getUnaliasedOption() const
getUnaliasedOption - Return the final option this option aliases (itself, if the option has no alias)...
Definition: Option.h:189
bool matches(OptSpecifier ID) const
matches - Predicate for whether this option is part of the given option (which may be a group).
Definition: Option.cpp:92
Option(const OptTable::Info *Info, const OptTable *Owner)
Definition: Option.cpp:26
void print(raw_ostream &O) const
Definition: Option.cpp:41
@ JoinedOrSeparateClass
Definition: Option.h:65
@ RemainingArgsClass
Definition: Option.h:61
@ JoinedAndSeparateClass
Definition: Option.h:66
@ RemainingArgsJoinedClass
Definition: Option.h:62
StringRef getPrefix() const
Get the default prefix for this option.
Definition: Option.h:126
const OptTable::Info * Info
Definition: Option.h:77
bool isValid() const
Definition: Option.h:83
unsigned getID() const
Definition: Option.h:87
StringRef getName() const
Get the name of this option without any prefix.
Definition: Option.h:98
std::unique_ptr< Arg > accept(const ArgList &Args, StringRef CurArg, bool GroupedShortOption, unsigned &Index) const
Potentially accept the current argument, returning a new Arg instance, or 0 if the option does not ac...
Definition: Option.cpp:232
OptionClass getKind() const
Definition: Option.h:92
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: Arg.h:26
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
#define N
Entry for a single option instance in the option data table.
Definition: OptTable.h:43
ArrayRef< StringLiteral > Prefixes
A null terminated array of prefix strings to apply to name while matching.
Definition: OptTable.h:46