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