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
OffsetParser(cl::Option & O)26 OffsetParser::OffsetParser(cl::Option &O) : parser<unsigned long long>(O) {}
27 OffsetParser::~OffsetParser() = default;
28
parse(cl::Option & O,StringRef ArgName,StringRef Arg,unsigned long long & Val)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.
propagateOptions()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