1//===-- options.cpp - Command line options for llvm-debuginfo-analyzer----===//
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// This handles the command line options for llvm-debuginfo-analyzer.
10//
11//===----------------------------------------------------------------------===//
12
13#include "Options.h"
14#include "llvm/DebugInfo/LogicalView/Core/LVOptions.h"
15#include "llvm/DebugInfo/LogicalView/Core/LVSort.h"
16#include "llvm/Support/CommandLine.h"
17
18using namespace llvm;
19using namespace llvm::logicalview;
20using namespace llvm::logicalview::cmdline;
21
22/// @}
23/// Command line options.
24/// @{
25
26OffsetParser::OffsetParser(cl::Option &O) : parser<unsigned long long>(O) {}
27OffsetParser::~OffsetParser() = default;
28
29bool OffsetParser::parse(cl::Option &O, StringRef ArgName, StringRef Arg,
30 unsigned long long &Val) {
31 char *End;
32 std::string Argument(Arg);
33 Val = strtoull(nptr: Argument.c_str(), endptr: &End, base: 0);
34 if (*End)
35 // Print an error message if unrecognized character.
36 return O.error(Message: "'" + Arg + "' unrecognized character.");
37 return false;
38}
39
40LVOptions cmdline::ReaderOptions;
41
42//===----------------------------------------------------------------------===//
43// Specific options
44//===----------------------------------------------------------------------===//
45cl::list<std::string>
46 cmdline::InputFilenames(cl::desc("<input object files or .dSYM bundles>"),
47 cl::Positional, cl::ZeroOrMore);
48
49//===----------------------------------------------------------------------===//
50// '--attribute' options
51//===----------------------------------------------------------------------===//
52cl::OptionCategory
53 cmdline::AttributeCategory("Attribute Options",
54 "These control extra attributes that are "
55 "added when the element is printed.");
56
57// --attribute=<value>[,<value>,...]
58cl::list<LVAttributeKind> cmdline::AttributeOptions(
59 "attribute", cl::cat(AttributeCategory), cl::desc("Element attributes."),
60 cl::Hidden, cl::CommaSeparated,
61 values(clEnumValN(LVAttributeKind::All, "all", "Include all attributes."),
62 clEnumValN(LVAttributeKind::Argument, "argument",
63 "Template parameters replaced by its arguments."),
64 clEnumValN(LVAttributeKind::Base, "base",
65 "Base types (int, bool, etc.)."),
66 clEnumValN(LVAttributeKind::Coverage, "coverage",
67 "Symbol location coverage."),
68 clEnumValN(LVAttributeKind::Directories, "directories",
69 "Directories referenced in the debug information."),
70 clEnumValN(LVAttributeKind::Discarded, "discarded",
71 "Discarded elements by the linker."),
72 clEnumValN(LVAttributeKind::Discriminator, "discriminator",
73 "Discriminators for inlined function instances."),
74 clEnumValN(LVAttributeKind::Encoded, "encoded",
75 "Template arguments encoded in the template name."),
76 clEnumValN(LVAttributeKind::Extended, "extended",
77 "Advanced attributes alias."),
78 clEnumValN(LVAttributeKind::Filename, "filename",
79 "Filename where the element is defined."),
80 clEnumValN(LVAttributeKind::Files, "files",
81 "Files referenced in the debug information."),
82 clEnumValN(LVAttributeKind::Format, "format",
83 "Object file format name."),
84 clEnumValN(LVAttributeKind::Gaps, "gaps",
85 "Missing debug location (gaps)."),
86 clEnumValN(LVAttributeKind::Generated, "generated",
87 "Compiler generated elements."),
88 clEnumValN(LVAttributeKind::Global, "global",
89 "Element referenced across Compile Units."),
90 clEnumValN(LVAttributeKind::Inserted, "inserted",
91 "Generated inlined abstract references."),
92 clEnumValN(LVAttributeKind::Language, "language",
93 "Source language name."),
94 clEnumValN(LVAttributeKind::Level, "level",
95 "Lexical scope level (File=0, Compile Unit=1)."),
96 clEnumValN(LVAttributeKind::Linkage, "linkage", "Linkage name."),
97 clEnumValN(LVAttributeKind::Local, "local",
98 "Element referenced only in the Compile Unit."),
99 clEnumValN(LVAttributeKind::Location, "location",
100 "Element debug location."),
101 clEnumValN(LVAttributeKind::Offset, "offset",
102 "Debug information offset."),
103 clEnumValN(LVAttributeKind::Pathname, "pathname",
104 "Pathname where the element is defined."),
105 clEnumValN(LVAttributeKind::Producer, "producer",
106 "Toolchain identification name."),
107 clEnumValN(LVAttributeKind::Publics, "publics",
108 "Function names that are public."),
109 clEnumValN(LVAttributeKind::Qualified, "qualified",
110 "The element type include parents in its name."),
111 clEnumValN(LVAttributeKind::Qualifier, "qualifier",
112 "Line qualifiers (Newstatement, BasicBlock, etc.)."),
113 clEnumValN(LVAttributeKind::Range, "range",
114 "Debug location ranges."),
115 clEnumValN(LVAttributeKind::Reference, "reference",
116 "Element declaration and definition references."),
117 clEnumValN(LVAttributeKind::Register, "register",
118 "Processor register names."),
119 clEnumValN(LVAttributeKind::Size, "size", "Type sizes."),
120 clEnumValN(LVAttributeKind::Standard, "standard",
121 "Basic attributes alias."),
122 clEnumValN(LVAttributeKind::Subrange, "subrange",
123 "Subrange encoding information for arrays."),
124 clEnumValN(LVAttributeKind::System, "system",
125 "Display PDB's MS system elements."),
126 clEnumValN(LVAttributeKind::Typename, "typename",
127 "Include Parameters in templates."),
128 clEnumValN(LVAttributeKind::Underlying, "underlying",
129 "Underlying type for type definitions."),
130 clEnumValN(LVAttributeKind::Zero, "zero", "Zero line numbers.")));
131
132//===----------------------------------------------------------------------===//
133// '--compare' options
134//===----------------------------------------------------------------------===//
135cl::OptionCategory
136 cmdline::CompareCategory("Compare Options",
137 "These control the view comparison.");
138
139// --compare-context
140static cl::opt<bool, true>
141 CompareContext("compare-context", cl::cat(CompareCategory),
142 cl::desc("Add the view as compare context."), cl::Hidden,
143 cl::ZeroOrMore, cl::location(L&: ReaderOptions.Compare.Context),
144 cl::init(Val: false));
145
146// --compare=<value>[,<value>,...]
147cl::list<LVCompareKind> cmdline::CompareElements(
148 "compare", cl::cat(CompareCategory), cl::desc("Elements to compare."),
149 cl::Hidden, cl::CommaSeparated,
150 values(clEnumValN(LVCompareKind::All, "all", "Compare all elements."),
151 clEnumValN(LVCompareKind::Lines, "lines", "Lines."),
152 clEnumValN(LVCompareKind::Scopes, "scopes", "Scopes."),
153 clEnumValN(LVCompareKind::Symbols, "symbols", "Symbols."),
154 clEnumValN(LVCompareKind::Types, "types", "Types.")));
155
156//===----------------------------------------------------------------------===//
157// '--output' options
158//===----------------------------------------------------------------------===//
159cl::OptionCategory
160 cmdline::OutputCategory("Output Options",
161 "These control the output generated.");
162
163// --output-file=<filename>
164cl::opt<std::string>
165 cmdline::OutputFilename("output-file", cl::cat(OutputCategory),
166 cl::desc("Redirect output to the specified file."),
167 cl::Hidden, cl::value_desc("filename"),
168 cl::init(Val: "-"));
169
170// --output-folder=<path>
171static cl::opt<std::string, true>
172 OutputFolder("output-folder", cl::cat(OutputCategory),
173 cl::desc("Folder name for view splitting."),
174 cl::value_desc("pathname"), cl::Hidden, cl::ZeroOrMore,
175 cl::location(L&: ReaderOptions.Output.Folder));
176
177// --output-level=<level>
178static cl::opt<unsigned, true>
179 OutputLevel("output-level", cl::cat(OutputCategory),
180 cl::desc("Only print to a depth of N elements."),
181 cl::value_desc("N"), cl::Hidden, cl::ZeroOrMore,
182 cl::location(L&: ReaderOptions.Output.Level), cl::init(Val: -1U));
183
184// --ouput=<value>[,<value>,...]
185cl::list<LVOutputKind> cmdline::OutputOptions(
186 "output", cl::cat(OutputCategory), cl::desc("Outputs for view."),
187 cl::Hidden, cl::CommaSeparated,
188 values(clEnumValN(LVOutputKind::All, "all", "All outputs."),
189 clEnumValN(LVOutputKind::Split, "split",
190 "Split the output by Compile Units."),
191 clEnumValN(LVOutputKind::Text, "text",
192 "Use a free form text output."),
193 clEnumValN(LVOutputKind::Json, "json",
194 "Use JSON as the output format.")));
195
196// --output-sort
197static cl::opt<LVSortMode, true> OutputSort(
198 "output-sort", cl::cat(OutputCategory),
199 cl::desc("Primary key when ordering logical view (default: line)."),
200 cl::Hidden, cl::ZeroOrMore,
201 values(clEnumValN(LVSortMode::None, "none",
202 "Unsorted output (i.e. as read from input)."),
203 clEnumValN(LVSortMode::ID, "id", "Sort by unique element ID."),
204 clEnumValN(LVSortMode::Kind, "kind", "Sort by element kind."),
205 clEnumValN(LVSortMode::Line, "line", "Sort by element line number."),
206 clEnumValN(LVSortMode::Name, "name", "Sort by element name."),
207 clEnumValN(LVSortMode::Offset, "offset", "Sort by element offset.")),
208 cl::location(L&: ReaderOptions.Output.SortMode), cl::init(Val: LVSortMode::Line));
209
210//===----------------------------------------------------------------------===//
211// '--print' options
212//===----------------------------------------------------------------------===//
213cl::OptionCategory
214 cmdline::PrintCategory("Print Options",
215 "These control which elements are printed.");
216
217// --print=<value>[,<value>,...]
218cl::list<LVPrintKind> cmdline::PrintOptions(
219 "print", cl::cat(PrintCategory), cl::desc("Element to print."),
220 cl::CommaSeparated,
221 values(clEnumValN(LVPrintKind::All, "all", "All elements."),
222 clEnumValN(LVPrintKind::Elements, "elements",
223 "Instructions, lines, scopes, symbols and types."),
224 clEnumValN(LVPrintKind::Instructions, "instructions",
225 "Assembler instructions."),
226 clEnumValN(LVPrintKind::Lines, "lines",
227 "Lines referenced in the debug information."),
228 clEnumValN(LVPrintKind::Scopes, "scopes",
229 "A lexical block (Function, Class, etc.)."),
230 clEnumValN(LVPrintKind::Sizes, "sizes",
231 "Scope contributions to the debug information."),
232 clEnumValN(LVPrintKind::Summary, "summary",
233 "Summary of elements missing/added/matched/printed."),
234 clEnumValN(LVPrintKind::Symbols, "symbols",
235 "Symbols (Variable, Members, etc.)."),
236 clEnumValN(LVPrintKind::Types, "types",
237 "Types (Pointer, Reference, etc.)."),
238 clEnumValN(LVPrintKind::Warnings, "warnings",
239 "Warnings detected.")));
240
241//===----------------------------------------------------------------------===//
242// '--report' options
243//===----------------------------------------------------------------------===//
244cl::OptionCategory
245 cmdline::ReportCategory("Report Options",
246 "These control how the elements are printed.");
247
248// --report=<value>[,<value>,...]
249cl::list<LVReportKind> cmdline::ReportOptions(
250 "report", cl::cat(ReportCategory),
251 cl::desc("Reports layout used for print, compare and select."), cl::Hidden,
252 cl::CommaSeparated,
253 values(clEnumValN(LVReportKind::All, "all", "Generate all reports."),
254 clEnumValN(LVReportKind::Children, "children",
255 "Selected elements are displayed in a tree view "
256 "(Include children)"),
257 clEnumValN(LVReportKind::List, "list",
258 "Selected elements are displayed in a tabular format."),
259 clEnumValN(LVReportKind::Parents, "parents",
260 "Selected elements are displayed in a tree view. "
261 "(Include parents)"),
262 clEnumValN(LVReportKind::View, "view",
263 "Selected elements are displayed in a tree view "
264 "(Include parents and children.")));
265
266//===----------------------------------------------------------------------===//
267// '--select' options
268//===----------------------------------------------------------------------===//
269cl::OptionCategory
270 cmdline::SelectCategory("Select Options",
271 "These control which elements are selected.");
272
273// --select-nocase
274static cl::opt<bool, true>
275 SelectIgnoreCase("select-nocase", cl::cat(SelectCategory),
276 cl::desc("Ignore case distinctions when searching."),
277 cl::Hidden, cl::ZeroOrMore,
278 cl::location(L&: ReaderOptions.Select.IgnoreCase),
279 cl::init(Val: false));
280
281// --select-regex
282static cl::opt<bool, true> SelectUseRegex(
283 "select-regex", cl::cat(SelectCategory),
284 cl::desc("Treat any <pattern> strings as regular expressions when "
285 "selecting instead of just as an exact string match."),
286 cl::Hidden, cl::ZeroOrMore, cl::location(L&: ReaderOptions.Select.UseRegex),
287 cl::init(Val: false));
288
289// --select=<pattern>
290cl::list<std::string> cmdline::SelectPatterns(
291 "select", cl::cat(SelectCategory),
292 cl::desc("Search elements matching the given pattern."), cl::Hidden,
293 cl::value_desc("pattern"), cl::CommaSeparated);
294
295// --select-offsets=<value>[,<value>,...]
296OffsetOptionList cmdline::SelectOffsets("select-offsets",
297 cl::cat(SelectCategory),
298 cl::desc("Offset element to print."),
299 cl::Hidden, cl::value_desc("offset"),
300 cl::CommaSeparated, cl::ZeroOrMore);
301
302// --select-elements=<value>[,<value>,...]
303cl::list<LVElementKind> cmdline::SelectElements(
304 "select-elements", cl::cat(SelectCategory),
305 cl::desc("Conditions to use when printing elements."), cl::Hidden,
306 cl::CommaSeparated,
307 values(clEnumValN(LVElementKind::Discarded, "Discarded",
308 "Discarded elements by the linker."),
309 clEnumValN(LVElementKind::Global, "Global",
310 "Element referenced across Compile Units."),
311 clEnumValN(LVElementKind::Optimized, "Optimized",
312 "Generated inlined abstract references.")));
313
314// --select-lines=<value>[,<value>,...]
315cl::list<LVLineKind> cmdline::SelectLines(
316 "select-lines", cl::cat(SelectCategory),
317 cl::desc("Line kind to use when printing lines."), cl::Hidden,
318 cl::CommaSeparated,
319 values(
320 clEnumValN(LVLineKind::IsAlwaysStepInto, "AlwaysStepInto",
321 "Always Step Into."),
322 clEnumValN(LVLineKind::IsBasicBlock, "BasicBlock", "Basic block."),
323 clEnumValN(LVLineKind::IsDiscriminator, "Discriminator",
324 "Discriminator."),
325 clEnumValN(LVLineKind::IsEndSequence, "EndSequence", "End sequence."),
326 clEnumValN(LVLineKind::IsEpilogueBegin, "EpilogueBegin.",
327 "Epilogue begin."),
328 clEnumValN(LVLineKind::IsLineDebug, "LineDebug", "Debug line."),
329 clEnumValN(LVLineKind::IsLineAssembler, "LineAssembler",
330 "Assembler line."),
331 clEnumValN(LVLineKind::IsNeverStepInto, "NeverStepInto",
332 "Never Step Into."),
333 clEnumValN(LVLineKind::IsNewStatement, "NewStatement",
334 "New statement."),
335 clEnumValN(LVLineKind::IsPrologueEnd, "PrologueEnd", "Prologue end.")));
336
337// --select-scopes=<value>[,<value>,...]
338cl::list<LVScopeKind> cmdline::SelectScopes(
339 "select-scopes", cl::cat(SelectCategory),
340 cl::desc("Scope kind to use when printing scopes."), cl::Hidden,
341 cl::CommaSeparated,
342 values(
343 clEnumValN(LVScopeKind::IsAggregate, "Aggregate",
344 "Class, Structure or Union."),
345 clEnumValN(LVScopeKind::IsArray, "Array", "Array."),
346 clEnumValN(LVScopeKind::IsBlock, "Block", "Lexical block."),
347 clEnumValN(LVScopeKind::IsCallSite, "CallSite", "Call site block."),
348 clEnumValN(LVScopeKind::IsCatchBlock, "CatchBlock",
349 "Exception catch block."),
350 clEnumValN(LVScopeKind::IsClass, "Class", "Class."),
351 clEnumValN(LVScopeKind::IsCompileUnit, "CompileUnit", "Compile unit."),
352 clEnumValN(LVScopeKind::IsEntryPoint, "EntryPoint",
353 "Function entry point."),
354 clEnumValN(LVScopeKind::IsEnumeration, "Enumeration", "Enumeration."),
355 clEnumValN(LVScopeKind::IsFunction, "Function", "Function."),
356 clEnumValN(LVScopeKind::IsFunctionType, "FunctionType",
357 "Function type."),
358 clEnumValN(LVScopeKind::IsInlinedFunction, "InlinedFunction",
359 "Inlined function."),
360 clEnumValN(LVScopeKind::IsLabel, "Label", "Label."),
361 clEnumValN(LVScopeKind::IsLexicalBlock, "LexicalBlock",
362 "Lexical block."),
363 clEnumValN(LVScopeKind::IsModule, "Module", "Module."),
364 clEnumValN(LVScopeKind::IsNamespace, "Namespace", "Namespace."),
365 clEnumValN(LVScopeKind::IsRoot, "Root", "Root."),
366 clEnumValN(LVScopeKind::IsStructure, "Structure", "Structure."),
367 clEnumValN(LVScopeKind::IsSubprogram, "Subprogram", "Subprogram."),
368 clEnumValN(LVScopeKind::IsTemplate, "Template", "Template."),
369 clEnumValN(LVScopeKind::IsTemplateAlias, "TemplateAlias",
370 "Template alias."),
371 clEnumValN(LVScopeKind::IsTemplatePack, "TemplatePack",
372 "Template pack."),
373 clEnumValN(LVScopeKind::IsTryBlock, "TryBlock", "Exception try block."),
374 clEnumValN(LVScopeKind::IsUnion, "Union", "Union.")));
375
376// --select-symbols=<value>[,<value>,...]
377cl::list<LVSymbolKind> cmdline::SelectSymbols(
378 "select-symbols", cl::cat(SelectCategory),
379 cl::desc("Symbol kind to use when printing symbols."), cl::Hidden,
380 cl::CommaSeparated,
381 values(clEnumValN(LVSymbolKind::IsCallSiteParameter, "CallSiteParameter",
382 "Call site parameter."),
383 clEnumValN(LVSymbolKind::IsConstant, "Constant", "Constant."),
384 clEnumValN(LVSymbolKind::IsInheritance, "Inheritance",
385 "Inheritance."),
386 clEnumValN(LVSymbolKind::IsMember, "Member", "Member."),
387 clEnumValN(LVSymbolKind::IsParameter, "Parameter", "Parameter."),
388 clEnumValN(LVSymbolKind::IsUnspecified, "Unspecified",
389 "Unspecified parameter."),
390 clEnumValN(LVSymbolKind::IsVariable, "Variable", "Variable.")));
391
392// --select-types=<value>[,<value>,...]
393cl::list<LVTypeKind> cmdline::SelectTypes(
394 "select-types", cl::cat(SelectCategory),
395 cl::desc("Type kind to use when printing types."), cl::Hidden,
396 cl::CommaSeparated,
397 values(
398 clEnumValN(LVTypeKind::IsBase, "Base", "Base Type (int, bool, etc.)."),
399 clEnumValN(LVTypeKind::IsConst, "Const", "Constant specifier."),
400 clEnumValN(LVTypeKind::IsEnumerator, "Enumerator", "Enumerator."),
401 clEnumValN(LVTypeKind::IsImport, "Import", "Import."),
402 clEnumValN(LVTypeKind::IsImportDeclaration, "ImportDeclaration",
403 "Import declaration."),
404 clEnumValN(LVTypeKind::IsImportModule, "ImportModule",
405 "Import module."),
406 clEnumValN(LVTypeKind::IsPointer, "Pointer", "Pointer."),
407 clEnumValN(LVTypeKind::IsPointerMember, "PointerMember",
408 "Pointer to member."),
409 clEnumValN(LVTypeKind::IsReference, "Reference", "Reference type."),
410 clEnumValN(LVTypeKind::IsRestrict, "Restrict", "Restrict specifier."),
411 clEnumValN(LVTypeKind::IsRvalueReference, "RvalueReference",
412 "Rvalue reference."),
413 clEnumValN(LVTypeKind::IsSubrange, "Subrange", "Array subrange."),
414 clEnumValN(LVTypeKind::IsTemplateParam, "TemplateParam",
415 "Template Parameter."),
416 clEnumValN(LVTypeKind::IsTemplateTemplateParam, "TemplateTemplateParam",
417 "Template template parameter."),
418 clEnumValN(LVTypeKind::IsTemplateTypeParam, "TemplateTypeParam",
419 "Template type parameter."),
420 clEnumValN(LVTypeKind::IsTemplateValueParam, "TemplateValueParam",
421 "Template value parameter."),
422 clEnumValN(LVTypeKind::IsTypedef, "Typedef", "Type definition."),
423 clEnumValN(LVTypeKind::IsUnspecified, "Unspecified",
424 "Unspecified type."),
425 clEnumValN(LVTypeKind::IsVolatile, "Volatile", "Volatile specifier.")));
426
427//===----------------------------------------------------------------------===//
428// '--warning' options
429//===----------------------------------------------------------------------===//
430cl::OptionCategory
431 cmdline::WarningCategory("Warning Options",
432 "These control the generated warnings.");
433
434// --warning=<value>[,<value>,...]
435cl::list<LVWarningKind> cmdline::WarningOptions(
436 "warning", cl::cat(WarningCategory), cl::desc("Warnings to generate."),
437 cl::Hidden, cl::CommaSeparated,
438 values(
439 clEnumValN(LVWarningKind::All, "all", "All warnings."),
440 clEnumValN(LVWarningKind::Coverages, "coverages",
441 "Invalid symbol coverages values."),
442 clEnumValN(LVWarningKind::Lines, "lines", "Debug lines that are zero."),
443 clEnumValN(LVWarningKind::Locations, "locations",
444 "Invalid symbol locations."),
445 clEnumValN(LVWarningKind::Ranges, "ranges", "Invalid code ranges.")));
446
447//===----------------------------------------------------------------------===//
448// '--internal' options
449//===----------------------------------------------------------------------===//
450cl::OptionCategory
451 cmdline::InternalCategory("Internal Options",
452 "Internal traces and extra debugging code.");
453
454// --internal=<value>[,<value>,...]
455cl::list<LVInternalKind> cmdline::InternalOptions(
456 "internal", cl::cat(InternalCategory), cl::desc("Traces to enable."),
457 cl::Hidden, cl::CommaSeparated,
458 values(
459 clEnumValN(LVInternalKind::All, "all", "Enable all traces."),
460 clEnumValN(LVInternalKind::Cmdline, "cmdline", "Print command line."),
461 clEnumValN(LVInternalKind::ID, "id", "Print unique element ID"),
462 clEnumValN(LVInternalKind::Integrity, "integrity",
463 "Check elements integrity."),
464 clEnumValN(LVInternalKind::None, "none", "Ignore element line number."),
465 clEnumValN(LVInternalKind::Tag, "tag", "Debug information tags.")));
466
467/// @}
468
469// Copy local options into a globally accessible data structure.
470void llvm::logicalview::cmdline::propagateOptions() {
471 // Traverse list of options and update the given set (Using case and Regex).
472 auto UpdatePattern = [&](auto &List, auto &Set, bool IgnoreCase,
473 bool UseRegex) {
474 if (!List.empty())
475 for (std::string &Pattern : List)
476 Set.insert((IgnoreCase && !UseRegex) ? StringRef(Pattern).lower()
477 : Pattern);
478 };
479
480 // Handle --select.
481 UpdatePattern(SelectPatterns, ReaderOptions.Select.Generic,
482 ReaderOptions.Select.IgnoreCase, ReaderOptions.Select.UseRegex);
483
484 // Traverse list of options and update the given set.
485 auto UpdateSet = [&](auto &List, auto &Set) {
486 std::copy(List.begin(), List.end(), std::inserter(Set, Set.begin()));
487 };
488
489 // Handle options sets.
490 UpdateSet(AttributeOptions, ReaderOptions.Attribute.Kinds);
491 UpdateSet(PrintOptions, ReaderOptions.Print.Kinds);
492 UpdateSet(OutputOptions, ReaderOptions.Output.Kinds);
493 UpdateSet(ReportOptions, ReaderOptions.Report.Kinds);
494 UpdateSet(WarningOptions, ReaderOptions.Warning.Kinds);
495 UpdateSet(InternalOptions, ReaderOptions.Internal.Kinds);
496
497 UpdateSet(SelectElements, ReaderOptions.Select.Elements);
498 UpdateSet(SelectLines, ReaderOptions.Select.Lines);
499 UpdateSet(SelectScopes, ReaderOptions.Select.Scopes);
500 UpdateSet(SelectSymbols, ReaderOptions.Select.Symbols);
501 UpdateSet(SelectTypes, ReaderOptions.Select.Types);
502 UpdateSet(SelectOffsets, ReaderOptions.Select.Offsets);
503 UpdateSet(CompareElements, ReaderOptions.Compare.Elements);
504
505 // Resolve any options dependencies (ie. --print=all should set other
506 // print options, etc.).
507 ReaderOptions.resolveDependencies();
508}
509