//===-- 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" usingnamespacellvm; usingnamespacellvm::logicalview; usingnamespacellvm::logicalview::cmdline; /// @} /// Command line options. /// @{ OffsetParser::OffsetParser(cl::Option &O) : … { … } OffsetParser::~OffsetParser() = default; bool OffsetParser::parse(cl::Option &O, StringRef ArgName, StringRef Arg, unsigned long long &Val) { … } 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() { … }
Codebase Browser
llvm