| //===-- options.cpp - Command line options for llvm-debuginfo-analyzer----===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This handles the command line options for llvm-debuginfo-analyzer. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "Options.h" | |
| #include "llvm/DebugInfo/LogicalView/Core/LVOptions.h" | |
| #include "llvm/DebugInfo/LogicalView/Core/LVSort.h" | |
| #include "llvm/Support/CommandLine.h" | |
| using namespace llvm; | |
| using namespace llvm::logicalview; | |
| using namespace llvm::logicalview::cmdline; | |
| /// @} | |
| /// Command line options. | |
| /// @{ | |
| OffsetParser::OffsetParser(cl::Option &O) : parser<unsigned long long>(O) {} | |
| OffsetParser::~OffsetParser() = default; | |
| bool OffsetParser::parse(cl::Option &O, StringRef ArgName, StringRef Arg, | |
| unsigned long long &Val) { | |
| char *End; | |
| std::string Argument(Arg); | |
| Val = strtoull(Argument.c_str(), &End, 0); | |
| if (*End) | |
| // Print an error message if unrecognized character. | |
| return O.error("'" + Arg + "' unrecognized character."); | |
| return false; | |
| } | |
| LVOptions cmdline::ReaderOptions; | |
| //===----------------------------------------------------------------------===// | |
| // Specific options | |
| //===----------------------------------------------------------------------===// | |
| cl::list<std::string> | |
| cmdline::InputFilenames(cl::desc("<input object files or .dSYM bundles>"), | |
| cl::Positional, cl::ZeroOrMore); | |
| //===----------------------------------------------------------------------===// | |
| // '--attribute' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::AttributeCategory("Attribute Options", | |
| "These control extra attributes that are " | |
| "added when the element is printed."); | |
| // --attribute=<value>[,<value>,...] | |
| cl::list<LVAttributeKind> cmdline::AttributeOptions( | |
| "attribute", cl::cat(AttributeCategory), cl::desc("Element attributes."), | |
| cl::Hidden, cl::CommaSeparated, | |
| values(clEnumValN(LVAttributeKind::All, "all", "Include all attributes."), | |
| clEnumValN(LVAttributeKind::Argument, "argument", | |
| "Template parameters replaced by its arguments."), | |
| clEnumValN(LVAttributeKind::Base, "base", | |
| "Base types (int, bool, etc.)."), | |
| clEnumValN(LVAttributeKind::Coverage, "coverage", | |
| "Symbol location coverage."), | |
| clEnumValN(LVAttributeKind::Directories, "directories", | |
| "Directories referenced in the debug information."), | |
| clEnumValN(LVAttributeKind::Discarded, "discarded", | |
| "Discarded elements by the linker."), | |
| clEnumValN(LVAttributeKind::Discriminator, "discriminator", | |
| "Discriminators for inlined function instances."), | |
| clEnumValN(LVAttributeKind::Encoded, "encoded", | |
| "Template arguments encoded in the template name."), | |
| clEnumValN(LVAttributeKind::Extended, "extended", | |
| "Advanced attributes alias."), | |
| clEnumValN(LVAttributeKind::Filename, "filename", | |
| "Filename where the element is defined."), | |
| clEnumValN(LVAttributeKind::Files, "files", | |
| "Files referenced in the debug information."), | |
| clEnumValN(LVAttributeKind::Format, "format", | |
| "Object file format name."), | |
| clEnumValN(LVAttributeKind::Gaps, "gaps", | |
| "Missing debug location (gaps)."), | |
| clEnumValN(LVAttributeKind::Generated, "generated", | |
| "Compiler generated elements."), | |
| clEnumValN(LVAttributeKind::Global, "global", | |
| "Element referenced across Compile Units."), | |
| clEnumValN(LVAttributeKind::Inserted, "inserted", | |
| "Generated inlined abstract references."), | |
| clEnumValN(LVAttributeKind::Level, "level", | |
| "Lexical scope level (File=0, Compile Unit=1)."), | |
| clEnumValN(LVAttributeKind::Linkage, "linkage", "Linkage name."), | |
| clEnumValN(LVAttributeKind::Local, "local", | |
| "Element referenced only in the Compile Unit."), | |
| clEnumValN(LVAttributeKind::Location, "location", | |
| "Element debug location."), | |
| clEnumValN(LVAttributeKind::Offset, "offset", | |
| "Debug information offset."), | |
| clEnumValN(LVAttributeKind::Pathname, "pathname", | |
| "Pathname where the element is defined."), | |
| clEnumValN(LVAttributeKind::Producer, "producer", | |
| "Toolchain identification name."), | |
| clEnumValN(LVAttributeKind::Publics, "publics", | |
| "Function names that are public."), | |
| clEnumValN(LVAttributeKind::Qualified, "qualified", | |
| "The element type include parents in its name."), | |
| clEnumValN(LVAttributeKind::Qualifier, "qualifier", | |
| "Line qualifiers (Newstatement, BasicBlock, etc.)."), | |
| clEnumValN(LVAttributeKind::Range, "range", | |
| "Debug location ranges."), | |
| clEnumValN(LVAttributeKind::Reference, "reference", | |
| "Element declaration and definition references."), | |
| clEnumValN(LVAttributeKind::Register, "register", | |
| "Processor register names."), | |
| clEnumValN(LVAttributeKind::Standard, "standard", | |
| "Basic attributes alias."), | |
| clEnumValN(LVAttributeKind::Subrange, "subrange", | |
| "Subrange encoding information for arrays."), | |
| clEnumValN(LVAttributeKind::System, "system", | |
| "Display PDB's MS system elements."), | |
| clEnumValN(LVAttributeKind::Typename, "typename", | |
| "Include Parameters in templates."), | |
| clEnumValN(LVAttributeKind::Underlying, "underlying", | |
| "Underlying type for type definitions."), | |
| clEnumValN(LVAttributeKind::Zero, "zero", "Zero line numbers."))); | |
| //===----------------------------------------------------------------------===// | |
| // '--compare' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::CompareCategory("Compare Options", | |
| "These control the view comparison."); | |
| // --compare-context | |
| static cl::opt<bool, true> | |
| CompareContext("compare-context", cl::cat(CompareCategory), | |
| cl::desc("Add the view as compare context."), cl::Hidden, | |
| cl::ZeroOrMore, cl::location(ReaderOptions.Compare.Context), | |
| cl::init(false)); | |
| // --compare=<value>[,<value>,...] | |
| cl::list<LVCompareKind> cmdline::CompareElements( | |
| "compare", cl::cat(CompareCategory), cl::desc("Elements to compare."), | |
| cl::Hidden, cl::CommaSeparated, | |
| values(clEnumValN(LVCompareKind::All, "all", "Compare all elements."), | |
| clEnumValN(LVCompareKind::Lines, "lines", "Lines."), | |
| clEnumValN(LVCompareKind::Scopes, "scopes", "Scopes."), | |
| clEnumValN(LVCompareKind::Symbols, "symbols", "Symbols."), | |
| clEnumValN(LVCompareKind::Types, "types", "Types."))); | |
| //===----------------------------------------------------------------------===// | |
| // '--output' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::OutputCategory("Output Options", | |
| "These control the output generated."); | |
| // --output-file=<filename> | |
| cl::opt<std::string> | |
| cmdline::OutputFilename("output-file", cl::cat(OutputCategory), | |
| cl::desc("Redirect output to the specified file."), | |
| cl::Hidden, cl::value_desc("filename"), | |
| cl::init("-")); | |
| // --output-folder=<path> | |
| static cl::opt<std::string, true> | |
| OutputFolder("output-folder", cl::cat(OutputCategory), | |
| cl::desc("Folder name for view splitting."), | |
| cl::value_desc("pathname"), cl::Hidden, cl::ZeroOrMore, | |
| cl::location(ReaderOptions.Output.Folder)); | |
| // --output-level=<level> | |
| static cl::opt<unsigned, true> | |
| OutputLevel("output-level", cl::cat(OutputCategory), | |
| cl::desc("Only print to a depth of N elements."), | |
| cl::value_desc("N"), cl::Hidden, cl::ZeroOrMore, | |
| cl::location(ReaderOptions.Output.Level), cl::init(-1U)); | |
| // --ouput=<value>[,<value>,...] | |
| cl::list<LVOutputKind> cmdline::OutputOptions( | |
| "output", cl::cat(OutputCategory), cl::desc("Outputs for view."), | |
| cl::Hidden, cl::CommaSeparated, | |
| values(clEnumValN(LVOutputKind::All, "all", "All outputs."), | |
| clEnumValN(LVOutputKind::Split, "split", | |
| "Split the output by Compile Units."), | |
| clEnumValN(LVOutputKind::Text, "text", | |
| "Use a free form text output."), | |
| clEnumValN(LVOutputKind::Json, "json", | |
| "Use JSON as the output format."))); | |
| // --output-sort | |
| static cl::opt<LVSortMode, true> OutputSort( | |
| "output-sort", cl::cat(OutputCategory), | |
| cl::desc("Primary key when ordering logical view (default: line)."), | |
| cl::Hidden, cl::ZeroOrMore, | |
| values(clEnumValN(LVSortMode::Kind, "kind", "Sort by element kind."), | |
| clEnumValN(LVSortMode::Line, "line", "Sort by element line number."), | |
| clEnumValN(LVSortMode::Name, "name", "Sort by element name."), | |
| clEnumValN(LVSortMode::Offset, "offset", "Sort by element offset.")), | |
| cl::location(ReaderOptions.Output.SortMode), cl::init(LVSortMode::Line)); | |
| //===----------------------------------------------------------------------===// | |
| // '--print' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::PrintCategory("Print Options", | |
| "These control which elements are printed."); | |
| // --print=<value>[,<value>,...] | |
| cl::list<LVPrintKind> cmdline::PrintOptions( | |
| "print", cl::cat(PrintCategory), cl::desc("Element to print."), | |
| cl::CommaSeparated, | |
| values(clEnumValN(LVPrintKind::All, "all", "All elements."), | |
| clEnumValN(LVPrintKind::Elements, "elements", | |
| "Instructions, lines, scopes, symbols and types."), | |
| clEnumValN(LVPrintKind::Instructions, "instructions", | |
| "Assembler instructions."), | |
| clEnumValN(LVPrintKind::Lines, "lines", | |
| "Lines referenced in the debug information."), | |
| clEnumValN(LVPrintKind::Scopes, "scopes", | |
| "A lexical block (Function, Class, etc.)."), | |
| clEnumValN(LVPrintKind::Sizes, "sizes", | |
| "Scope contributions to the debug information."), | |
| clEnumValN(LVPrintKind::Summary, "summary", | |
| "Summary of elements missing/added/matched/printed."), | |
| clEnumValN(LVPrintKind::Symbols, "symbols", | |
| "Symbols (Variable, Members, etc.)."), | |
| clEnumValN(LVPrintKind::Types, "types", | |
| "Types (Pointer, Reference, etc.)."), | |
| clEnumValN(LVPrintKind::Warnings, "warnings", | |
| "Warnings detected."))); | |
| //===----------------------------------------------------------------------===// | |
| // '--report' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::ReportCategory("Report Options", | |
| "These control how the elements are printed."); | |
| // --report=<value>[,<value>,...] | |
| cl::list<LVReportKind> cmdline::ReportOptions( | |
| "report", cl::cat(ReportCategory), | |
| cl::desc("Reports layout used for print, compare and select."), cl::Hidden, | |
| cl::CommaSeparated, | |
| values(clEnumValN(LVReportKind::All, "all", "Generate all reports."), | |
| clEnumValN(LVReportKind::Children, "children", | |
| "Selected elements are displayed in a tree view " | |
| "(Include children)"), | |
| clEnumValN(LVReportKind::List, "list", | |
| "Selected elements are displayed in a tabular format."), | |
| clEnumValN(LVReportKind::Parents, "parents", | |
| "Selected elements are displayed in a tree view. " | |
| "(Include parents)"), | |
| clEnumValN(LVReportKind::View, "view", | |
| "Selected elements are displayed in a tree view " | |
| "(Include parents and children."))); | |
| //===----------------------------------------------------------------------===// | |
| // '--select' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::SelectCategory("Select Options", | |
| "These control which elements are selected."); | |
| // --select-nocase | |
| static cl::opt<bool, true> | |
| SelectIgnoreCase("select-nocase", cl::cat(SelectCategory), | |
| cl::desc("Ignore case distinctions when searching."), | |
| cl::Hidden, cl::ZeroOrMore, | |
| cl::location(ReaderOptions.Select.IgnoreCase), | |
| cl::init(false)); | |
| // --select-regex | |
| static cl::opt<bool, true> SelectUseRegex( | |
| "select-regex", cl::cat(SelectCategory), | |
| cl::desc("Treat any <pattern> strings as regular expressions when " | |
| "selecting instead of just as an exact string match."), | |
| cl::Hidden, cl::ZeroOrMore, cl::location(ReaderOptions.Select.UseRegex), | |
| cl::init(false)); | |
| // --select=<pattern> | |
| cl::list<std::string> cmdline::SelectPatterns( | |
| "select", cl::cat(SelectCategory), | |
| cl::desc("Search elements matching the given pattern."), cl::Hidden, | |
| cl::value_desc("pattern"), cl::CommaSeparated); | |
| // --select-offsets=<value>[,<value>,...] | |
| OffsetOptionList cmdline::SelectOffsets("select-offsets", | |
| cl::cat(SelectCategory), | |
| cl::desc("Offset element to print."), | |
| cl::Hidden, cl::value_desc("offset"), | |
| cl::CommaSeparated, cl::ZeroOrMore); | |
| // --select-elements=<value>[,<value>,...] | |
| cl::list<LVElementKind> cmdline::SelectElements( | |
| "select-elements", cl::cat(SelectCategory), | |
| cl::desc("Conditions to use when printing elements."), cl::Hidden, | |
| cl::CommaSeparated, | |
| values(clEnumValN(LVElementKind::Discarded, "Discarded", | |
| "Discarded elements by the linker."), | |
| clEnumValN(LVElementKind::Global, "Global", | |
| "Element referenced across Compile Units."), | |
| clEnumValN(LVElementKind::Optimized, "Optimized", | |
| "Generated inlined abstract references."))); | |
| // --select-lines=<value>[,<value>,...] | |
| cl::list<LVLineKind> cmdline::SelectLines( | |
| "select-lines", cl::cat(SelectCategory), | |
| cl::desc("Line kind to use when printing lines."), cl::Hidden, | |
| cl::CommaSeparated, | |
| values( | |
| clEnumValN(LVLineKind::IsAlwaysStepInto, "AlwaysStepInto", | |
| "Always Step Into."), | |
| clEnumValN(LVLineKind::IsBasicBlock, "BasicBlock", "Basic block."), | |
| clEnumValN(LVLineKind::IsDiscriminator, "Discriminator", | |
| "Discriminator."), | |
| clEnumValN(LVLineKind::IsEndSequence, "EndSequence", "End sequence."), | |
| clEnumValN(LVLineKind::IsEpilogueBegin, "EpilogueBegin.", | |
| "Epilogue begin."), | |
| clEnumValN(LVLineKind::IsLineDebug, "LineDebug", "Debug line."), | |
| clEnumValN(LVLineKind::IsLineAssembler, "LineAssembler", | |
| "Assembler line."), | |
| clEnumValN(LVLineKind::IsNeverStepInto, "NeverStepInto", | |
| "Never Step Into."), | |
| clEnumValN(LVLineKind::IsNewStatement, "NewStatement", | |
| "New statement."), | |
| clEnumValN(LVLineKind::IsPrologueEnd, "PrologueEnd", "Prologue end."))); | |
| // --select-scopes=<value>[,<value>,...] | |
| cl::list<LVScopeKind> cmdline::SelectScopes( | |
| "select-scopes", cl::cat(SelectCategory), | |
| cl::desc("Scope kind to use when printing scopes."), cl::Hidden, | |
| cl::CommaSeparated, | |
| values( | |
| clEnumValN(LVScopeKind::IsAggregate, "Aggregate", | |
| "Class, Structure or Union."), | |
| clEnumValN(LVScopeKind::IsArray, "Array", "Array."), | |
| clEnumValN(LVScopeKind::IsBlock, "Block", "Lexical block."), | |
| clEnumValN(LVScopeKind::IsCallSite, "CallSite", "Call site block."), | |
| clEnumValN(LVScopeKind::IsCatchBlock, "CatchBlock", | |
| "Exception catch block."), | |
| clEnumValN(LVScopeKind::IsClass, "Class", "Class."), | |
| clEnumValN(LVScopeKind::IsCompileUnit, "CompileUnit", "Compile unit."), | |
| clEnumValN(LVScopeKind::IsEntryPoint, "EntryPoint", | |
| "Function entry point."), | |
| clEnumValN(LVScopeKind::IsEnumeration, "Enumeration", "Enumeration."), | |
| clEnumValN(LVScopeKind::IsFunction, "Function", "Function."), | |
| clEnumValN(LVScopeKind::IsFunctionType, "FunctionType", | |
| "Function type."), | |
| clEnumValN(LVScopeKind::IsInlinedFunction, "InlinedFunction", | |
| "Inlined function."), | |
| clEnumValN(LVScopeKind::IsLabel, "Label", "Label."), | |
| clEnumValN(LVScopeKind::IsLexicalBlock, "LexicalBlock", | |
| "Lexical block."), | |
| clEnumValN(LVScopeKind::IsNamespace, "Namespace", "Namespace."), | |
| clEnumValN(LVScopeKind::IsRoot, "Root", "Root."), | |
| clEnumValN(LVScopeKind::IsStructure, "Structure", "Structure."), | |
| clEnumValN(LVScopeKind::IsSubprogram, "Subprogram", "Subprogram."), | |
| clEnumValN(LVScopeKind::IsTemplate, "Template", "Template."), | |
| clEnumValN(LVScopeKind::IsTemplateAlias, "TemplateAlias", | |
| "Template alias."), | |
| clEnumValN(LVScopeKind::IsTemplatePack, "TemplatePack", | |
| "Template pack."), | |
| clEnumValN(LVScopeKind::IsTryBlock, "TryBlock", "Exception try block."), | |
| clEnumValN(LVScopeKind::IsUnion, "Union", "Union."))); | |
| // --select-symbols=<value>[,<value>,...] | |
| cl::list<LVSymbolKind> cmdline::SelectSymbols( | |
| "select-symbols", cl::cat(SelectCategory), | |
| cl::desc("Symbol kind to use when printing symbols."), cl::Hidden, | |
| cl::CommaSeparated, | |
| values(clEnumValN(LVSymbolKind::IsCallSiteParameter, "CallSiteParameter", | |
| "Call site parameter."), | |
| clEnumValN(LVSymbolKind::IsConstant, "Constant", "Constant."), | |
| clEnumValN(LVSymbolKind::IsInheritance, "Inheritance", | |
| "Inheritance."), | |
| clEnumValN(LVSymbolKind::IsMember, "Member", "Member."), | |
| clEnumValN(LVSymbolKind::IsParameter, "Parameter", "Parameter."), | |
| clEnumValN(LVSymbolKind::IsUnspecified, "Unspecified", | |
| "Unspecified parameter."), | |
| clEnumValN(LVSymbolKind::IsVariable, "Variable", "Variable."))); | |
| // --select-types=<value>[,<value>,...] | |
| cl::list<LVTypeKind> cmdline::SelectTypes( | |
| "select-types", cl::cat(SelectCategory), | |
| cl::desc("Type kind to use when printing types."), cl::Hidden, | |
| cl::CommaSeparated, | |
| values( | |
| clEnumValN(LVTypeKind::IsBase, "Base", "Base Type (int, bool, etc.)."), | |
| clEnumValN(LVTypeKind::IsConst, "Const", "Constant specifier."), | |
| clEnumValN(LVTypeKind::IsEnumerator, "Enumerator", "Enumerator."), | |
| clEnumValN(LVTypeKind::IsImport, "Import", "Import."), | |
| clEnumValN(LVTypeKind::IsImportDeclaration, "ImportDeclaration", | |
| "Import declaration."), | |
| clEnumValN(LVTypeKind::IsImportModule, "ImportModule", | |
| "Import module."), | |
| clEnumValN(LVTypeKind::IsPointer, "Pointer", "Pointer."), | |
| clEnumValN(LVTypeKind::IsPointerMember, "PointerMember", | |
| "Pointer to member."), | |
| clEnumValN(LVTypeKind::IsReference, "Reference", "Reference type."), | |
| clEnumValN(LVTypeKind::IsRestrict, "Restrict", "Restrict specifier."), | |
| clEnumValN(LVTypeKind::IsRvalueReference, "RvalueReference", | |
| "Rvalue reference."), | |
| clEnumValN(LVTypeKind::IsSubrange, "Subrange", "Array subrange."), | |
| clEnumValN(LVTypeKind::IsTemplateParam, "TemplateParam", | |
| "Template Parameter."), | |
| clEnumValN(LVTypeKind::IsTemplateTemplateParam, "TemplateTemplateParam", | |
| "Template template parameter."), | |
| clEnumValN(LVTypeKind::IsTemplateTypeParam, "TemplateTypeParam", | |
| "Template type parameter."), | |
| clEnumValN(LVTypeKind::IsTemplateValueParam, "TemplateValueParam", | |
| "Template value parameter."), | |
| clEnumValN(LVTypeKind::IsTypedef, "Typedef", "Type definition."), | |
| clEnumValN(LVTypeKind::IsUnspecified, "Unspecified", | |
| "Unspecified type."), | |
| clEnumValN(LVTypeKind::IsVolatile, "Volatile", "Volatile specifier."))); | |
| //===----------------------------------------------------------------------===// | |
| // '--warning' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::WarningCategory("Warning Options", | |
| "These control the generated warnings."); | |
| // --warning=<value>[,<value>,...] | |
| cl::list<LVWarningKind> cmdline::WarningOptions( | |
| "warning", cl::cat(WarningCategory), cl::desc("Warnings to generate."), | |
| cl::Hidden, cl::CommaSeparated, | |
| values( | |
| clEnumValN(LVWarningKind::All, "all", "All warnings."), | |
| clEnumValN(LVWarningKind::Coverages, "coverages", | |
| "Invalid symbol coverages values."), | |
| clEnumValN(LVWarningKind::Lines, "lines", "Debug lines that are zero."), | |
| clEnumValN(LVWarningKind::Locations, "locations", | |
| "Invalid symbol locations."), | |
| clEnumValN(LVWarningKind::Ranges, "ranges", "Invalid code ranges."))); | |
| //===----------------------------------------------------------------------===// | |
| // '--internal' options | |
| //===----------------------------------------------------------------------===// | |
| cl::OptionCategory | |
| cmdline::InternalCategory("Internal Options", | |
| "Internal traces and extra debugging code."); | |
| // --internal=<value>[,<value>,...] | |
| cl::list<LVInternalKind> cmdline::InternalOptions( | |
| "internal", cl::cat(InternalCategory), cl::desc("Traces to enable."), | |
| cl::Hidden, cl::CommaSeparated, | |
| values( | |
| clEnumValN(LVInternalKind::All, "all", "Enable all traces."), | |
| clEnumValN(LVInternalKind::Cmdline, "cmdline", "Print command line."), | |
| clEnumValN(LVInternalKind::ID, "id", "Print unique element ID"), | |
| clEnumValN(LVInternalKind::Integrity, "integrity", | |
| "Check elements integrity."), | |
| clEnumValN(LVInternalKind::None, "none", "Ignore element line number."), | |
| clEnumValN(LVInternalKind::Tag, "tag", "Debug information tags."))); | |
| /// @} | |
| // Copy local options into a globally accessible data structure. | |
| void llvm::logicalview::cmdline::propagateOptions() { | |
| // Traverse list of options and update the given set (Using case and Regex). | |
| auto UpdatePattern = [&](auto &List, auto &Set, bool IgnoreCase, | |
| bool UseRegex) { | |
| if (!List.empty()) | |
| for (std::string &Pattern : List) | |
| Set.insert((IgnoreCase && !UseRegex) ? StringRef(Pattern).lower() | |
| : Pattern); | |
| }; | |
| // Handle --select. | |
| UpdatePattern(SelectPatterns, ReaderOptions.Select.Generic, | |
| ReaderOptions.Select.IgnoreCase, ReaderOptions.Select.UseRegex); | |
| // Traverse list of options and update the given set. | |
| auto UpdateSet = [&](auto &List, auto &Set) { | |
| std::copy(List.begin(), List.end(), std::inserter(Set, Set.begin())); | |
| }; | |
| // Handle options sets. | |
| UpdateSet(AttributeOptions, ReaderOptions.Attribute.Kinds); | |
| UpdateSet(PrintOptions, ReaderOptions.Print.Kinds); | |
| UpdateSet(OutputOptions, ReaderOptions.Output.Kinds); | |
| UpdateSet(ReportOptions, ReaderOptions.Report.Kinds); | |
| UpdateSet(WarningOptions, ReaderOptions.Warning.Kinds); | |
| UpdateSet(InternalOptions, ReaderOptions.Internal.Kinds); | |
| UpdateSet(SelectElements, ReaderOptions.Select.Elements); | |
| UpdateSet(SelectLines, ReaderOptions.Select.Lines); | |
| UpdateSet(SelectScopes, ReaderOptions.Select.Scopes); | |
| UpdateSet(SelectSymbols, ReaderOptions.Select.Symbols); | |
| UpdateSet(SelectTypes, ReaderOptions.Select.Types); | |
| UpdateSet(SelectOffsets, ReaderOptions.Select.Offsets); | |
| UpdateSet(CompareElements, ReaderOptions.Compare.Elements); | |
| // Resolve any options dependencies (ie. --print=all should set other | |
| // print options, etc.). | |
| ReaderOptions.resolveDependencies(); | |
| } |