llvm-project

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