//===-- 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);

//===----------------------------------------------------------------------===//
// '--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::Language, "language",
                      "Source language name."),
           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::Size, "size", "Type sizes."),
           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::location(ReaderOptions.Compare.Context));

// --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::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::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,
    values(clEnumValN(LVSortMode::None, "none",
                      "Unsorted output (i.e. as read from input)."),
           clEnumValN(LVSortMode::ID, "id", "Sort by unique element ID."),
           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::location(ReaderOptions.Select.IgnoreCase));

// --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::location(ReaderOptions.Select.UseRegex));

// --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);

// --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::IsModule, "Module", "Module."),
        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();
}