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