1//===- OptionParserEmitter.cpp - Table Driven Command Option Line Parsing -===//
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 "OptEmitter.h"
10#include "llvm/ADT/STLExtras.h"
11#include "llvm/ADT/SmallString.h"
12#include "llvm/ADT/SmallVector.h"
13#include "llvm/ADT/StringExtras.h"
14#include "llvm/ADT/StringMap.h"
15#include "llvm/ADT/Twine.h"
16#include "llvm/Support/raw_ostream.h"
17#include "llvm/TableGen/Error.h"
18#include "llvm/TableGen/Record.h"
19#include "llvm/TableGen/StringToOffsetTable.h"
20#include "llvm/TableGen/TableGenBackend.h"
21#include <array>
22#include <cstring>
23#include <map>
24#include <set>
25
26using namespace llvm;
27
28static std::string getOptionName(const Record &R) {
29 // Use the record name unless EnumName is defined.
30 if (isa<UnsetInit>(Val: R.getValueInit(FieldName: "EnumName")))
31 return R.getName().str();
32
33 return R.getValueAsString(FieldName: "EnumName").str();
34}
35
36// Only pass EmitComment for short strings that cannot contain "*/".
37static void writeStrTableOffset(raw_ostream &OS,
38 const StringToOffsetTable &Table,
39 llvm::StringRef Str, bool EmitComment = false) {
40 std::optional<unsigned> Offset = Table.GetStringOffset(Str);
41 if (!Offset)
42 PrintFatalError(Msg: "string was not added to the option string table: " + Str);
43 OS << *Offset;
44 if (EmitComment) {
45 OS << " /* ";
46 OS.write_escaped(Str);
47 OS << " */";
48 }
49}
50
51static raw_ostream &writeCstring(raw_ostream &OS, llvm::StringRef Str) {
52 OS << '"';
53 OS.write_escaped(Str);
54 OS << '"';
55 return OS;
56}
57
58static StringRef getOptionalString(const Record &R, StringRef Field) {
59 return R.getValueAsOptionalString(FieldName: Field).value_or(u: "");
60}
61
62// Offset zero is the empty string and stands for an unset HelpText. A
63// HelpText<""> marks an option as deliberately undocumented, so it maps to a
64// second empty string that the table does not put at offset zero.
65static StringRef getHelpText(const Record &R) {
66 std::optional<StringRef> S = R.getValueAsOptionalString(FieldName: "HelpText");
67 if (!S)
68 return StringRef();
69 return S->empty() ? StringRef("\0", 1) : *S;
70}
71
72// The string table appends the empty string that terminates the list.
73static std::string getAliasArgsBlob(const Record &R) {
74 std::string Blob;
75 for (StringRef AliasArg : R.getValueAsListOfStrings(FieldName: "AliasArgs")) {
76 if (AliasArg.empty())
77 PrintFatalError(ErrorLoc: R.getLoc(), Msg: "AliasArgs entries must not be empty");
78 Blob += AliasArg;
79 Blob += '\0';
80 }
81 return Blob;
82}
83
84static std::string getOptionPrefixedName(const Record &R) {
85 std::vector<StringRef> Prefixes = R.getValueAsListOfStrings(FieldName: "Prefixes");
86 StringRef Name = R.getValueAsString(FieldName: "Name");
87
88 if (Prefixes.empty())
89 return Name.str();
90
91 return (Prefixes[0] + Twine(Name)).str();
92}
93
94class MarshallingInfo {
95public:
96 static constexpr const char *MacroName = "OPTION_WITH_MARSHALLING";
97 const Record &R;
98 bool ShouldAlwaysEmit = false;
99 StringRef MacroPrefix;
100 StringRef KeyPath;
101 StringRef DefaultValue;
102 StringRef NormalizedValuesScope;
103 StringRef ImpliedCheck;
104 StringRef ImpliedValue;
105 StringRef ShouldParse;
106 StringRef Normalizer;
107 StringRef Denormalizer;
108 int TableIndex = -1;
109 std::vector<StringRef> Values;
110 std::vector<StringRef> NormalizedValues;
111 std::string ValueTableName;
112
113 static size_t NextTableIndex;
114
115 static constexpr const char *ValueTablePreamble = R"(
116struct SimpleEnumValue {
117 const char *Name;
118 unsigned Value;
119};
120
121struct SimpleEnumValueTable {
122 const SimpleEnumValue *Table;
123 unsigned Size;
124};
125)";
126
127 static constexpr const char *ValueTablesDecl =
128 "static const SimpleEnumValueTable SimpleEnumValueTables[] = ";
129
130 MarshallingInfo(const Record &R) : R(R) {}
131
132 std::string getMacroName() const {
133 return (MacroPrefix + MarshallingInfo::MacroName).str();
134 }
135
136 void emit(raw_ostream &OS) const {
137 OS << ShouldParse;
138 OS << ", ";
139 OS << ShouldAlwaysEmit;
140 OS << ", ";
141 OS << KeyPath;
142 OS << ", ";
143 emitScopedNormalizedValue(OS, NormalizedValue: DefaultValue);
144 OS << ", ";
145 OS << ImpliedCheck;
146 OS << ", ";
147 emitScopedNormalizedValue(OS, NormalizedValue: ImpliedValue);
148 OS << ", ";
149 OS << Normalizer;
150 OS << ", ";
151 OS << Denormalizer;
152 OS << ", ";
153 OS << TableIndex;
154 }
155
156 std::optional<StringRef> emitValueTable(raw_ostream &OS) const {
157 if (TableIndex == -1)
158 return {};
159 OS << "static const SimpleEnumValue " << ValueTableName << "[] = {\n";
160 for (unsigned I = 0, E = Values.size(); I != E; ++I) {
161 OS << "{";
162 writeCstring(OS, Str: Values[I]);
163 OS << ",";
164 OS << "static_cast<unsigned>(";
165 emitScopedNormalizedValue(OS, NormalizedValue: NormalizedValues[I]);
166 OS << ")},";
167 }
168 OS << "};\n";
169 return StringRef(ValueTableName);
170 }
171
172private:
173 void emitScopedNormalizedValue(raw_ostream &OS,
174 StringRef NormalizedValue) const {
175 if (!NormalizedValuesScope.empty())
176 OS << NormalizedValuesScope << "::";
177 OS << NormalizedValue;
178 }
179};
180
181size_t MarshallingInfo::NextTableIndex = 0;
182
183static MarshallingInfo createMarshallingInfo(const Record &R) {
184 assert(!isa<UnsetInit>(R.getValueInit("KeyPath")) &&
185 !isa<UnsetInit>(R.getValueInit("DefaultValue")) &&
186 "MarshallingInfo must have a provide a keypath, default value and a "
187 "value merger");
188
189 MarshallingInfo Ret(R);
190
191 Ret.ShouldAlwaysEmit = R.getValueAsBit(FieldName: "ShouldAlwaysEmit");
192 Ret.MacroPrefix = R.getValueAsString(FieldName: "MacroPrefix");
193 Ret.KeyPath = R.getValueAsString(FieldName: "KeyPath");
194 Ret.DefaultValue = R.getValueAsString(FieldName: "DefaultValue");
195 Ret.NormalizedValuesScope = R.getValueAsString(FieldName: "NormalizedValuesScope");
196 Ret.ImpliedCheck = R.getValueAsString(FieldName: "ImpliedCheck");
197 Ret.ImpliedValue =
198 R.getValueAsOptionalString(FieldName: "ImpliedValue").value_or(u&: Ret.DefaultValue);
199
200 Ret.ShouldParse = R.getValueAsString(FieldName: "ShouldParse");
201 Ret.Normalizer = R.getValueAsString(FieldName: "Normalizer");
202 Ret.Denormalizer = R.getValueAsString(FieldName: "Denormalizer");
203
204 if (!isa<UnsetInit>(Val: R.getValueInit(FieldName: "NormalizedValues"))) {
205 assert(!isa<UnsetInit>(R.getValueInit("Values")) &&
206 "Cannot provide normalized values for value-less options");
207 Ret.TableIndex = MarshallingInfo::NextTableIndex++;
208 Ret.NormalizedValues = R.getValueAsListOfStrings(FieldName: "NormalizedValues");
209 Ret.Values.reserve(n: Ret.NormalizedValues.size());
210 Ret.ValueTableName = getOptionName(R) + "ValueTable";
211
212 StringRef ValuesStr = R.getValueAsString(FieldName: "Values");
213 for (;;) {
214 size_t Idx = ValuesStr.find(C: ',');
215 if (Idx == StringRef::npos)
216 break;
217 if (Idx > 0)
218 Ret.Values.push_back(x: ValuesStr.slice(Start: 0, End: Idx));
219 ValuesStr = ValuesStr.substr(Start: Idx + 1);
220 }
221 if (!ValuesStr.empty())
222 Ret.Values.push_back(x: ValuesStr);
223
224 assert(Ret.Values.size() == Ret.NormalizedValues.size() &&
225 "The number of normalized values doesn't match the number of "
226 "values");
227 }
228
229 return Ret;
230}
231
232// -foo-bar becomes foo_bar, or bar if Prefix is "foo-".
233static std::string getSpellingIdentifier(const Record &R,
234 StringRef Prefix = "") {
235 StringRef Spelling = R.getValueAsString(FieldName: "Name");
236 Spelling.consume_front(Prefix);
237 std::string ID = Spelling.str();
238 llvm::replace(Range&: ID, OldValue: '-', NewValue: '_');
239 if (ID.empty() || isDigit(C: ID[0]) ||
240 !all_of(Range&: ID, P: [](char C) { return isAlnum(C) || C == '_'; }))
241 PrintFatalError(ErrorLoc: R.getLoc(), Msg: "the spelling is not an identifier; name the "
242 "defm");
243 return ID;
244}
245
246// `defm : BoolField<"foo-bar", ...>` declares member foo_bar, and a named defm
247// names it.
248static std::string getMemberName(const Record &R, StringRef Prefix) {
249 StringRef Name = R.getValueAsString(FieldName: "FieldName");
250 return Name.starts_with(Prefix: "anonymous_") ? getSpellingIdentifier(R, Prefix)
251 : Name.str();
252}
253
254// The OPT_ name of an option of an OptionsStruct. `defm :` rows are named
255// after the spelling: -foo-bar is OPT_foo_bar.
256static std::string getStructOptionID(const Record &R) {
257 if (!R.getName().starts_with(Prefix: "anonymous_"))
258 return getOptionName(R);
259 return getSpellingIdentifier(R);
260}
261
262// The preprocessor expression of R's Condition, or "" if it has none.
263static StringRef getCondition(const Record &R) {
264 const RecordVal *V = R.getValue(Name: "Condition");
265 const auto *DI = V ? dyn_cast<DefInit>(Val: V->getValue()) : nullptr;
266 return DI ? DI->getDef()->getValueAsString(FieldName: "Expr") : "";
267}
268
269namespace {
270// Wraps what is emitted during its lifetime in `#if Condition` where R has one.
271class ConditionScope {
272 raw_ostream &OS;
273 StringRef Condition;
274
275public:
276 ConditionScope(raw_ostream &OS, const Record &R)
277 : OS(OS), Condition(getCondition(R)) {
278 if (!Condition.empty())
279 OS << "#if " << Condition << '\n';
280 }
281 ~ConditionScope() {
282 if (!Condition.empty())
283 OS << "#endif\n";
284 }
285};
286} // namespace
287
288// Emits the OPT_ IDs of an OptionsStruct, which its table rows name.
289static void emitStructOptionIDs(ArrayRef<const Record *> Groups,
290 ArrayRef<const Record *> Opts,
291 raw_ostream &OS) {
292 OS << "namespace {\nenum ID : unsigned {\n OPT_INVALID = 0,\n";
293 for (const Record *R : Groups)
294 OS << " OPT_" << getOptionName(R: *R) << ",\n";
295 for (const Record *R : Opts) {
296 ConditionScope CS(OS, *R);
297 OS << " OPT_" << getStructOptionID(R: *R) << ",\n";
298 }
299 OS << "};\n} // namespace\n\n";
300}
301
302// Emits the struct an OptionsStruct def declares: its declaration under
303// OPTIONS_STRUCT_DECL, and under OPTIONS_STRUCT_DEFS the default values, the
304// option table, and apply(), which sets the member an argument names.
305static void emitOptionsStruct(const Record &Struct,
306 ArrayRef<const Record *> Groups,
307 ArrayRef<const Record *> Opts, raw_ostream &OS) {
308 struct Member {
309 std::string Name;
310 StringRef Type, Default, Spelling;
311 };
312 std::vector<const Record *> Fields;
313 for (const Record *R : Opts) {
314 StringRef Kind = R->getValueAsDef(FieldName: "Kind")->getValueAsString(FieldName: "Name");
315 if (!R->getValue(Name: "FieldName")) {
316 if (Kind != "Input" && Kind != "Unknown" && !R->getValue(Name: "AliasTarget"))
317 PrintFatalError(ErrorLoc: R->getLoc(), Msg: "an option of an OptionsStruct must be "
318 "declared with BoolField, ValueField or "
319 "AliasOf");
320 continue;
321 }
322 if (Kind != "FlagOrEq" && Kind != "SeparateOrEq")
323 PrintFatalError(ErrorLoc: R->getLoc(),
324 Msg: "a member is set by a FlagOrEq or SeparateOrEq");
325 StringRef Type = R->getValueAsString(FieldName: "FieldType");
326 if (Kind == "FlagOrEq" && Type != "bool" && Type != "llvm::BoolOrDefault" &&
327 !R->getValue(Name: "BareValue"))
328 PrintFatalError(ErrorLoc: R->getLoc(), Msg: "a FlagOrEq sets a bool or has a BareValue");
329 Fields.push_back(x: R);
330 }
331 // Members in declaration order.
332 std::vector<const Record *> ByID = Fields;
333 llvm::sort(C&: ByID, Comp: [](const Record *A, const Record *B) {
334 return A->getID() < B->getID();
335 });
336 StringRef Prefix = Struct.getValueAsString(FieldName: "MemberPrefix");
337 std::vector<Member> Members;
338 StringMap<StringRef> MemberSpelling;
339 for (const Record *R : ByID) {
340 Member M{.Name: getMemberName(R: *R, Prefix), .Type: R->getValueAsString(FieldName: "FieldType"),
341 .Default: R->getValueAsString(FieldName: "FieldDefault"), .Spelling: R->getValueAsString(FieldName: "Name")};
342 auto [It, Inserted] = MemberSpelling.try_emplace(Key: M.Name, Args&: M.Spelling);
343 if (!Inserted)
344 PrintFatalError(ErrorLoc: R->getLoc(),
345 Msg: "member '" + M.Name + "' is also set by -" + It->second);
346 Members.push_back(x: M);
347 }
348
349 StringRef Name = Struct.getName();
350 OS << "\n#ifdef OPTIONS_STRUCT_DECL\n#undef OPTIONS_STRUCT_DECL\n";
351 OS << "#include \"llvm/ADT/ArrayRef.h\"\n";
352 OS << "#include \"llvm/ADT/BoolOrDefault.h\"\n";
353 OS << "#include \"llvm/ADT/StringRef.h\"\n";
354 OS << "#include \"llvm/Support/Allocator.h\"\n";
355 OS << "#include \"llvm/Support/LibraryOptionsContext.h\"\n\n";
356 StringRef Namespace = Struct.getValueAsString(FieldName: "Namespace");
357 OS << "namespace llvm {\nnamespace opt {\nclass Arg;\n";
358 OS << "class LibraryOptionsParser;\n";
359 OS << "class OptTable;\n} // namespace opt\n} // namespace llvm\n\n";
360 OS << "namespace " << Namespace << " {\n";
361 OS << "struct " << Name << " {\n";
362 if (Namespace != "llvm")
363 OS << " using StringRef = llvm::StringRef;\n";
364 for (auto [R, M] : llvm::zip_equal(t&: ByID, u&: Members)) {
365 ConditionScope CS(OS, *R);
366 OS << " " << M.Type << " " << M.Name << "{" << M.Default << "};\n";
367 }
368 OS << "\n static const llvm::opt::OptTable &optTable();\n";
369 OS << " /// Sets the member that \\p A names, allocating a list from \\p "
370 "Alloc.\n /// Returns false if the value is invalid.\n";
371 OS << " bool apply(const llvm::opt::Arg &A, llvm::BumpPtrAllocator "
372 "&Alloc);\n";
373 OS << "\nprivate:\n friend class llvm::cl::LibraryOptionsContext;\n"
374 " friend class llvm::opt::LibraryOptionsParser;\n";
375 OS << "\n static const " << Name << " Default;\n";
376 OS << "};\n} // namespace " << Namespace << "\n";
377 OS << "#endif // OPTIONS_STRUCT_DECL\n";
378
379 std::string Qualified = (Namespace + "::" + Name).str();
380 OS << "\n#ifdef OPTIONS_STRUCT_DEFS\n#undef OPTIONS_STRUCT_DEFS\n";
381 OS << "LLVM_REQUIRE_CONSTANT_INITIALIZATION const " << Qualified << " "
382 << Qualified << "::Default;\n\n";
383 OS << "const llvm::opt::OptTable &" << Qualified << "::optTable() {\n";
384 OS << " static const llvm::opt::LibraryOptTable T(optionTables());\n";
385 OS << " return T;\n}\n\n";
386 OS << "bool " << Qualified
387 << "::apply(const llvm::opt::Arg &A, llvm::BumpPtrAllocator &Alloc) {\n";
388 OS << " switch (A.getOption().getID()) {\n";
389 for (const Record *R : Fields) {
390 ConditionScope CS(OS, *R);
391 OS << " case OPT_" << getStructOptionID(R: *R) << ":\n";
392 std::string Member = getMemberName(R: *R, Prefix);
393 if (R->getValue(Name: "BareValue"))
394 OS << " if (!A.getNumValues()) { " << Member << " = "
395 << R->getValueAsString(FieldName: "BareValue") << "; return true; }\n";
396 if (!isa<UnsetInit>(Val: R->getValueInit(FieldName: "NormalizedValues"))) {
397 SmallVector<StringRef> Values;
398 R->getValueAsString(FieldName: "Values").split(A&: Values, Separator: ',');
399 std::vector<StringRef> Enumerators =
400 R->getValueAsListOfStrings(FieldName: "NormalizedValues");
401 if (Values.size() != Enumerators.size())
402 PrintFatalError(ErrorLoc: R->getLoc(), Msg: "an EnumField needs one enumerator per "
403 "value");
404 // The generic lambda sets a scalar, a std::optional, or a list element.
405 OS << " return llvm::opt::parseArgValue(A.getValue(), " << Member
406 << ", Alloc, [](llvm::StringRef V, auto &X) {\n";
407 for (auto [Value, Enumerator] : llvm::zip_equal(t&: Values, u&: Enumerators))
408 OS << " if (V == \"" << Value
409 << "\") {\n X = " << Enumerator
410 << ";\n return true;\n }\n";
411 OS << " return false;\n });\n";
412 continue;
413 }
414 // A FlagOrEq without a value means =true.
415 StringRef Value =
416 R->getValueAsDef(FieldName: "Kind")->getValueAsString(FieldName: "Name") == "FlagOrEq"
417 ? "A.getNumValues() ? A.getValue() : \"true\""
418 : "A.getValue()";
419 OS << " return llvm::opt::parseArgValue(" << Value << ", " << Member
420 << ", Alloc);\n";
421 }
422 OS << " }\n llvm_unreachable(\"option without a member\");\n}\n";
423 OS << "#endif // OPTIONS_STRUCT_DEFS\n";
424}
425
426/// OptionParserEmitter - This tablegen backend takes an input .td file
427/// describing a list of options and emits a data structure for parsing and
428/// working with those options when given an input command line.
429static void emitOptionParser(const RecordKeeper &Records, raw_ostream &OS) {
430 // Get the option groups and options.
431 ArrayRef<const Record *> Groups =
432 Records.getAllDerivedDefinitions(ClassName: "OptionGroup");
433 std::vector<const Record *> Opts = Records.getAllDerivedDefinitions(ClassName: "Option");
434 llvm::sort(C&: Opts, Comp: IsOptionRecordsLess);
435
436 std::vector<const Record *> SubCommands =
437 Records.getAllDerivedDefinitions(ClassName: "SubCommand");
438
439 ArrayRef<const Record *> Structs =
440 Records.getAllDerivedDefinitionsIfDefined(ClassName: "OptionsStruct");
441 if (Structs.size() > 1)
442 PrintFatalError(ErrorLoc: Structs[1]->getLoc(), Msg: "only one OptionsStruct is allowed");
443
444 StringMap<const Record *> Members;
445 for (const Record *R : Opts)
446 if (R->getValue(Name: "FieldName"))
447 Members[R->getValueAsString(FieldName: "Name")] = R;
448 DenseMap<const Record *, const Record *> AliasTargets;
449 for (const Record *R : Opts) {
450 if (!R->getValue(Name: "AliasTarget"))
451 continue;
452 StringRef Target = R->getValueAsString(FieldName: "AliasTarget");
453 const Record *T = Members.lookup(Key: Target);
454 if (!T)
455 PrintFatalError(ErrorLoc: R->getLoc(),
456 Msg: "'-" + Target +
457 "' is not an option of the OptionsStruct");
458 if (!getCondition(R: *T).empty())
459 PrintFatalError(ErrorLoc: R->getLoc(), Msg: "an alias cannot refer to an option with a "
460 "Condition");
461 AliasTargets[R] = T;
462 }
463
464 emitSourceFileHeader(Desc: "Option Parsing Definitions", OS);
465
466 // Generate prefix groups.
467 using PrefixKeyT = SmallVector<SmallString<2>, 2>;
468 using PrefixesT = std::map<PrefixKeyT, unsigned>;
469 PrefixesT Prefixes;
470 Prefixes.try_emplace(k: PrefixKeyT(), args: 0);
471 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
472 std::vector<StringRef> RPrefixes = R.getValueAsListOfStrings(FieldName: "Prefixes");
473 PrefixKeyT PrefixKey(RPrefixes.begin(), RPrefixes.end());
474 Prefixes.try_emplace(k: PrefixKey, args: 0);
475 }
476
477 // Generate sub command groups.
478 using SubCommandKeyT = SmallVector<StringRef, 2>;
479 using SubCommandIDsT = std::map<SubCommandKeyT, unsigned>;
480 SubCommandIDsT SubCommandIDs;
481
482 auto GetSubCommandIDsOffset = [&SubCommandIDs](const Record &R) {
483 SubCommandKeyT SubCommandKey;
484 for (const Record *SubCommand : R.getValueAsListOfDefs(FieldName: "SubCommands"))
485 SubCommandKey.push_back(Elt: SubCommand->getName());
486 return SubCommandIDs[SubCommandKey];
487 };
488
489 SubCommandIDs.try_emplace(k: SubCommandKeyT(), args: 0);
490 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
491 std::vector<const Record *> RSubCommands =
492 R.getValueAsListOfDefs(FieldName: "SubCommands");
493 SubCommandKeyT SubCommandKey;
494 for (const auto &SubCommand : RSubCommands)
495 SubCommandKey.push_back(Elt: SubCommand->getName());
496 SubCommandIDs.try_emplace(k: SubCommandKey, args: 0);
497 }
498
499 llvm::StringToOffsetTable Table;
500 for (const auto &[PrefixSet, _] : Prefixes)
501 for (const auto &Prefix : PrefixSet)
502 Table.GetOrAddStringOffset(Str: Prefix);
503 for (const Record &R : llvm::make_pointee_range(Range&: Groups)) {
504 Table.GetOrAddStringOffset(Str: R.getValueAsString(FieldName: "Name"));
505 Table.GetOrAddStringOffset(Str: getHelpText(R));
506 }
507 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
508 Table.GetOrAddStringOffset(Str: getOptionPrefixedName(R));
509 Table.GetOrAddStringOffset(Str: getHelpText(R));
510 Table.GetOrAddStringOffset(Str: getOptionalString(R, Field: "MetaVarName"));
511 Table.GetOrAddStringOffset(Str: getOptionalString(R, Field: "Values"));
512 Table.GetOrAddStringOffset(Str: getAliasArgsBlob(R));
513 for (const Record *V : R.getValueAsListOfDefs(FieldName: "HelpTextsForVariants"))
514 Table.GetOrAddStringOffset(Str: V->getValueAsString(FieldName: "Text"));
515 }
516
517 // Flags and Visibility name enumerators of the including tool. An option
518 // inherits its group's. Names are sorted so that equal masks share an
519 // InfoExtra row.
520 auto GetMask = [](const Record &R, StringRef Field) {
521 std::set<StringRef> Names;
522 for (const Init *I : *R.getValueAsListInit(FieldName: Field))
523 Names.insert(x: cast<DefInit>(Val: I)->getDef()->getName());
524 if (const DefInit *DI = dyn_cast<DefInit>(Val: R.getValueInit(FieldName: "Group")))
525 for (const Init *I : *DI->getDef()->getValueAsListInit(FieldName: Field))
526 Names.insert(x: cast<DefInit>(Val: I)->getDef()->getName());
527 std::string Mask;
528 raw_string_ostream MaskOS(Mask);
529 ListSeparator Sep(" | ");
530 for (StringRef Name : Names)
531 MaskOS << Sep << "static_cast<unsigned>(" << Name << ")";
532 return Mask.empty() ? std::string("0") : Mask;
533 };
534
535 // IDs are 1-based positions in the table, which lists groups first.
536 DenseMap<const Record *, unsigned> OptionID;
537 for (const Record &R : llvm::make_pointee_range(Range&: Groups))
538 OptionID.try_emplace(Key: &R, Args: OptionID.size() + 1);
539 for (const Record &R : llvm::make_pointee_range(Range&: Opts))
540 OptionID.try_emplace(Key: &R, Args: OptionID.size() + 1);
541 // An OptionsStruct's rows name the IDs, since a false Condition omits a row
542 // and shifts the IDs after it.
543 auto GetRefID = [&](const Record &R, StringRef Field) -> std::string {
544 const Record *Ref = Field == "Alias" ? AliasTargets.lookup(Val: &R) : nullptr;
545 if (const auto *DI = dyn_cast<DefInit>(Val: R.getValueInit(FieldName: Field)))
546 Ref = DI->getDef();
547 if (!Ref)
548 return "0";
549 if (Structs.empty())
550 return utostr(X: OptionID.lookup(Val: Ref));
551 return "OPT_" + getStructOptionID(R: *Ref);
552 };
553
554 OS << "/////////\n";
555 OS << "// Tables\n\n";
556 // An OptionsStruct's definitions use the tables.
557 OS << (Structs.empty()
558 ? "#ifdef OPTTABLE_CODE\n"
559 : "#if defined(OPTTABLE_CODE) || defined(OPTIONS_STRUCT_DEFS)\n");
560 if (!Structs.empty())
561 emitStructOptionIDs(Groups, Opts, OS);
562 // A function rather than an object: the object needs dynamic relocations.
563 OS << "static llvm::opt::OptTable::Tables optionTables() {\n";
564 // An OptionsStruct's .cpp has no using-directive for llvm::opt.
565 if (!Structs.empty())
566 OS << " using llvm::opt::DefaultVis, llvm::opt::HelpHidden,\n"
567 " llvm::opt::RenderAsInput, llvm::opt::RenderJoined,\n"
568 " llvm::opt::RenderSeparate;\n";
569 Table.EmitStringTableDef(OS, Name: "OptionStrTable");
570 OS << "\n";
571
572 // Dump prefixes.
573 OS << " static constexpr llvm::StringTable::Offset OptionPrefixesTable[] = "
574 "{\n";
575 {
576 // Ensure the first prefix set is always empty.
577 assert(!Prefixes.empty() &&
578 "We should always emit an empty set of prefixes");
579 assert(Prefixes.begin()->first.empty() &&
580 "First prefix set should always be empty");
581 llvm::ListSeparator Sep(",\n");
582 unsigned CurIndex = 0;
583 for (auto &[Prefix, PrefixIndex] : Prefixes) {
584 // First emit the number of prefix strings in this list of prefixes.
585 OS << Sep << " " << Prefix.size() << " /* prefixes */";
586 PrefixIndex = CurIndex;
587 if (PrefixIndex > 255)
588 PrintFatalError(Msg: "too many distinct prefix sets");
589 assert((CurIndex == 0 || !Prefix.empty()) &&
590 "Only first prefix set should be empty!");
591 for (const auto &PrefixKey : Prefix)
592 OS << ", " << *Table.GetStringOffset(Str: PrefixKey) << " /* '" << PrefixKey
593 << "' */";
594 CurIndex += Prefix.size() + 1;
595 }
596 }
597 OS << "\n };\n\n";
598
599 // Dump help text variants. Each option's variants form a run ended by a zero
600 // row; offset 0 is the empty run.
601 OS << " static constexpr llvm::opt::OptTable::HelpTextVariant "
602 "OptionHelpTextVariantsTable[] = {\n";
603 DenseMap<const Record *, unsigned> HelpTextVariantsOffset;
604 unsigned NumVariantRows = 1;
605 OS << " {0, 0},\n";
606 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
607 std::vector<const Record *> Variants =
608 R.getValueAsListOfDefs(FieldName: "HelpTextsForVariants");
609 if (Variants.empty())
610 continue;
611 HelpTextVariantsOffset[&R] = NumVariantRows;
612 NumVariantRows += Variants.size() + 1;
613 for (const Record *V : Variants) {
614 const ListInit *Vis = V->getValueAsListInit(FieldName: "Visibilities");
615 if (Vis->empty())
616 PrintFatalError(ErrorLoc: V->getLoc(), Msg: "HelpTextVariant needs a visibility");
617 OS << " {";
618 ListSeparator Sep(" | ");
619 for (const Init *I : *Vis)
620 OS << Sep << I->getAsUnquotedString();
621 OS << ", ";
622 writeStrTableOffset(OS, Table, Str: V->getValueAsString(FieldName: "Text"));
623 OS << "},\n";
624 }
625 OS << " {0, 0},\n";
626 }
627 OS << " };\n\n";
628
629 // Dump subcommands.
630 if (!SubCommands.empty()) {
631 OS << " static constexpr llvm::opt::OptTable::SubCommand "
632 "OptionSubCommands[] = {\n";
633 for (const Record *SubCommand : SubCommands) {
634 OS << " { \"" << SubCommand->getValueAsString(FieldName: "Name") << "\", ";
635 OS << "\"" << SubCommand->getValueAsString(FieldName: "HelpText") << "\", ";
636 OS << "\"" << SubCommand->getValueAsString(FieldName: "Usage") << "\" },\n";
637 }
638 OS << " };\n\n";
639 }
640
641 // Dump subcommand IDs.
642 OS << " static constexpr unsigned OptionSubCommandIDsTable[] = {\n";
643 {
644 // Ensure the first subcommand set is always empty.
645 assert(!SubCommandIDs.empty() &&
646 "We should always emit an empty set of subcommands");
647 assert(SubCommandIDs.begin()->first.empty() &&
648 "First subcommand set should always be empty");
649 llvm::ListSeparator Sep(",\n");
650 unsigned CurIndex = 0;
651 for (auto &[SubCommand, SubCommandIndex] : SubCommandIDs) {
652 // First emit the number of subcommand strings in this list of
653 // subcommands.
654 OS << Sep << " " << SubCommand.size() << " /* subcommands */";
655 SubCommandIndex = CurIndex;
656 assert((CurIndex == 0 || !SubCommand.empty()) &&
657 "Only first subcommand set should be empty!");
658 for (const auto &SubCommandKey : SubCommand) {
659 auto It = llvm::find_if(Range&: SubCommands, P: [&](const Record *R) {
660 return R->getName() == SubCommandKey;
661 });
662 assert(It != SubCommands.end() && "SubCommand not found");
663 OS << ", " << std::distance(first: SubCommands.begin(), last: It) << " /* '"
664 << SubCommandKey << "' */";
665 }
666 CurIndex += SubCommand.size() + 1;
667 }
668 }
669 OS << "\n };\n\n";
670
671 // Fields that are rarely set or take few distinct values, in
672 // OptTable::InfoExtra order. Options with equal values share a row; row 0 is
673 // all zero.
674 OS << " static constexpr llvm::opt::OptTable::InfoExtra "
675 "OptionInfoExtrasTable[] = {\n {0, 0, 0, 0, 0, 0, 0, 0},\n";
676 std::map<std::array<std::string, 8>, unsigned> ExtraRows;
677 ExtraRows.try_emplace(k: {"0", "0", "0", "0", "0", "0", "0", "0"}, args: 0);
678 DenseMap<const Record *, unsigned> ExtraOffset;
679 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
680 int64_t NumArgs = R.getValueAsInt(FieldName: "NumArgs");
681 if (NumArgs < 0 || NumArgs > 255)
682 PrintFatalError(ErrorLoc: R.getLoc(), Msg: "NumArgs must be in [0, 255]");
683 std::array<std::string, 8> Row = {
684 utostr(X: *Table.GetStringOffset(Str: getOptionalString(R, Field: "MetaVarName"))),
685 utostr(X: *Table.GetStringOffset(Str: getAliasArgsBlob(R))),
686 utostr(X: *Table.GetStringOffset(Str: getOptionalString(R, Field: "Values"))),
687 GetMask(R, "Flags"),
688 GetMask(R, "Visibility"),
689 utostr(X: HelpTextVariantsOffset.lookup(Val: &R)),
690 utostr(X: GetSubCommandIDsOffset(R)),
691 utostr(X: NumArgs)};
692 auto [It, Inserted] = ExtraRows.try_emplace(k: Row, args: ExtraRows.size());
693 if (Inserted) {
694 OS << " {";
695 interleaveComma(c: Row, os&: OS);
696 OS << "},\n";
697 }
698 ExtraOffset[&R] = It->second;
699 }
700 OS << " };\n\n";
701
702 // Dump the option table in OptTable::Info field order.
703 OS << " static constexpr llvm::opt::OptTable::Info OptionInfoTable[] = {\n";
704 for (const Record &R : llvm::make_pointee_range(Range&: Groups)) {
705 OS << " {";
706 writeStrTableOffset(OS, Table, Str: R.getValueAsString(FieldName: "Name"),
707 /*EmitComment=*/true);
708 OS << ", ";
709 writeStrTableOffset(OS, Table, Str: getHelpText(R));
710 OS << ", " << GetRefID(R, "Group")
711 << ", 0, 0, 0, llvm::opt::Option::GroupClass},\n";
712 }
713 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
714 ConditionScope CS(OS, R);
715 OS << " {";
716 writeStrTableOffset(OS, Table, Str: getOptionPrefixedName(R),
717 /*EmitComment=*/true);
718 OS << ", ";
719 writeStrTableOffset(OS, Table, Str: getHelpText(R));
720 OS << ", " << GetRefID(R, "Group") << ", " << GetRefID(R, "Alias");
721 OS << ", " << ExtraOffset.lookup(Val: &R);
722 std::vector<StringRef> RPrefixes = R.getValueAsListOfStrings(FieldName: "Prefixes");
723 OS << ", " << Prefixes[PrefixKeyT(RPrefixes.begin(), RPrefixes.end())];
724 // An AliasOf without AliasArgs takes its target's kind.
725 const Record *KindR = AliasTargets.lookup(Val: &R);
726 if (!KindR || !R.getValueAsListOfStrings(FieldName: "AliasArgs").empty())
727 KindR = &R;
728 OS << ", llvm::opt::Option::"
729 << KindR->getValueAsDef(FieldName: "Kind")->getValueAsString(FieldName: "Name") << "Class},\n";
730 }
731 OS << " };\n\n";
732
733 OS << " return {OptionStrTable, OptionPrefixesTable,\n";
734 OS << " OptionInfoTable, OptionInfoExtrasTable, "
735 "OptionHelpTextVariantsTable, "
736 << (SubCommands.empty() ? "{}" : "OptionSubCommands")
737 << ", OptionSubCommandIDsTable};\n";
738 OS << "}\n";
739 OS << "#undef OPTTABLE_CODE\n";
740 OS << (Structs.empty()
741 ? "#endif // OPTTABLE_CODE\n\n"
742 : "#endif // OPTTABLE_CODE || OPTIONS_STRUCT_DEFS\n\n");
743
744 if (!Structs.empty())
745 emitOptionsStruct(Struct: *Structs[0], Groups, Opts, OS);
746
747 // Dump ValuesCode.
748 OS << "/////////\n";
749 OS << "// ValuesCode\n\n";
750 OS << "#ifdef OPTTABLE_VALUES_CODE\n";
751 std::vector<const Record *> ValuesCodeOpts;
752 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
753 // The option values, if any;
754 if (!isa<UnsetInit>(Val: R.getValueInit(FieldName: "ValuesCode"))) {
755 if (!isa<UnsetInit>(Val: R.getValueInit(FieldName: "Values")))
756 PrintFatalError(ErrorLoc: R.getLoc(), Msg: "cannot set both Values and ValuesCode");
757 ValuesCodeOpts.push_back(x: &R);
758 OS << "#define VALUES_CODE " << getOptionName(R) << "_Values\n";
759 OS << R.getValueAsString(FieldName: "ValuesCode") << "\n";
760 OS << "#undef VALUES_CODE\n";
761 }
762 }
763 // A function keeps these strings out of a relocated table. It names OPT_ IDs,
764 // so include this block after the option enum; a table that uses a different
765 // ID prefix cannot use ValuesCode.
766 OS << "static llvm::StringRef getOptionValuesCode(unsigned ID) {\n";
767 OS << " switch (ID) {\n";
768 for (const Record *R : ValuesCodeOpts)
769 OS << " case OPT_" << getOptionName(R: *R) << ": return " << getOptionName(R: *R)
770 << "_Values;\n";
771 OS << " }\n return {};\n}\n";
772 OS << "#undef OPTTABLE_VALUES_CODE\n";
773 OS << "#endif // OPTTABLE_VALUES_CODE\n";
774
775 OS << "/////////\n";
776 OS << "// Groups\n\n";
777 OS << "#ifdef OPTION\n";
778 for (const Record &R : llvm::make_pointee_range(Range&: Groups)) {
779 // Start a single option entry.
780 OS << "OPTION(";
781
782 // A zero prefix offset corresponds to an empty set of prefixes.
783 OS << "0 /* no prefixes */";
784
785 // The option string offset.
786 OS << ", ";
787 writeStrTableOffset(OS, Table, Str: R.getValueAsString(FieldName: "Name"),
788 /*EmitComment=*/true);
789
790 // The option identifier name.
791 OS << ", " << getOptionName(R);
792
793 // The option kind.
794 OS << ", Group";
795
796 // The containing option group (if any).
797 OS << ", ";
798 if (const DefInit *DI = dyn_cast<DefInit>(Val: R.getValueInit(FieldName: "Group")))
799 OS << getOptionName(R: *DI->getDef());
800 else
801 OS << "INVALID";
802
803 // The other option arguments (unused for groups).
804 OS << ", INVALID, 0, 0, 0, 0";
805
806 // The option help text.
807 OS << ", ";
808 writeStrTableOffset(OS, Table, Str: getHelpText(R));
809
810 // Groups have no help text variants.
811 OS << ", 0";
812
813 // The option meta-variable name (unused).
814 OS << ", 0";
815
816 // The option Values and SubCommandIDsOffset (unused for groups).
817 OS << ", 0, 0)\n";
818 }
819 OS << "\n";
820
821 OS << "//////////\n";
822 OS << "// Options\n\n";
823
824 auto WriteOptRecordFields = [&](raw_ostream &OS, const Record &R) {
825 // The option prefix;
826 std::vector<StringRef> RPrefixes = R.getValueAsListOfStrings(FieldName: "Prefixes");
827 OS << Prefixes[PrefixKeyT(RPrefixes.begin(), RPrefixes.end())] << ", ";
828
829 // The option prefixed name.
830 writeStrTableOffset(OS, Table, Str: getOptionPrefixedName(R),
831 /*EmitComment=*/true);
832
833 // The option identifier name.
834 OS << ", " << getOptionName(R);
835
836 // The option kind.
837 OS << ", " << R.getValueAsDef(FieldName: "Kind")->getValueAsString(FieldName: "Name");
838
839 // The containing option group (if any).
840 OS << ", ";
841 if (const DefInit *DI = dyn_cast<DefInit>(Val: R.getValueInit(FieldName: "Group")))
842 OS << getOptionName(R: *DI->getDef());
843 else
844 OS << "INVALID";
845
846 // The option alias (if any).
847 OS << ", ";
848 if (const DefInit *DI = dyn_cast<DefInit>(Val: R.getValueInit(FieldName: "Alias")))
849 OS << getOptionName(R: *DI->getDef());
850 else
851 OS << "INVALID";
852
853 // The option alias arguments (if any).
854 OS << ", ";
855 writeStrTableOffset(OS, Table, Str: getAliasArgsBlob(R));
856
857 // "Flags" for the option, such as HelpHidden and Render*
858 OS << ", " << GetMask(R, "Flags");
859
860 // Option visibility, for sharing options between drivers.
861 OS << ", " << GetMask(R, "Visibility");
862
863 // The option parameter field.
864 OS << ", " << R.getValueAsInt(FieldName: "NumArgs");
865
866 // The option help text.
867 OS << ", ";
868 writeStrTableOffset(OS, Table, Str: getHelpText(R));
869
870 // The option help text variants.
871 OS << ", " << HelpTextVariantsOffset.lookup(Val: &R);
872
873 // The option meta-variable name.
874 OS << ", ";
875 writeStrTableOffset(OS, Table, Str: getOptionalString(R, Field: "MetaVarName"));
876
877 // The option Values. Used for shell autocompletion.
878 OS << ", ";
879 writeStrTableOffset(OS, Table, Str: getOptionalString(R, Field: "Values"));
880
881 // The option SubCommandIDsOffset.
882 OS << ", " << GetSubCommandIDsOffset(R);
883 };
884
885 auto IsMarshallingOption = [](const Record &R) {
886 return !isa<UnsetInit>(Val: R.getValueInit(FieldName: "KeyPath")) &&
887 !R.getValueAsString(FieldName: "KeyPath").empty();
888 };
889
890 std::vector<const Record *> OptsWithMarshalling;
891 for (const Record &R : llvm::make_pointee_range(Range&: Opts)) {
892 ConditionScope CS(OS, R);
893 // Start a single option entry.
894 OS << "OPTION(";
895 WriteOptRecordFields(OS, R);
896 OS << ")\n";
897 if (IsMarshallingOption(R))
898 OptsWithMarshalling.push_back(x: &R);
899 }
900 OS << "#endif // OPTION\n";
901
902 auto CmpMarshallingOpts = [](const Record *const *A, const Record *const *B) {
903 unsigned AID = (*A)->getID();
904 unsigned BID = (*B)->getID();
905
906 if (AID < BID)
907 return -1;
908 if (AID > BID)
909 return 1;
910 return 0;
911 };
912 // The RecordKeeper stores records (options) in lexicographical order, and we
913 // have reordered the options again when generating prefix groups. We need to
914 // restore the original definition order of options with marshalling to honor
915 // the topology of the dependency graph implied by `DefaultAnyOf`.
916 array_pod_sort(Start: OptsWithMarshalling.begin(), End: OptsWithMarshalling.end(),
917 Compare: CmpMarshallingOpts);
918
919 std::vector<MarshallingInfo> MarshallingInfos;
920 MarshallingInfos.reserve(n: OptsWithMarshalling.size());
921 for (const auto *R : OptsWithMarshalling)
922 MarshallingInfos.push_back(x: createMarshallingInfo(R: *R));
923
924 for (const auto &MI : MarshallingInfos) {
925 OS << "#ifdef " << MI.getMacroName() << "\n";
926 OS << MI.getMacroName() << "(";
927 WriteOptRecordFields(OS, MI.R);
928 OS << ", ";
929 MI.emit(OS);
930 OS << ")\n";
931 OS << "#endif // " << MI.getMacroName() << "\n";
932 }
933
934 OS << "\n";
935 OS << "#ifdef SIMPLE_ENUM_VALUE_TABLE";
936 OS << "\n";
937 OS << MarshallingInfo::ValueTablePreamble;
938 std::vector<StringRef> ValueTableNames;
939 for (const auto &MI : MarshallingInfos)
940 if (auto MaybeValueTableName = MI.emitValueTable(OS))
941 ValueTableNames.push_back(x: *MaybeValueTableName);
942
943 OS << MarshallingInfo::ValueTablesDecl << "{";
944 for (auto ValueTableName : ValueTableNames)
945 OS << "{" << ValueTableName << ", std::size(" << ValueTableName << ")},\n";
946 OS << "};\n";
947 OS << "static const unsigned SimpleEnumValueTablesSize = "
948 "std::size(SimpleEnumValueTables);\n";
949
950 OS << "#endif // SIMPLE_ENUM_VALUE_TABLE\n";
951}
952
953static TableGen::Emitter::Opt X("gen-opt-parser-defs", emitOptionParser,
954 "Generate option definitions");
955