include "OptionsBase.td"

let Command = "target modules dump symtab" in {
  def tm_sort : Option<"sort", "s">,
                Group<1>,
                Desc<"${S}upply a sort order when dumping the symbol table.">,
                EnumArg<"SortOrder">;
  def tm_smn : Option<"show-mangled-names", "m">,
               Group<1>,
               Desc<"Do not de${m}angle symbol names before showing them.">;
}

let Command = "target modules dump separate debug info" in {
  def tm_json : Option<"json", "j">,
                Group<1>,
                Desc<"Output the details in ${J}SON format.">;
  def tm_errors_only
      : Option<"errors-only", "e">,
        Group<1>,
        Desc<"Filter to show only debug info files with ${e}rrors.">;
  def tm_force_load_all_debug_info
      : Option<"force-load-all-debug-info", "f">,
        Group<1>,
        Desc<"${F}orce load all debug info files.">;
}

let Command = "help" in {
  def help_hide_aliases : Option<"hide-aliases", "a">,
                          Desc<"Hide ${a}liases in the command list.">;
  def help_hide_user : Option<"hide-user-commands", "u">,
                       Desc<"Hide ${u}ser-defined commands from the list.">;
  def help_show_hidden : Option<"show-hidden-commands", "h">,
                         Desc<"Include commands prefixed with an underscore.">;
}

let Command = "settings set" in {
  def setset_global
      : Option<"global", "g">,
        Desc<"Apply the new value to the ${g}lobal default value.">;
  def setset_force
      : Option<"force", "f">,
        Desc<"${F}orce an empty value to be accepted as the default.">;
  def setset_exists
      : Option<"exists", "e">,
        Desc<"Set the setting if it ${e}xists, but do not cause the command to "
             "raise an error if it does not exist.">;
}

let Command = "settings write" in {
  def setwrite_file : Option<"file", "f">,
                      Required,
                      Arg<"Filename">,
                      Completion<"DiskFile">,
                      Desc<"The ${f}ile into which to write the settings.">;
  def setwrite_append : Option<"append", "a">,
                        Desc<"${A}ppend to saved settings file if it exists.">;
}

let Command = "settings read" in {
  def setread_file : Option<"file", "f">,
                     Required,
                     Arg<"Filename">,
                     Completion<"DiskFile">,
                     Desc<"The ${f}ile from which to read the settings.">;
}

let Command = "settings clear" in {
  def setclear_all : Option<"all", "a">, Desc<"Clear ${a}ll settings.">;
}

let Command = "settings show" in {
  def setshow_defaults : Option<"defaults", "d">,
                         Desc<"Include ${d}efault values if defined.">;
}

let Command = "breakpoint list" in {
  // FIXME: We need to add an "internal" command, and then add this sort of
  // thing to it. But I need to see it for now, and don't want to wait.
  def blist_internal : Option<"internal", "i">,
                       Desc<"Show debugger ${i}nternal breakpoints.">;
  def blist_brief : Option<"brief", "b">,
                    Group<1>,
                    Desc<"Give a ${b}rief description of the breakpoint (no "
                         "location info).">;
  def blist_full
      : Option<"full", "f">,
        Group<2>,
        Desc<"Give a ${f}ull description of the breakpoint and its locations.">;
  def blist_verbose : Option<"verbose", "v">,
                      Group<3>,
                      Desc<"Explain everything we know about the breakpoint "
                           "(for debugging debugger bugs).">;
  def blist_dummy_bp
      : Option<"dummy-breakpoints", "D">,
        Desc<"List ${D}ummy breakpoints - i.e. breakpoints set before a file "
             "is provided, which prime new targets.">;
}

let Command = "breakpoint modify" in {
  def breakpoint_modify_ignore_count
      : Option<"ignore-count", "i">,
        Group<1>,
        Arg<"Count">,
        Desc<"Set the number of times this breakpoint is skipped before "
             "stopping.">;
  def breakpoint_modify_one_shot
      : Option<"one-shot", "o">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"The breakpoint is deleted the first time it causes a stop.">;
  def breakpoint_modify_thread_index
      : Option<"thread-index", "x">,
        Group<1>,
        Arg<"ThreadIndex">,
        Desc<"The breakpoint stops only for the thread whose inde${x} matches "
             "this argument.">;
  def breakpoint_modify_thread_id
      : Option<"thread-id", "t">,
        Group<1>,
        Arg<"ThreadID">,
        Desc<"The breakpoint stops only for the ${t}hread whose TID matches "
             "this argument.  The token 'current' resolves to the current "
             "thread's ID.">;
  def breakpoint_modify_thread_name
      : Option<"thread-name", "T">,
        Group<1>,
        Arg<"ThreadName">,
        Desc<"The breakpoint stops only for the ${t}hread whose thread name "
             "matches this argument.">;
  def breakpoint_modify_queue_name
      : Option<"queue-name", "q">,
        Group<1>,
        Arg<"QueueName">,
        Desc<"The breakpoint stops only for threads in the ${q}ueue whose name "
             "is given by this argument.">;
  def breakpoint_modify_condition
      : Option<"condition", "c">,
        Group<1>,
        Arg<"Expression">,
        Desc<"The breakpoint stops only if this ${c}ondition expression "
             "evaluates to true.">;
  def breakpoint_modify_condition_language
      : Option<"condition-language", "Y">,
        Group<1>,
        Arg<"Language">,
        Desc<"Specifies the Language to use when executing the breakpoint's "
             "condition expression.">;
  def breakpoint_modify_auto_continue
      : Option<"auto-continue", "G">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"The breakpoint will auto-continue after running its commands.">;
  def breakpoint_modify_enable : Option<"enable", "e">,
                                 Group<2>,
                                 Desc<"${E}nable the breakpoint.">;
  def breakpoint_modify_disable : Option<"disable", "d">,
                                  Group<3>,
                                  Desc<"${D}isable the breakpoint.">;
  def breakpoint_modify_command
      : Option<"command", "C">,
        Group<4>,
        Arg<"Command">,
        Desc<
            "A ${c}ommand to run when the breakpoint is hit, can be provided "
            "more than once, the commands will be run in left-to-right order.">;
}

let Command = "breakpoint dummy" in {
  def breakpoint_dummy_options_dummy_breakpoints
      : Option<"dummy-breakpoints", "D">,
        Group<1>,
        Desc<"Act on ${D}ummy breakpoints - i.e. breakpoints set before a file "
             "is provided, which prime new targets.">;
}

let Command = "breakpoint names" in {
  def breakpoint_name_option_names :
    Option<"breakpoint-name", "N">, Group<1>,
    Arg<"BreakpointName">,
    Desc<"Adds this name to the list of names for this breakpoint.  "
    "Can be specified more than once.">;
}

let Command = "breakpoint set" in {
  def breakpoint_set_shlib
      : Option<"shlib", "s">,
        Arg<"ShlibName">,
        Completion<"Module">,
        Groups<[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12]>, // *not* in group 10
        Desc<
            "${S}et the breakpoint only in this shared library.  Can repeat "
            "this option multiple times to specify multiple shared libraries.">;
  def breakpoint_set_hardware
      : Option<"hardware", "H">,
        Desc<"Require the breakpoint to use ${h}ardware breakpoints.">;
  def breakpoint_set_file
      : Option<"file", "f">,
        Arg<"Filename">,
        Completion<"SourceFile">,
        Groups<[1, 3, 4, 5, 6, 7, 8, 9, 11]>,
        Desc<"Specifies the source ${f}ile in which to set this breakpoint.  "
             "Note, by default lldb only looks for files that are #included if "
             "they use the standard include file extensions.  To set "
             "breakpoints on .c/.cpp/.m/.mm files that are #included, set "
             "target.inline-breakpoint-strategy to \"always\".">;
  def breakpoint_set_line
      : Option<"line", "l">,
        Group<1>,
        Arg<"LineNum">,
        Required,
        Desc<"Specifies the ${l}ine number on which to set this breakpoint.">;
  def breakpoint_set_column
      : Option<"column", "u">,
        Group<1>,
        Arg<"ColumnNum">,
        Desc<"Specifies the col${u}mn number on which to set this breakpoint.">;
  def breakpoint_set_address
      : Option<"address", "a">,
        Group<2>,
        Arg<"AddressOrExpression">,
        Required,
        Desc<"Set the breakpoint at the specified ${a}ddress.  If the address "
             "maps uniquely to a particular binary, then the address will be "
             "converted to a \"file\"address, so that the breakpoint will "
             "track that binary+offset no matter where the binary eventually "
             "loads.  Alternately, if you also specify the module - with the "
             "-s option - then the address will be treated as a file address "
             "in that module, and resolved accordingly.  Again, this will "
             "allow lldb to track that offset on subsequent reloads.  The "
             "module need not have been loaded at the time you specify this "
             "breakpoint, and will get resolved when the module is loaded.">;
  def breakpoint_set_name
      : Option<"name", "n">,
        Group<3>,
        Arg<"FunctionName">,
        Completion<"Symbol">,
        Required,
        Desc<"Set the breakpoint by function ${n}ame.  Can be repeated "
             "multiple times to make one breakpoint for multiple names.">;
  def breakpoint_set_source_regexp_function
      : Option<"source-regexp-function", "X">,
        Group<9>,
        Arg<"FunctionName">,
        Completion<"Symbol">,
        Desc<"When used with '-p' limits the source regex to source contained "
             "in the named functions.  Can be repeated multiple times.">;
  def breakpoint_set_fullname
      : Option<"fullname", "F">,
        Group<4>,
        Arg<"FullName">,
        Required,
        Completion<"Symbol">,
        Desc<"Set the breakpoint by ${f}ully qualified function names. For C++ "
             "this means namespaces and all arguments, and for Objective-C "
             "this means a full function prototype with class and selector.  "
             "Can be repeated multiple times to make one breakpoint for "
             "multiple names.">;
  def breakpoint_set_selector
      : Option<"selector", "S">,
        Group<5>,
        Arg<"Selector">,
        Required,
        Desc<"Set the breakpoint by Objective-C ${s}elector name.  Can be "
             "repeated multiple times to make one breakpoint for multiple "
             "Selectors.">;
  def breakpoint_set_method
      : Option<"method", "M">,
        Group<6>,
        Arg<"Method">,
        Required,
        Desc<"Set the breakpoint by C++ ${m}ethod names.  Can be repeated "
             "multiple times to make one breakpoint for multiple methods.">;
  def breakpoint_set_func_regex
      : Option<"func-regex", "r">,
        Group<7>,
        Arg<"RegularExpression">,
        Required,
        Desc<"Set the breakpoint by function name, evaluating a "
             "${r}egular-expression to find the function name(s).">;
  def breakpoint_set_basename
      : Option<"basename", "b">,
        Group<8>,
        Arg<"FunctionName">,
        Required,
        Completion<"Symbol">,
        Desc<"Set the breakpoint by function ${b}asename (C++ namespaces and "
             "arguments will be ignored).  Can be repeated multiple times to "
             "make one breakpoint for multiple symbols.">;
  def breakpoint_set_source_pattern_regexp
      : Option<"source-pattern-regexp", "p">,
        Group<9>,
        Arg<"RegularExpression">,
        Required,
        Desc<"Set the breakpoint by specifying a regular expression which is "
             "matched against the source text in a source file or files "
             "specified with the -f can be specified more than once.  If no "
             "source files are specified, uses the current \"default source "
             "file\".  If you want to match against all source files, ${p}ass "
             "the \"--all-files\" option.">;
  def breakpoint_set_all_files
      : Option<"all-files", "A">,
        Group<9>,
        Desc<"${A}ll files are searched for source pattern matches.">;
  def breakpoint_set_language_exception
      : Option<"language-exception", "E">,
        Group<10>,
        Arg<"Language">,
        Required,
        Desc<"Set the breakpoint on ${e}xceptions thrown by the specified "
             "language (without options, on throw but not catch.)">;
  def breakpoint_set_on_throw
      : Option<"on-throw", "w">,
        Group<10>,
        Arg<"Boolean">,
        Desc<"Set the breakpoint on exception thro${w}.">;
  def breakpoint_set_on_catch
      : Option<"on-catch", "h">,
        Group<10>,
        Arg<"Boolean">,
        Desc<"Set the breakpoint on exception catc${h}.">;
  def breakpoint_set_language
      : Option<"language", "L">,
        GroupRange<3, 8>,
        Arg<"Language">,
        Desc<"Specifies the ${L}anguage to use when interpreting the "
             "breakpoint's expression (note: currently only implemented for "
             "setting breakpoints on identifiers). If not set the "
             "target.language setting is used.">;
  def breakpoint_set_skip_prologue
      : Option<"skip-prologue", "K">,
        Arg<"Boolean">,
        Groups<[1, 3, 4, 5, 6, 7, 8, 12]>,
        Desc<"S${k}ip the prologue if the breakpoint is at the beginning of a "
             "function. If not set the target.skip-prologue setting is used.">;
  def breakpoint_set_breakpoint_name
      : Option<"breakpoint-name", "N">,
        Arg<"BreakpointName">,
        Desc<"Adds this to the list of ${n}ames for this breakpoint.">;
  def breakpoint_set_address_slide
      : Option<"address-slide", "R">,
        Arg<"Address">,
        Groups<[1, 3, 4, 5, 6, 7, 8, 12]>,
        Desc<"Add the specified offset to whatever address(es) the breakpoint "
             "${r}esolves to. At present this applies the offset directly as "
             "given, and doesn't try to align it to instruction boundaries.">;
  def breakpoint_set_move_to_nearest_code
      : Option<"move-to-nearest-code", "m">,
        Groups<[1, 9, 12]>,
        Arg<"Boolean">,
        Desc<"${M}ove breakpoints to nearest code. If not set the "
             "target.move-to-nearest-code setting is used.">;
  def breakpoint_set_file_colon_line
      : Option<"joint-specifier", "y">,
        Group<12>,
        Arg<"FileLineColumn">,
        Required,
        Completion<"SourceFile">,
        Desc<"A specifier in the form filename:line[:column] for setting file "
             "& line breakpoints.">;
  /* Don't add this option till it actually does something useful...
  def breakpoint_set_exception_typename : Option<"exception-typename", "O">,
    Arg<"TypeName">, Desc<"The breakpoint will only stop if an "
    "exception Object of this type is thrown.  Can be repeated multiple times "
    "to stop for multiple object types">;
   */
}

let Command = "breakpoint add address" in {
  def breakpoint_add_address_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
    Completion<"Module">,
    Desc<"Set the breakpoint at an address relative to sections in this shared"
    " library.">;
  def breakpoint_add_address_hardware : Option<"hardware", "H">,
    Desc<"Require the breakpoint to use hardware breakpoints.">;
}

let Command = "breakpoint add exception" in {
  def breakpoint_add_exception_hardware : Option<"hardware", "H">,
    Desc<"Require the breakpoint to use hardware breakpoints.">;
  def breakpoint_add_exception_typename : Option<"exception-typename", "O">,
    Arg<"TypeName">, Desc<"The breakpoint will only stop if an "
    "exception Object of this type is thrown.  Can be repeated multiple times "
    "to stop for multiple object types">;
  def breakpoint_add_exception_stage : Option<"exception-stage", "E">,
    Arg<"ExceptionStage">,
    Desc<"Stop only at the specified exception stage.  Can be specified more "
         "than once to create a mask of stages.">;
}

let Command = "breakpoint add file" in {
  def breakpoint_add_file_hardware : Option<"hardware", "H">,
    Desc<"Require the breakpoint to use hardware breakpoints.">;
  def breakpoint_add_file_line : Option<"line", "l">, Group<2>, Arg<"LineNum">,
    Required,
    Desc<"Specifies the line number on which to set this breakpoint.">;
  def breakpoint_add_file_filename : Option<"filename", "f">, Group<2>,
    Arg<"Filename">, Completion<"SourceFile">, Desc<"The file in which to seek "
    "the specified source line.">;
  def breakpoint_add_file_column : Option<"column", "u">, Arg<"ColumnNum">, Group<2>,
    Desc<"Specifies the column number on which to set this breakpoint.">;
  def breakpoint_add_file_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
    Completion<"Module">,
    Desc<"Set the breakpoint only in this shared library.  Can repeat this "
    "option multiple times to specify multiple shared libraries.">;
  def breakpoint_add_file_move_to_nearest_code : Option<"move-to-nearest-code", "m">,
    Arg<"Boolean">,
    Desc<"Move breakpoints to nearest code. If not set the "
    "target.move-to-nearest-code setting is used.">;
  def breakpoint_add_file_address_slide : Option<"address-slide", "S">,
    Arg<"Offset">,
    Desc<"Add the specified offset to whatever address(es) the breakpoint "
    "resolves to. At present this applies the offset directly as given, and "
    "doesn't try to align it to instruction boundaries.">;
  def breakpoint_add_file_skip_prologue : Option<"skip-prologue", "K">,
    Arg<"Boolean">,
    Desc<"Skip the prologue if the breakpoint is at the beginning of a "
    "function. If not set the target.skip-prologue setting is used.">;
}

let Command = "breakpoint add name" in {
  def breakpoint_add_name_hardware : Option<"hardware", "H">,
    Desc<"Require the breakpoint to use hardware breakpoints.">;
  def breakpoint_add_name_address_slide : Option<"address-slide", "S">,
    Arg<"Offset">,
    Desc<"Add the specified offset to whatever address(es) the breakpoint "
    "resolves to. At present this applies the offset directly as given, and "
    "doesn't try to align it to instruction boundaries.">;
  def breakpoint_add_name_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
    Completion<"Module">,
    Desc<"Search for names only in this shared library.  Can repeat this "
    "option multiple times to specify multiple shared libraries.">;
  def breakpoint_add_name_filename : Option<"filename", "f">,
    Arg<"Filename">, Completion<"SourceFile">, Desc<"Only search for functions "
    "defined in the given source file.  Can be specified more than once.">;
  def breakpoint_add_name_skip_prologue : Option<"skip-prologue", "K">,
    Arg<"Boolean">,
    Desc<"Skip the prologue if the breakpoint is at the beginning of a "
    "function. If not set the target.skip-prologue setting is used.">;
  def breakpoint_add_name_match_style : Option<"match-style", "m">,
    Arg<"NameMatchStyle">, 
    Desc<"The style of matching to do when looking for candidate symbols - "
    "auto if not specified.">;
  def breakpoint_add_name_language : Option<"name-language", "L">,
    Arg<"Language">,
    Desc<"Only consider indentifiers from the given language when looking for "
    "match candidates.">;
}

let Command = "breakpoint add pattern" in {
  def breakpoint_add_pattern_hardware : Option<"hardware", "H">,
    Desc<"Require the breakpoint to use hardware breakpoints.">;
  def breakpoint_add_pattern_move_to_nearest_code : Option<"move-to-nearest-code", "m">,
    Arg<"Boolean">,
    Desc<"Move breakpoints to nearest code. If not set the "
    "target.move-to-nearest-code setting is used.">;
  def breakpoint_add_pattern_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
    Completion<"Module">,
    Desc<"Search for pattern matches only in this shared library.  Can repeat this "
    "option multiple times to specify multiple shared libraries.">;
  def breakpoint_add_pattern_filename : Option<"filename", "f">, Group<1>,
    Arg<"Filename">, Completion<"SourceFile">, Desc<"Limit the pattern search "
    "to the specified source file.  Can be specified more than once.">;
  def breakpoint_add_pattern_name : Option<"name", "n">, Arg<"FunctionName">,
    Completion<"Symbol">, Group<1>,
    Desc<"Search for pattern matches only in functions matching the specified "
    "function name using the 'auto' match style.  Can be specified more than "
    "once, and composes with the filename option.">;
  def breakpoint_add_pattern_all_files : Option<"all-files", "a">, Group<2>,
    Desc<"All files are searched for source pattern matches, limited by the "
    "shlib argument.">;
}

let Command = "breakpoint add scripted" in {
  def breakpoint_add_scripted_hardware : Option<"hardware", "H">,
    Desc<"Require the breakpoint to use hardware breakpoints.">;
  def breakpoint_add_scripted_filename : Option<"filename", "f">,
    Arg<"Filename">, Completion<"SourceFile">, Desc<"The files in which to apply "
    "the scripted resolver callback.  Can repeat the option multiple times.">;
  def breakpoint_add_scripted_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
    Completion<"Module">,
    Desc<"The module in which to apply the scripted resolver callback.  Can "
    "repeat this option multiple times to specify multiple shared libraries.">;
}


let Command = "breakpoint clear" in {
  def breakpoint_clear_file : Option<"file", "f">,
                              Group<1>,
                              Arg<"Filename">,
                              Completion<"SourceFile">,
                              Desc<"Specify the breakpoint by source location "
                                   "in this particular ${f}ile.">;
  def breakpoint_clear_line : Option<"line", "l">,
                              Group<1>,
                              Arg<"LineNum">,
                              Required,
                              Desc<"Specify the breakpoint by source location "
                                   "at this particular ${l}ine.">;
}

let Command = "breakpoint delete" in {
  def breakpoint_delete_force
      : Option<"force", "f">,
        Group<1>,
        Desc<"Delete all breakpoints without querying for confirmation.">;
  def breakpoint_delete_dummy_breakpoints
      : Option<"dummy-breakpoints", "D">,
        Group<1>,
        Desc<"Delete Dummy breakpoints - i.e. breakpoints set before a file is "
             "provided, which prime new targets.">;
  def breakpoint_delete_disabled
      : Option<"disabled", "d">,
        Group<1>,
        Desc<"${D}elete all breakpoints which are currently disabled. When "
             "using the disabled option any breakpoints listed on the command "
             "line are EXCLUDED from deletion.">;
}

let Command = "breakpoint name" in {
  def breakpoint_name_name : Option<"name", "N">,
                             Group<1>,
                             Arg<"BreakpointName">,
                             Desc<"Specifies a breakpoint name to use.">;
  def breakpoint_name_breakpoint_id : Option<"breakpoint-id", "B">,
                                      Group<2>,
                                      Arg<"BreakpointID">,
                                      Desc<"Specify a breakpoint ID to use.">;
  def breakpoint_name_dummy_breakpoints
      : Option<"dummy-breakpoints", "D">,
        Group<3>,
        Desc<"Operate on Dummy breakpoints - i.e. breakpoints set before a "
             "file is provided, which prime new targets.">;
  def breakpoint_name_help_string
      : Option<"help-string", "H">,
        Group<4>,
        Arg<"None">,
        Desc<"A help string describing the purpose of this name.">;
}

let Command = "breakpoint access" in {
  def breakpoint_access_allow_list
      : Option<"allow-list", "L">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Determines whether the breakpoint will show up in break list if "
             "not referred to explicitly.">;
  def breakpoint_access_allow_disable
      : Option<"allow-disable", "A">,
        Group<2>,
        Arg<"Boolean">,
        Desc<"Determines whether the breakpoint can be disabled by name or "
             "when all breakpoints are disabled.">;
  def breakpoint_access_allow_delete
      : Option<"allow-delete", "D">,
        Group<3>,
        Arg<"Boolean">,
        Desc<"Determines whether the breakpoint can be deleted by name or when "
             "all breakpoints are deleted.">;
}

let Command = "breakpoint read" in {
  def breakpoint_read_file
      : Option<"file", "f">,
        Arg<"Filename">,
        Required,
        Completion<"DiskFile">,
        Desc<"The ${f}ile from which to read the breakpoints.">;
  def breakpoint_read_breakpoint_name
      : Option<"breakpoint-name", "N">,
        Arg<"BreakpointName">,
        Desc<"Only read in breakpoints with this name.">;
}

let Command = "breakpoint write" in {
  def breakpoint_write_file
      : Option<"file", "f">,
        Arg<"Filename">,
        Required,
        Completion<"DiskFile">,
        Desc<"The ${f}ile into which to write the breakpoints.">;
  def breakpoint_write_append
      : Option<"append", "a">,
        Desc<"${A}ppend to saved breakpoints file if it exists.">;
}

let Command = "breakpoint command add" in {
  def breakpoint_add_one_liner
      : Option<"one-liner", "o">,
        Group<1>,
        Arg<"OneLiner">,
        Desc<"Specify a ${o}ne-line breakpoint command inline. Be sure to "
             "surround it with quotes.">;
  def breakpoint_add_stop_on_error
      : Option<"stop-on-error", "e">,
        Arg<"Boolean">,
        Desc<"Specify whether breakpoint command execution should terminate on "
             "error.">;
  def breakpoint_add_script_type
      : Option<"script-type", "s">,
        EnumArg<"ScriptLang">,
        Desc<"Specify the language for the commands - if none is specified, "
             "the lldb command interpreter will be used.">;
  def breakpoint_add_dummy_breakpoints
      : Option<"dummy-breakpoints", "D">,
        Desc<"Sets Dummy breakpoints - i.e. breakpoints set before a file is "
             "provided, which prime new targets.">;
}

let Command = "breakpoint command delete" in {
  def breakpoint_command_delete_dummy_breakpoints
      : Option<"dummy-breakpoints", "D">,
        Group<1>,
        Desc<"Delete commands from Dummy breakpoints - i.e. breakpoints set "
             "before a file is provided, which prime new targets.">;
}

let Command = "disassemble" in {
  def disassemble_options_bytes
      : Option<"bytes", "b">,
        Desc<"Show opcode ${b}ytes when disassembling.">;
  def disassemble_options_kind
      : Option<"kind", "k">,
        Desc<"Show instruction control flow ${k}ind. Refer to the enum "
             "`InstructionControlFlowKind` for a list of control flow kind. As "
             "an important note, far jumps, far calls and far returns often "
             "indicate calls to and from kernel.">;
  def disassemble_options_context
      : Option<"context", "C">,
        Arg<"NumLines">,
        Desc<"Number of ${c}ontext lines of source to show.">;
  def disassemble_options_mixed
      : Option<"mixed", "m">,
        Desc<"Enable ${m}ixed source and assembly display.">;
  def disassemble_options_raw
      : Option<"raw", "r">,
        Desc<"Print ${r}aw disassembly with no symbol information.">;
  def disassemble_options_plugin
      : Option<"plugin", "P">,
        Arg<"Plugin">,
        Desc<"Name of the disassembler ${p}lugin you want to use.">;
  def disassemble_options_flavor
      : Option<"flavor", "F">,
        Arg<"DisassemblyFlavor">,
        Desc<"Name of the disassembly ${f}lavor you want to use. Currently the "
             "only valid options are default, and for Intel architectures, att "
             "and intel.">;
  def disassemble_options_cpu : Option<"cpu", "X">,
                                Arg<"CPUName">,
                                Desc<"Override the CPU for disassembling.">;
  def disassemble_options_features
      : Option<"features", "Y">,
        Arg<"CPUFeatures">,
        Desc<"Specify additional CPU features for disassembling.">;
  def disassemble_options_arch
      : Option<"arch", "A">,
        Arg<"Architecture">,
        Desc<"Specify the ${a}rchitecture to use for cross disassembly.">;
  def disassemble_options_start_address
      : Option<"start-address", "s">,
        Groups<[1, 2]>,
        Arg<"AddressOrExpression">,
        Required,
        Desc<"Address at which to ${s}tart disassembling.">;
  def disassemble_options_end_address
      : Option<"end-address", "e">,
        Group<1>,
        Arg<"AddressOrExpression">,
        Desc<"Address at which to ${e}nd disassembling.">;
  def disassemble_options_count : Option<"count", "c">,
                                  Groups<[2, 3, 4, 5, 7]>,
                                  Arg<"NumLines">,
                                  Desc<"Number of instructions to display.">;
  def disassemble_options_name
      : Option<"name", "n">,
        Group<3>,
        Arg<"FunctionName">,
        Completion<"Symbol">,
        Desc<"Disassemble entire contents of the given function ${n}ame.">;
  def disassemble_options_frame
      : Option<"frame", "f">,
        Group<4>,
        Desc<"Disassemble from the start of the current frame's function.">;
  def disassemble_options_pc : Option<"pc", "p">,
                               Group<5>,
                               Desc<"Disassemble around the current ${p}c.">;
  def disassemble_options_line
      : Option<"line", "l">,
        Group<6>,
        Desc<"Disassemble the current frame's current source ${l}ine "
             "instructions if there is debug line table information, else "
             "disassemble around the pc.">;
  def disassemble_options_address
      : Option<"address", "a">,
        Group<7>,
        Arg<"AddressOrExpression">,
        Desc<"Disassemble function containing this ${a}ddress.">;
  def disassemble_options_force : Option<"force", "\\x01">,
                                  Groups<[2, 3, 4, 5, 7]>,
                                  Desc<"Force disassembly of large functions.">;
  def disassemble_options_variable
      : Option<"variable", "v">,
        Desc<"Enable ${v}ariable disassembly annotations for this invocation.">;
}

let Command = "diagnostics dump" in {
  def diagnostics_dump_directory
      : Option<"directory", "d">,
        Group<1>,
        Arg<"Path">,
        Desc<"Dump the diagnostics to the given directory.">;
}

let Command = "expression" in {
  def expression_options_all_threads
      : Option<"all-threads", "a">,
        Groups<[1, 2]>,
        Arg<"Boolean">,
        Desc<
            "Should we run ${a}ll threads if the execution doesn't complete on "
            "one thread.">;
  def expression_options_ignore_breakpoints
      : Option<"ignore-breakpoints", "i">,
        Groups<[1, 2]>,
        Arg<"Boolean">,
        Desc<"${I}gnore breakpoint hits while running expressions">;
  def expression_options_timeout
      : Option<"timeout", "t">,
        Groups<[1, 2]>,
        Arg<"UnsignedInteger">,
        Desc<"${T}imeout value (in microseconds) for running the expression.">;
  def expression_options_unwind_on_error
      : Option<"unwind-on-error", "u">,
        Groups<[1, 2]>,
        Arg<"Boolean">,
        Desc<"Clean up program state if the expression causes a crash, or "
             "raises a signal. Note, unlike gdb hitting a breakpoint is "
             "controlled by another option (-i).">;
  def expression_options_debug
      : Option<"debug", "g">,
        Groups<[1, 2]>,
        Desc<"When specified, debug the JIT code by setting a breakpoint on "
             "the first instruction and forcing breakpoints to not be ignored "
             "(-i0) and no unwinding to happen on error (-u0).">;
  def expression_options_language
      : Option<"language", "l">,
        Groups<[1, 2, 3]>,
        Arg<"Language">,
        Desc<"Specifies the Language to use when parsing the expression.  If "
             "not set the target.language setting is used.">;
  def expression_options_apply_fixits
      : Option<"apply-fixits", "X">,
        Groups<[1, 2]>,
        Arg<"Boolean">,
        Desc<"If true, simple fix-it hints will be automatically applied to "
             "the expression.">;
  def expression_options_description_verbosity
      : Option<"description-verbosity", "v">,
        Group<1>,
        OptionalEnumArg<"DescriptionVerbosity">,
        Desc<"How verbose should the output of this expression be, if the "
             "object description is asked for.">;
  def expression_options_top_level
      : Option<"top-level", "p">,
        Groups<[1, 2]>,
        Desc<"Interpret the expression as a complete translation unit, without "
             "injecting it into the local context.  Allows declaration of "
             "persistent, top-level entities without a $ prefix.">;
  def expression_options_allow_jit
      : Option<"allow-jit", "j">,
        Groups<[1, 2]>,
        Arg<"Boolean">,
        Desc<"Controls whether the expression can fall back to being JITted if "
             "it's not supported by the interpreter (defaults to true).">;
  def persistent_result
      : Option<"persistent-result", "\\x01">,
        Groups<[1, 2]>,
        Arg<"Boolean">,
        Desc<"Persist expression result in a variable for subsequent use. "
             "Expression results will be labeled with $-prefixed variables, "
             "e.g. $0, $1, etc.">;
  def ignore_context_qualifiers
      : Option<"c++-ignore-context-qualifiers", "Q">,
        Groups<[1, 2]>,
        Desc<"When specified, evaluates the expression without taking into "
             "account the type ${Q}ualifiers of the scope. In C++, this would "
             "permit calling a non-const method when stopped in a const-method "
             "(which would be disallowed by language rules).">;
}

let Command = "frame diag" in {
  def frame_diag_register : Option<"register", "r">,
                            Group<1>,
                            Arg<"RegisterName">,
                            Desc<"A register to diagnose.">;
  def frame_diag_address : Option<"address", "a">,
                           Group<1>,
                           Arg<"Address">,
                           Desc<"An address to diagnose.">;
  def frame_diag_offset : Option<"offset", "o">,
                          Group<1>,
                          Arg<"Offset">,
                          Desc<"An optional offset.  Requires --register.">;
}

let Command = "frame select" in {
  def frame_select_relative
      : Option<"relative", "r">,
        Group<1>,
        Arg<"Offset">,
        Desc<"A relative frame index offset from the current frame index.">;
}

let Command = "frame recognizer add" in {
  def frame_recognizer_shlib : Option<"shlib", "s">,
                               Arg<"ShlibName">,
                               Completion<"Module">,
                               Desc<"Name of the module or shared library that "
                                    "this recognizer applies to.">;
  def frame_recognizer_function
      : Option<"function", "n">,
        Arg<"Name">,
        Completion<"Symbol">,
        Desc<"Name of the function that this recognizer applies to. Can be "
             "specified more than once except if -x|--regex is provided.">;
  def frame_recognizer_python_class : Option<"python-class", "l">,
                                      Group<2>,
                                      Arg<"PythonClass">,
                                      Desc<"Give the name of a Python class to "
                                           "use for this frame recognizer.">;
  def frame_recognizer_regex
      : Option<"regex", "x">,
        Desc<"Function name and module name are actually regular expressions.">;
  def frame_recognizer_first_instruction_only
      : Option<"first-instruction-only", "f">,
        Arg<"Boolean">,
        Desc<"If true, only apply this recognizer to frames whose PC currently "
             "points to the first instruction of the specified function. If "
             "false, the recognizer will always be applied, regardless of the "
             "current position within the specified function. The implementer "
             "should keep in mind that some features, e.g., accessing function "
             "argument values via $arg<N>, are not guaranteed to work reliably "
             "in this case, so extra care must be taken to make the recognizer "
             "operate correctly. Defaults to true.">;
}

let Command = "history" in {
  def history_count : Option<"count", "c">,
                      Group<1>,
                      Arg<"UnsignedInteger">,
                      Desc<"How many history commands to print.">;
  def history_start_index : Option<"start-index", "s">,
                            Group<1>,
                            Arg<"UnsignedInteger">,
                            Desc<"Index at which to start printing history "
                                 "commands (or end to mean tail mode).">;
  def history_end_index
      : Option<"end-index", "e">,
        Group<1>,
        Arg<"UnsignedInteger">,
        Desc<"Index at which to stop printing history commands.">;
  def history_clear : Option<"clear", "C">,
                      Group<2>,
                      Desc<"Clears the current command history.">;
}

let Command = "log enable" in {
  def log_file : Option<"file", "f">,
                 Group<1>,
                 Arg<"Filename">,
                 Desc<"Set the destination file to log to.">;
  def log_handler : Option<"log-handler", "h">,
                    Group<1>,
                    EnumArg<"LogHandler">,
                    Desc<"Specify a log handler which determines where log "
                         "messages are written.">;
  def log_buffer_size : Option<"buffer", "b">,
                        Group<1>,
                        Arg<"UnsignedInteger">,
                        Desc<"Set the log to be buffered, using the specified "
                             "buffer size, if supported by the log handler.">;
  def log_verbose : Option<"verbose", "v">,
                    Group<1>,
                    Desc<"Enable verbose logging.">;
  def log_sequence
      : Option<"sequence", "s">,
        Group<1>,
        Desc<"Prepend all log lines with an increasing integer sequence id.">;
  def log_timestamp : Option<"timestamp", "T">,
                      Group<1>,
                      Desc<"Prepend all log lines with a timestamp.">;
  def log_pid_tid : Option<"pid-tid", "p">,
                    Group<1>,
                    Desc<"Prepend all log lines with the process and thread ID "
                         "that generates the log line.">;
  def log_thread_name : Option<"thread-name", "n">,
                        Group<1>,
                        Desc<"Prepend all log lines with the thread name for "
                             "the thread that generates the log line.">;

  def log_stack : Option<"stack", "S">,
                  Group<1>,
                  Desc<"Append a stack backtrace to each log line.">;
  def log_append : Option<"append", "a">,
                   Group<1>,
                   Desc<"Append to the log file instead of overwriting.">;
  def log_file_function
      : Option<"file-function", "F">,
        Group<1>,
        Desc<"Prepend the names of files and function that generate the logs.">;
}

let Command = "log dump" in {
  def log_dump_file : Option<"file", "f">,
                      Group<1>,
                      Arg<"Filename">,
                      Desc<"Set the destination file to dump to.">;
}

let Command = "memory read" in {
  def memory_read_num_per_line
      : Option<"num-per-line", "l">,
        Group<1>,
        Arg<"NumberPerLine">,
        Desc<"The number of items per line to display.">;
  def memory_read_binary
      : Option<"binary", "b">,
        Group<2>,
        Desc<"If true, memory will be saved as binary. If false, the memory is "
             "saved as an ASCII dump that uses the format, size, count "
             "and number per line settings.">;
  def memory_read_type : Option<"type", "t">,
                         Groups<[3, 4]>,
                         Arg<"Name">,
                         Required,
                         Desc<"The name of a type to view memory as.">;
  def memory_read_language
      : Option<"language", "x">,
        Group<4>,
        Arg<"Language">,
        Desc<"The language of the type to view memory as.">;
  def memory_read_offset : Option<"offset", "E">,
                           Group<3>,
                           Arg<"Count">,
                           Desc<"How many elements of the specified type to "
                                "skip before starting to display data.">;
  def memory_read_force
      : Option<"force", "r">,
        Groups<[1, 2, 3]>,
        Desc<"Necessary if reading over target.max-memory-read-size bytes.">;
}

let Command = "memory find" in {
  def memory_find_expression
      : Option<"expression", "e">,
        Group<1>,
        Arg<"Expression">,
        Required,
        Desc<"Evaluate an expression to obtain a byte pattern.">;
  def memory_find_string : Option<"string", "s">,
                           Group<2>,
                           Arg<"Name">,
                           Required,
                           Desc<"Use text to find a byte pattern.">;
  def memory_find_count : Option<"count", "c">,
                          Arg<"Count">,
                          Desc<"How many times to perform the search.">;
  def memory_find_dump_offset
      : Option<"dump-offset", "o">,
        Arg<"Offset">,
        Desc<"When dumping memory for a match, an offset from the match "
             "location to start dumping from.">;
}

let Command = "memory write" in {
  def memory_write_infile : Option<"infile", "i">,
                            Group<1>,
                            Arg<"Filename">,
                            Required,
                            Desc<"Write memory using the contents of a file.">;
  def memory_write_offset
      : Option<"offset", "o">,
        Group<1>,
        Arg<"Offset">,
        Desc<"Start writing bytes from an offset within the input file.">;
}

let Command = "memory region" in {
  def memory_region_all : Option<"all", "a">,
                          Group<2>,
                          Required,
                          Desc<"Show all memory regions. This is equivalent to "
                               "starting from address 0 and repeating the "
                               "command. Unmapped areas are included.">;
}

let Command = "memory tag write" in {
  def memory_write_end_addr
      : Option<"end-addr", "e">,
        Group<1>,
        Arg<"AddressOrExpression">,
        Desc<"Set tags for start address to end-addr, repeating tags as needed "
             "to cover the range. (instead of calculating the range from the "
             "number of tags given)">;
}

let Command = "register read" in {
  def register_read_alternate
      : Option<"alternate", "A">,
        Desc<"Display register names using the alternate register name if "
             "there is one.">;
  def register_read_set : Option<"set", "s">,
                          Group<1>,
                          Arg<"Index">,
                          Desc<"Specify which register sets to dump by index.">;
  def register_read_all : Option<"all", "a">,
                          Group<2>,
                          Desc<"Show all register sets.">;
}

let Command = "source" in {
  def source_stop_on_error : Option<"stop-on-error", "e">,
                             Arg<"Boolean">,
                             Desc<"If true, stop executing commands on error.">;
  def source_stop_on_continue
      : Option<"stop-on-continue", "c">,
        Arg<"Boolean">,
        Desc<"If true, stop executing commands on continue.">;
  def source_silent_run : Option<"silent-run", "s">,
                          Arg<"Boolean">,
                          Desc<"If true don't echo commands while executing.">;
  def cmd_relative_to_command_file
      : Option<"relative-to-command-file", "C">,
        Desc<"Resolve non-absolute paths relative to the location of the "
             "current command file. This argument can only be used when the "
             "command is being sourced from a file.">;
}

let Command = "alias" in {
  def alias_help : Option<"help", "h">,
                   Arg<"HelpText">,
                   Desc<"Help text for this command">;
  def alias_long_help : Option<"long-help", "H">,
                        Arg<"HelpText">,
                        Desc<"Long help text for this command">;
}

let Command = "regex" in {
  def regex_help : Option<"help", "h">,
                   Group<1>,
                   Arg<"None">,
                   Desc<"The help text to display for this command.">;
  def regex_syntax : Option<"syntax", "s">,
                     Group<1>,
                     Arg<"None">,
                     Desc<"A syntax string showing the typical usage syntax.">;
}

let Command = "permissions" in {
  def permissions_permissions_value
      : Option<"permissions-value", "v">,
        Arg<"PermissionsNumber">,
        Desc<"Give out the numeric value for permissions (e.g. 757)">;
  def permissions_permissions_string
      : Option<"permissions-string", "s">,
        Arg<"PermissionsString">,
        Desc<"Give out the string value for permissions (e.g. rwxr-xr--).">;
  def permissions_user_read : Option<"user-read", "r">,
                              Desc<"Allow user to read.">;
  def permissions_user_write : Option<"user-write", "w">,
                               Desc<"Allow user to write.">;
  def permissions_user_exec : Option<"user-exec", "x">,
                              Desc<"Allow user to execute.">;
  def permissions_group_read : Option<"group-read", "R">,
                               Desc<"Allow group to read.">;
  def permissions_group_write : Option<"group-write", "W">,
                                Desc<"Allow group to write.">;
  def permissions_group_exec : Option<"group-exec", "X">,
                               Desc<"Allow group to execute.">;
  def permissions_world_read : Option<"world-read", "d">,
                               Desc<"Allow world to read.">;
  def permissions_world_write : Option<"world-write", "t">,
                                Desc<"Allow world to write.">;
  def permissions_world_exec : Option<"world-exec", "e">,
                               Desc<"Allow world to execute.">;
}

let Command = "platform fread" in {
  def platform_fread_offset
      : Option<"offset", "o">,
        Group<1>,
        Arg<"Index">,
        Desc<"Offset into the file at which to start reading.">;
  def platform_fread_count : Option<"count", "c">,
                             Group<1>,
                             Arg<"Count">,
                             Desc<"Number of bytes to read from the file.">;
}

let Command = "platform fwrite" in {
  def platform_fwrite_offset
      : Option<"offset", "o">,
        Group<1>,
        Arg<"Index">,
        Desc<"Offset into the file at which to start reading.">;
  def platform_fwrite_data : Option<"data", "d">,
                             Group<1>,
                             Arg<"Value">,
                             Desc<"Text to write to the file.">;
}

let Command = "platform process list" in {
  def platform_process_list_pid
      : Option<"pid", "p">,
        Group<1>,
        Arg<"Pid">,
        Desc<"List the process info for a specific process ID.">;
  def platform_process_list_name
      : Option<"name", "n">,
        Group<2>,
        Arg<"ProcessName">,
        Required,
        Desc<"Find processes with executable basenames that match a string.">;
  def platform_process_list_ends_with
      : Option<"ends-with", "e">,
        Group<3>,
        Arg<"ProcessName">,
        Required,
        Desc<
            "Find processes with executable basenames that end with a string.">;
  def platform_process_list_starts_with
      : Option<"starts-with", "s">,
        Group<4>,
        Arg<"ProcessName">,
        Required,
        Desc<"Find processes with executable basenames that start with a "
             "string.">;
  def platform_process_list_contains
      : Option<"contains", "c">,
        Group<5>,
        Arg<"ProcessName">,
        Required,
        Desc<"Find processes with executable basenames that contain a string.">;
  def platform_process_list_regex
      : Option<"regex", "r">,
        Group<6>,
        Arg<"RegularExpression">,
        Required,
        Desc<"Find processes with executable basenames that match a regular "
             "expression.">;
  def platform_process_list_parent
      : Option<"parent", "P">,
        GroupRange<2, 6>,
        Arg<"Pid">,
        Desc<"Find processes that have a matching parent process ID.">;
  def platform_process_list_uid
      : Option<"uid", "u">,
        GroupRange<2, 6>,
        Arg<"UnsignedInteger">,
        Validator<"&posix_validator">,
        Desc<"Find processes that have a matching user ID.">;
  def platform_process_list_euid
      : Option<"euid", "U">,
        GroupRange<2, 6>,
        Arg<"UnsignedInteger">,
        Validator<"&posix_validator">,
        Desc<"Find processes that have a matching effective user ID.">;
  def platform_process_list_gid
      : Option<"gid", "g">,
        GroupRange<2, 6>,
        Arg<"UnsignedInteger">,
        Validator<"&posix_validator">,
        Desc<"Find processes that have a matching group ID.">;
  def platform_process_list_egid
      : Option<"egid", "G">,
        GroupRange<2, 6>,
        Arg<"UnsignedInteger">,
        Validator<"&posix_validator">,
        Desc<"Find processes that have a matching effective group ID.">;
  def platform_process_list_arch
      : Option<"arch", "a">,
        GroupRange<2, 6>,
        Arg<"Architecture">,
        Desc<"Find processes that have a matching architecture.">;
  def platform_process_list_show_args
      : Option<"show-args", "A">,
        GroupRange<1, 6>,
        Desc<"Show process arguments instead of the process executable "
             "basename.">;
  def platform_process_list_all_users
      : Option<"all-users", "x">,
        GroupRange<1, 6>,
        Desc<"Show processes matching all user IDs.">;
  def platform_process_list_verbose : Option<"verbose", "v">,
                                      GroupRange<1, 6>,
                                      Desc<"Enable verbose output.">;
}

let Command = "platform process attach" in {
  def platform_process_attach_plugin
      : Option<"plugin", "P">,
        Arg<"Plugin">,
        Desc<"Name of the process plugin you want to use.">;
  def platform_process_attach_pid
      : Option<"pid", "p">,
        Group<1>,
        Arg<"Pid">,
        Desc<"The process ID of an existing process to attach to.">;
  def platform_process_attach_name
      : Option<"name", "n">,
        Group<2>,
        Arg<"ProcessName">,
        Desc<"The name of the process to attach to.">;
  def platform_process_attach_waitfor
      : Option<"waitfor", "w">,
        Group<2>,
        Desc<"Wait for the process with <process-name> to launch.">;
}

let Command = "platform shell" in {
  def platform_shell_host
      : Option<"host", "h">,
        Desc<"Run the commands on the host shell when enabled.">;
  def platform_shell_timeout : Option<"timeout", "t">,
                               Arg<"Value">,
                               Desc<"Seconds to wait for the remote host to "
                                    "finish running the command.">;
  def platform_shell_interpreter : Option<"shell", "s">,
                                   Arg<"Path">,
                                   Desc<"Shell interpreter path. This is the "
                                        "binary used to run the command.">;
}

let Command = "plugin list" in {
  def plugin_list_json : Option<"json", "j">,
                         Desc<"Output the plugin list in json format.">;
}

let Command = "process launch" in {
  def process_launch_stop_at_entry
      : Option<"stop-at-entry", "s">,
        Desc<
            "Stop at the entry point of the program when launching a process.">;
  def process_launch_stop_at_user_entry
      : Option<"stop-at-user-entry", "m">,
        Desc<"Stop at the user entry point when launching a process. For C "
             "based languages this will be the 'main' function, but this might "
             "differ for other languages.">;
  def process_launch_disable_aslr
      : Option<"disable-aslr", "A">,
        Arg<"Boolean">,
        Desc<"Set whether to disable address space layout randomization when "
             "launching a process.">;
  def process_launch_plugin
      : Option<"plugin", "P">,
        Arg<"Plugin">,
        Desc<"Name of the process plugin you want to use.">;
  def process_launch_working_dir
      : Option<"working-dir", "w">,
        Arg<"DirectoryName">,
        Desc<"Set the current working directory to <path> when running the "
             "inferior. This option applies only to the current `process "
             "launch` invocation. If `target.launch-working-dir` is set and "
             "this option is given, the value of this option will be used "
             "instead of the setting.">;
  def process_launch_arch
      : Option<"arch", "a">,
        Arg<"Architecture">,
        Desc<"Set the architecture for the process to launch when ambiguous.">;
  def process_launch_environment
      : Option<"environment", "E">,
        Arg<"None">,
        Desc<"Specify an environment variable name/value string (--environment "
             "NAME=VALUE). Can be specified multiple times for subsequent "
             "environment entries.">;
  def process_launch_shell
      : Option<"shell", "c">,
        GroupRange<1, 3>,
        OptionalArg<"Filename">,
        Desc<"Run the process in a shell (not supported on all platforms).">;
  def process_launch_stdin
      : Option<"stdin", "i">,
        Group<1>,
        Arg<"Filename">,
        Desc<"Redirect stdin for the process to <filename>.">;
  def process_launch_stdout
      : Option<"stdout", "o">,
        Group<1>,
        Arg<"Filename">,
        Desc<"Redirect stdout for the process to <filename>.">;
  def process_launch_stderr
      : Option<"stderr", "e">,
        Group<1>,
        Arg<"Filename">,
        Desc<"Redirect stderr for the process to <filename>.">;
  def process_launch_tty : Option<"tty", "t">,
                           Group<2>,
                           Desc<"Start the process in a terminal (not "
                                "supported on all platforms).">;
  def process_launch_no_stdio
      : Option<"no-stdio", "n">,
        Group<3>,
        Desc<"Do not set up for terminal I/O to go to running process.">;
  def process_launch_shell_expand_args
      : Option<"shell-expand-args", "X">,
        Group<4>,
        Arg<"Boolean">,
        Desc<"Set whether to shell expand arguments to the process when "
             "launching.">;
  def process_launch_memory_tagging
      : Option<"memory-tagging", "M">,
        Desc<"Set whether to explicitly enable memory tagging when launching "
             "the process.  Requires hardware support.  "
             "(Only supported on Darwin.)">;
}

let Command = "process attach" in {
  def process_attach_continue
      : Option<"continue", "c">,
        Desc<"Immediately ${c}ontinue the process once attached.">;
  def process_attach_plugin
      : Option<"plugin", "P">,
        Arg<"Plugin">,
        Desc<"Name of the process ${p}lugin you want to use.">;
  def process_attach_pid
      : Option<"pid", "p">,
        Group<1>,
        Arg<"Pid">,
        Desc<"The ${p}rocess ID of an existing process to attach to.">;
  def process_attach_name : Option<"name", "n">,
                            Group<2>,
                            Arg<"ProcessName">,
                            Desc<"The ${n}ame of the process to attach to.">;
  def process_attach_include_existing
      : Option<"include-existing", "i">,
        Group<2>,
        Desc<"${I}nclude existing processes when doing attach -w.">;
  def process_attach_waitfor
      : Option<"waitfor", "w">,
        Group<2>,
        Desc<"${W}ait for the process with <process-name> to launch.">;
}

let Command = "process continue" in {
  def process_continue_ignore_count
      : Option<"ignore-count", "i">,
        Groups<[1, 2]>,
        Arg<"UnsignedInteger">,
        Desc<"Ignore <N> crossings of the breakpoint (if it exists) for the "
             "currently selected thread.">;
  def process_continue_run_to_bkpt
      : Option<"continue-to-bkpt", "b">,
        Groups<[3, 4]>,
        Arg<"BreakpointIDRange">,
        Desc<"Specify a breakpoint to continue to, temporarily ignoring other "
             "breakpoints.  Can be specified more than once.  The continue "
             "action will be done synchronously if this option is specified.">;
  def thread_continue_forward
      : Option<"forward", "F">,
        Groups<[1, 3]>,
        Desc<"Set the direction to forward before continuing.">;
  def thread_continue_reverse
      : Option<"reverse", "R">,
        Groups<[2, 4]>,
        Desc<"Set the direction to reverse before continuing.">;
}

let Command = "process detach" in {
  def process_detach_keep_stopped
      : Option<"keep-stopped", "s">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Whether or not the process should be kept stopped on"
             " detach (if possible).">;
}

let Command = "process connect" in {
  def process_connect_plugin
      : Option<"plugin", "p">,
        Arg<"Plugin">,
        Desc<"Name of the process plugin you want to use.">;
}

let Command = "process load" in {
  def process_load_install
      : Option<"install", "i">,
        OptionalArg<"Path">,
        Desc<
            "Install the shared library to the target. If specified without an "
            "argument then the library will installed in the current working "
            "directory.">;
}

let Command = "process handle" in {
  def process_handle_clear
      : Option<"clear", "c">,
        Group<2>,
        Desc<"Removes the signals listed from the Target signal handlers">;
  def process_handle_stop
      : Option<"stop", "s">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Whether or not the process should be stopped if the signal is "
             "received.">;
  def process_handle_notify : Option<"notify", "n">,
                              Group<1>,
                              Arg<"Boolean">,
                              Desc<"Whether or not the debugger should notify "
                                   "the user if the signal is "
                                   "received.">;
  def process_handle_pass
      : Option<"pass", "p">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Whether or not the signal should be passed to the process.">;
  def process_handle_only_target
      : Option<"target", "t">,
        Group<1>,
        Desc<"Show only the signals with behaviors modified in this target">;
  def process_handle_dummy : Option<"dummy", "d">,
                             Group<2>,
                             Desc<"Also clear the values in the dummy target "
                                  "so they won't be inherited by new targets.">;
}

let Command = "process status" in {
  def process_status_verbose : Option<"verbose", "v">,
                               Group<1>,
                               Desc<"Show verbose process status including "
                                    "extended crash information.">;
  def process_status_dump
      : Option<"dump-modification-id", "d">,
        Group<1>,
        Desc<"Dump the state of the ProcessModID of the stopped process.">;
}

let Command = "process save_core" in {
  def process_save_core_style : Option<"style", "s">,
                                Group<1>,
                                EnumArg<"SaveCoreStyle">,
                                Desc<"Request a specific style "
                                     "of corefile to be saved.">;
  def process_save_core_plugin_name
      : Option<"plugin-name", "p">,
        OptionalArg<"Plugin">,
        Desc<"Specify a plugin name to create the core file. "
             "This allows core files to be saved in different formats.">;
}

let Command = "script import" in {
  def script_import_allow_reload
      : Option<"allow-reload", "r">,
        Group<1>,
        Desc<"Allow the script to be loaded even if it was already loaded "
             "before. "
             "This argument exists for backwards compatibility, but reloading "
             "is always "
             "allowed, whether you specify it or not.">;
  def relative_to_command_file
      : Option<"relative-to-command-file", "c">,
        Group<1>,
        Desc<"Resolve non-absolute paths relative to the location of the "
             "current command file. This argument can only be used when the "
             "command is "
             "being sourced from a file.">;
  def silent : Option<"silent", "s">,
               Group<1>,
               Desc<"If true don't print any script output while importing.">;
}

let Command = "script add" in {
  def script_add_function
      : Option<"function", "f">,
        Group<1>,
        Arg<"PythonFunction">,
        Desc<"Name of the Python function to bind to this command name.">;
  def script_add_class
      : Option<"class", "c">,
        Groups<[2, 3]>,
        Arg<"PythonClass">,
        Desc<"Name of the Python class to bind to this command name.">;
  def script_add_help : Option<"help", "h">,
                        Group<1>,
                        Arg<"HelpText">,
                        Desc<"The help text to display for this command.">;
  def script_add_overwrite
      : Option<"overwrite", "o">,
        Desc<"Overwrite an existing command at this node.">;
  def script_add_synchronicity
      : Option<"synchronicity", "s">,
        EnumArg<"ScriptedCommandSynchronicity">,
        Desc<
            "Set the synchronicity of this command's executions with regard to "
            "LLDB event system.">;
  def script_add_completion_type
      : Option<"completion-type", "C">,
        Groups<[1, 2]>,
        EnumArg<"CompletionType">,
        Desc<
            "Specify which completion type the command should use - if none is "
            "specified, the command won't use auto-completion.">;
  def script_add_parsed_command
      : Option<"parsed", "p">,
        Group<3>,
        Desc<
            "Make a parsed command. The command class will provide the command "
            "definition by implementing get_options and get_arguments.">;
}

let Command = "container add" in {
  def container_add_help : Option<"help", "h">,
                           Arg<"HelpText">,
                           Desc<"Help text for this command">;
  def container_add_long_help : Option<"long-help", "H">,
                                Arg<"HelpText">,
                                Desc<"Long help text for this command">;
  def container_add_overwrite
      : Option<"overwrite", "o">,
        Group<1>,
        Desc<"Overwrite an existing command at this node.">;
}

let Command = "scripting run" in {
  def script_language : Option<"language", "l">,
                        EnumArg<"ScriptLang">,
                        Desc<"Specify the scripting "
                             " language. If none is specific the default "
                             "scripting language is used.">;
}

let Command = "scripting extension list" in {
  def scripting_extension_list_language
      : Option<"language", "l">,
        EnumArg<"ScriptLang">,
        Desc<"Specify the scripting "
             " language. If none is specified the default scripting language "
             "is used.">;
}

let Command = "source info" in {
  def source_info_count : Option<"count", "c">,
                          Arg<"Count">,
                          Desc<"The number of line entries to display.">;
  def source_info_shlib
      : Option<"shlib", "s">,
        Groups<[1, 2]>,
        Arg<"ShlibName">,
        Completion<"Module">,
        Desc<"Look up the source in the given module or "
             "shared library (can be specified more than once).">;
  def source_info_file : Option<"file", "f">,
                         Group<1>,
                         Arg<"Filename">,
                         Completion<"SourceFile">,
                         Desc<"The file from which to display source.">;
  def source_info_line
      : Option<"line", "l">,
        Group<1>,
        Arg<"LineNum">,
        Desc<"The line number at which to start the displaying lines.">;
  def source_info_end_line
      : Option<"end-line", "e">,
        Group<1>,
        Arg<"LineNum">,
        Desc<"The line number at which to stop displaying lines.">;
  def source_info_name
      : Option<"name", "n">,
        Group<2>,
        Arg<"Symbol">,
        Completion<"Symbol">,
        Desc<"The name of a function whose source to display.">;
  def source_info_address
      : Option<"address", "a">,
        Group<3>,
        Arg<"AddressOrExpression">,
        Desc<"Lookup the address and display the source"
             " information for the corresponding file and line.">;
}

let Command = "source list" in {
  def source_list_count : Option<"count", "c">,
                          Arg<"Count">,
                          Desc<"The number of source lines to display.">;
  def source_list_shlib
      : Option<"shlib", "s">,
        Groups<[1, 2, 5]>,
        Arg<"ShlibName">,
        Completion<"Module">,
        Desc<"Look up the source file in the given shared library.">;
  def source_list_show_breakpoints
      : Option<"show-breakpoints", "b">,
        Desc<"Show the line table locations from the debug information that "
             "indicate valid places to set source level breakpoints.">;
  def source_list_file : Option<"file", "f">,
                         Group<1>,
                         Arg<"Filename">,
                         Completion<"SourceFile">,
                         Desc<"The file from which to display source.">;
  def source_list_line
      : Option<"line", "l">,
        Group<1>,
        Arg<"LineNum">,
        Desc<"The line number at which to start displaying source.">;
  def source_list_name
      : Option<"name", "n">,
        Group<2>,
        Arg<"Symbol">,
        Completion<"Symbol">,
        Desc<"The name of a function whose source to display.">;
  def source_list_address
      : Option<"address", "a">,
        Group<3>,
        Arg<"AddressOrExpression">,
        Desc<"Lookup the address and display the source information for the "
             "corresponding file and line.">;
  def source_list_reverse : Option<"reverse", "r">,
                            Group<4>,
                            Desc<"Reverse the listing to look backwards from "
                                 "the last displayed block of source.">;
  def source_list_file_colon_line
      : Option<"joint-specifier", "y">,
        Group<5>,
        Arg<"FileLineColumn">,
        Completion<"SourceFile">,
        Desc<"A specifier in the form filename:line[:column] from which to "
             "display source.">;
}

let Command = "target dependents" in {
  def dependents_no_dependents
      : Option<"no-dependents", "d">,
        Group<1>,
        OptionalEnumArg<"Value">,
        Desc<"Whether or not to load dependents when creating a target. If the "
             "option is not specified, the value is implicitly 'default'. If "
             "the "
             "option is specified but without a value, the value is implicitly "
             "'true'.">;
}

let Command = "target modules dump" in {
  def target_modules_dump_verbose : Option<"verbose", "v">,
                                    Desc<"Enable verbose dump.">;
}

let Command = "target modules list" in {
  def target_modules_list_address : Option<"address", "a">,
                                    Group<1>,
                                    Arg<"AddressOrExpression">,
                                    Desc<"Display the image at this address.">;
  def target_modules_list_arch
      : Option<"arch", "A">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the architecture when listing images.">;
  def target_modules_list_triple
      : Option<"triple", "t">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the triple when listing images.">;
  def target_modules_list_header : Option<"header", "h">,
                                   Group<1>,
                                   Desc<"Display the image base address as a "
                                        "load address if debugging, a file"
                                        " address otherwise.">;
  def target_modules_list_offset
      : Option<"offset", "o">,
        Group<1>,
        Desc<"Display the image load address offset from the base file address "
             "(the slide amount).">;
  def target_modules_list_uuid : Option<"uuid", "u">,
                                 Group<1>,
                                 Desc<"Display the UUID when listing images.">;
  def target_modules_list_fullpath
      : Option<"fullpath", "f">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the fullpath to the image object file.">;
  def target_modules_list_directory
      : Option<"directory", "d">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the directory with optional width for "
             "the image object file.">;
  def target_modules_list_basename
      : Option<"basename", "b">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the basename with optional width for "
             "the image object file.">;
  def target_modules_list_symfile
      : Option<"symfile", "s">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the fullpath to the image symbol file "
             "with optional width.">;
  def target_modules_list_symfile_unique
      : Option<"symfile-unique", "S">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the symbol file with optional"
             " width only if it is different from the executable object file.">;
  def target_modules_list_mod_time
      : Option<"mod-time", "m">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<"Display the modification time with optional "
             "width of the module.">;
  def target_modules_list_ref_count
      : Option<"ref-count", "r">,
        Group<1>,
        OptionalArg<"Width">,
        Desc<
            "Display whether the module is still in the "
            "the shared module cache (Y/N), and its shared pointer use_count.">;
  def target_modules_list_pointer : Option<"pointer", "p">,
                                    Group<1>,
                                    OptionalArg<"None">,
                                    Desc<"Display the module pointer.">;
  def target_modules_list_global
      : Option<"global", "g">,
        Group<1>,
        Desc<"Display the modules from the global module list, not just the "
             "current target.">;
}

let Command = "target modules show unwind" in {
  def target_modules_show_unwind_name
      : Option<"name", "n">,
        Group<1>,
        Arg<"FunctionName">,
        Desc<"Show unwind instructions for a function or symbol name.">;
  def target_modules_show_unwind_address
      : Option<"address", "a">,
        Group<2>,
        Arg<"AddressOrExpression">,
        Desc<"Show unwind instructions for a function "
             "or symbol containing an address">;
  def target_modules_show_unwind_cached
      : Option<"cached", "c">,
        Arg<"Boolean">,
        Desc<"Show cached unwind information">;
}

let Command = "target modules lookup" in {
  def target_modules_lookup_address : Option<"address", "a">,
                                      Group<1>,
                                      Arg<"AddressOrExpression">,
                                      Required,
                                      Desc<"Lookup an address in one or "
                                           "more target modules.">;
  def target_modules_lookup_offset
      : Option<"offset", "o">,
        Group<1>,
        Arg<"Offset">,
        Desc<"When looking up an address subtract <offset> from any "
             "addresses before doing the lookup.">;
  // FIXME: re-enable regex for types when the LookupTypeInModule actually uses
  // the regex option by adding to group 6.
  def target_modules_lookup_regex
      : Option<"regex", "r">,
        Groups<[2, 4, 5]>,
        Desc<"The <name> argument for name lookups are regular expressions.">;
  def target_modules_lookup_symbol
      : Option<"symbol", "s">,
        Group<2>,
        Arg<"Symbol">,
        Required,
        Desc<"Lookup a symbol by name in the symbol tables"
             " in one or more target modules.">;
  def target_modules_lookup_file
      : Option<"file", "f">,
        Group<3>,
        Arg<"Filename">,
        Required,
        Desc<"Lookup a file by fullpath or basename in "
             "one or more target modules.">;
  def target_modules_lookup_line
      : Option<"line", "l">,
        Group<3>,
        Arg<"LineNum">,
        Desc<"Lookup a line number in a file (must be used in "
             "conjunction with --file).">;
  def target_modules_lookup_no_inlines
      : Option<"no-inlines", "i">,
        GroupRange<3, 5>,
        Desc<
            "Ignore inline entries (must be used in conjunction with --file or "
            "--function).">;
  def target_modules_lookup_function
      : Option<"function", "F">,
        Group<4>,
        Arg<"FunctionName">,
        Required,
        Desc<"Lookup a function by name in the debug"
             " symbols in one or more target modules.">;
  def target_modules_lookup_name : Option<"name", "n">,
                                   Group<5>,
                                   Arg<"FunctionOrSymbol">,
                                   Required,
                                   Desc<"Lookup a function or symbol by "
                                        "name in one or more target modules.">;
  def target_modules_lookup_type
      : Option<"type", "t">,
        Group<6>,
        Arg<"Name">,
        Required,
        Desc<"Lookup a type by name in the debug symbols in one or more "
             "target modules.">;
  def target_modules_lookup_variables_ranges
      : Option<"show-variable-ranges", "\\x01">,
        GroupRange<1, 6>,
        Desc<"Dump valid ranges of variables (must be used in conjunction with "
             "--verbose">;
  def target_modules_lookup_verbose
      : Option<"verbose", "v">,
        Desc<"Enable verbose lookup information.">;
  def target_modules_lookup_all : Option<"all", "A">,
                                  Desc<"Print all matches, not just the best "
                                       "match, if a best match is available.">;
}

let Command = "target stop_hook add" in {
  def target_stop_hook_add_one_liner
      : Option<"one-liner", "o">,
        GroupRange<1, 3>,
        Arg<"OneLiner">,
        Desc<"Add a command for the stop hook.  Can be specified more than "
             "once, and commands will be run in the order they appear.">;
  def target_stop_hook_add_shlib
      : Option<"shlib", "s">,
        Arg<"ShlibName">,
        Completion<"Module">,
        Desc<"Set the module within which the stop-hook is to be run.">;
  def target_stop_hook_add_thread_index
      : Option<"thread-index", "x">,
        Arg<"ThreadIndex">,
        Desc<"The stop hook is run only for the thread whose index matches "
             "this argument.">;
  def target_stop_hook_add_thread_id
      : Option<"thread-id", "t">,
        Arg<"ThreadID">,
        Desc<"The stop hook is run only for the thread whose TID matches this "
             "argument.">;
  def target_stop_hook_add_thread_name
      : Option<"thread-name", "T">,
        Arg<"ThreadName">,
        Desc<"The stop hook is run only for the thread whose thread name "
             "matches this argument.">;
  def target_stop_hook_add_queue_name
      : Option<"queue-name", "q">,
        Arg<"QueueName">,
        Desc<"The stop hook is run only for threads in the ${q}ueue whose name "
             "is given by this argument.">;
  def target_stop_hook_add_file : Option<"file", "f">,
                                  Groups<[1, 4]>,
                                  Arg<"Filename">,
                                  Desc<"Specify the source ${f}ile within "
                                       "which the stop-hook is to be run.">,
                                  Completion<"SourceFile">;
  def target_stop_hook_add_start_line
      : Option<"start-line", "l">,
        Groups<[1, 4]>,
        Arg<"LineNum">,
        Desc<"Set the start of the ${l}ine range for which the "
             "stop-hook is to be run.">;
  def target_stop_hook_add_end_line
      : Option<"end-line", "e">,
        Groups<[1, 4]>,
        Arg<"LineNum">,
        Desc<"Set the ${e}nd of the line range for which the stop-hook is to "
             "be run.">;
  def target_stop_hook_add_classname
      : Option<"classname", "c">,
        Groups<[2, 5]>,
        Arg<"ClassName">,
        Desc<"Specify the ${c}lass within which the stop-hook is to be run.">;
  def target_stop_hook_add_name
      : Option<"name", "n">,
        Groups<[3, 6]>,
        Arg<"FunctionName">,
        Desc<
            "Set the ${f}unction name within which the stop hook will be run.">,
        Completion<"Symbol">;
  def target_stop_hook_add_auto_continue
      : Option<"auto-continue", "G">,
        Arg<"Boolean">,
        Desc<"The stop-hook will auto-continue after running its commands.">;
  def target_stop_hook_add_at_initial_stop
      : Option<"at-initial-stop", "I">,
        Arg<"Boolean">,
        Desc<"Whether the stop-hook will trigger when lldb ${i}nitially gains "
             "control of the process. For a process launch, this initial stop "
             "may happen very early on - before the loader has run. You can "
             "use this option if you do not want some stop-hooks to run then. "
             "Defaults to true.">;
}

let Command = "target stop_hook list" in {
  def target_stop_hook_list_internal
      : Option<"internal", "i">,
        Desc<"Show debugger ${i}nternal stop hooks.">;
}

let Command = "thread backtrace" in {
  def thread_backtrace_count : Option<"count", "c">,
                               Group<1>,
                               Arg<"Count">,
                               Desc<"How many frames to display (0 for all)">;
  def thread_backtrace_start : Option<"start", "s">,
                               Group<1>,
                               Arg<"FrameIndex">,
                               Desc<"Frame in which to ${s}tart the backtrace">;
  def thread_backtrace_extended
      : Option<"extended", "e">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Show the ${e}xtended backtrace, if available">;
  def thread_backtrace_unfiltered : Option<"unfiltered", "u">,
                                    Group<1>,
                                    Desc<"Do not filter out frames according "
                                         "to installed frame recognizers">;
  def thread_backtrace_provider
      : Option<"provider", "p">,
        Group<1>,
        Arg<"FrameProviderIDRange">,
        Desc<"Show backtrace from specific frame provider(s). "
             "Use a single ID (e.g., '2') for one provider, "
             "a range (e.g., '0-2', '0 to 2') for multiple, "
             "or '*'/'all' to show every provider. "
             "ID 0 is the base unwinder, 1+ are synthetic providers.">;
}

let Command = "thread step scope" in {
  def thread_step_scope_step_in_avoids_no_debug
      : Option<"step-in-avoids-no-debug", "a">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"A boolean value that sets whether stepping into functions will "
             "step over functions with no debug information.">;
  def thread_step_scope_step_out_avoids_no_debug
      : Option<"step-out-avoids-no-debug", "A">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"A boolean value, if true stepping out of functions will continue "
             "to step out till it hits a function with debug information.">;
  def thread_step_scope_count
      : Option<"count", "c">,
        Group<1>,
        Arg<"Count">,
        Desc<"How many times to perform the stepping operation - currently "
             "only supported for step-inst and next-inst.">;
  def thread_step_scope_end_linenumber
      : Option<"end-linenumber", "e">,
        Group<1>,
        Arg<"LineNum">,
        Desc<"The line at which to stop stepping - defaults to the next line "
             "and only supported for step-in and step-over. You can also pass "
             "the string 'block' to step to the end of the current block. This "
             "is particularly useful in conjunction with --step-target to step "
             "through a complex calling sequence.">;
  def thread_step_scope_run_mode : Option<"run-mode", "m">,
                                   Group<1>,
                                   EnumArg<"RunMode">,
                                   Desc<"Determine how to run other threads "
                                        "while stepping the current thread.">;
  def thread_step_scope_step_over_regexp
      : Option<"step-over-regexp", "r">,
        Group<1>,
        Arg<"RegularExpression">,
        Desc<"A ${r}egular expression that defines function names to not to "
             "stop at when stepping in.">;
  def thread_step_scope_step_in_target
      : Option<"step-in-target", "t">,
        Group<1>,
        Arg<"FunctionName">,
        Desc<"The name of the directly called function step in should stop at "
             "when stepping into.">;
}

let Command = "thread until" in {
  def thread_until_frame
      : Option<"frame", "f">,
        Group<1>,
        Arg<"FrameIndex">,
        Desc<"Frame index for until operation - defaults to 0">;
  def thread_until_thread
      : Option<"thread", "t">,
        Group<1>,
        Arg<"ThreadIndex">,
        Desc<"Thread index for the thread for until operation">;
  def thread_until_run_mode : Option<"run-mode", "m">,
                              Group<1>,
                              EnumArg<"RunMode">,
                              Desc<"Determine how to run other "
                                   "threads while stepping this one">;
  def thread_until_address
      : Option<"address", "a">,
        Group<1>,
        Arg<"AddressOrExpression">,
        Desc<"Run until we reach the specified address, "
             "or leave the function - can be specified multiple times.">;
}

let Command = "thread info" in {
  def thread_info_json : Option<"json", "j">,
                         Desc<"Display the thread info in"
                              " JSON format.">;
  def thread_info_stop_info : Option<"stop-info", "s">,
                              Desc<"Display the "
                                   "extended stop info in JSON format.">;
  def thread_info_backing_thread : Option<"backing-thread", "b">,
                                   Desc<"If this is an OS plugin thread, query "
                                        "the backing thread instead; has"
                                        " no effect otherwise.">;
}

let Command = "thread return" in {
  def thread_return_from_expression
      : Option<"from-expression", "x">,
        Desc<"Return from the innermost expression evaluation.">;
}

let Command = "thread jump" in {
  def thread_jump_file : Option<"file", "f">,
                         Group<1>,
                         Arg<"Filename">,
                         Completion<"SourceFile">,
                         Desc<"Specifies the source file to jump to.">;
  def thread_jump_line : Option<"line", "l">,
                         Group<1>,
                         Arg<"LineNum">,
                         Required,
                         Desc<"Specifies the line number to jump to.">;
  def thread_jump_by
      : Option<"by", "b">,
        Group<2>,
        Arg<"Offset">,
        Required,
        Desc<"Jumps by a relative line offset from the current line, "
             "can be a positive or negative offset.">;
  def thread_jump_address : Option<"address", "a">,
                            Group<3>,
                            Arg<"AddressOrExpression">,
                            Required,
                            Desc<"Jumps to a specific address.">;
  def thread_jump_force : Option<"force", "r">,
                          Groups<[1, 2, 3]>,
                          Desc<"Allows the PC to leave the current function.">;
}

let Command = "thread plan list" in {
  def thread_plan_list_verbose
      : Option<"verbose", "v">,
        Group<1>,
        Desc<"Display more information about the thread plans">;
  def thread_plan_list_internal
      : Option<"internal", "i">,
        Group<1>,
        Desc<"Display internal as well as user thread plans">;
  def thread_plan_list_thread_id
      : Option<"thread-id", "t">,
        Group<1>,
        Arg<"ThreadID">,
        Desc<"List the thread plans for this TID, can be "
             "specified more than once.">;
  def thread_plan_list_unreported
      : Option<"unreported", "u">,
        Group<1>,
        Desc<"Display thread plans for unreported threads">;
}

let Command = "thread select" in {
  def thread_select_thread_id
      : Option<"thread-id", "t">,
        Group<2>,
        Arg<"ThreadID">,
        Completion<"ThreadID">,
        Desc<"Provide a thread ID instead of a thread index.">;
}

let Command = "thread trace dump function calls" in {
  def thread_trace_dump_function_calls_file
      : Option<"file", "F">,
        Group<1>,
        Arg<"Filename">,
        Desc<"Dump the function calls to a file instead of the standard "
             "output.">;
  def thread_trace_dump_function_calls_json
      : Option<"json", "j">,
        Group<1>,
        Desc<"Dump in simple JSON format.">;
  def thread_trace_dump_function_calls_pretty_json
      : Option<"pretty-json", "J">,
        Group<1>,
        Desc<"Dump in JSON format but pretty printing the output for easier "
             "readability.">;
}

let Command = "thread trace dump instructions" in {
  def thread_trace_dump_instructions_forwards
      : Option<"forwards", "f">,
        Group<1>,
        Desc<"If specified, the trace is traversed forwards chronologically "
             "starting at the oldest instruction. Otherwise, it starts at the "
             "most "
             "recent one and the traversal is backwards.">;
  def thread_trace_dump_instructions_count
      : Option<"count", "c">,
        Group<1>,
        Arg<"Count">,
        Desc<
            "The number of instructions to display starting at the most recent "
            "instruction, or the oldest if --forwards is provided.">;
  def thread_trace_dump_instructions_all
      : Option<"all", "a">,
        Group<1>,
        Desc<"From the starting point of the trace, dump all instructions "
             "available.">;
  def thread_trace_dump_instructions_id
      : Option<"id", "i">,
        Group<1>,
        Arg<"Index">,
        Desc<"Custom starting instruction id from where to start traversing. "
             "This "
             "id can be provided in decimal or hexadecimal representation.">;
  def thread_trace_dump_instructions_skip
      : Option<"skip", "s">,
        Group<1>,
        Arg<"Index">,
        Desc<"How many trace items (instructions, errors and events) to skip "
             "from "
             "the starting position of the trace before starting the "
             "traversal.">;
  def thread_trace_dump_instructions_raw
      : Option<"raw", "r">,
        Group<1>,
        Desc<"Dump only instruction address without disassembly nor symbol "
             "information.">;
  def thread_trace_dump_instructions_file
      : Option<"file", "F">,
        Group<1>,
        Arg<"Filename">,
        Desc<"Dump the instruction to a file instead of the standard output.">;
  def thread_trace_dump_instructions_json : Option<"json", "j">,
                                            Group<1>,
                                            Desc<"Dump in simple JSON format.">;
  def thread_trace_dump_instructions_pretty_print
      : Option<"pretty-json", "J">,
        Group<1>,
        Desc<"Dump in JSON format but pretty printing the output for easier "
             "readability.">;
  def thread_trace_dump_instructions_show_kind
      : Option<"kind", "k">,
        Group<1>,
        Desc<"Show instruction control flow kind. Refer to the enum "
             "`InstructionControlFlowKind` for a list of control flow kind. "
             "As an important note, far jumps, far calls and far returns often "
             "indicate "
             "calls to and from kernel.">;
  def thread_trace_dump_instructions_show_timestamps
      : Option<"time", "t">,
        Group<1>,
        Desc<
            "For each trace item, print the corresponding wall clock timestamp "
            "if available.">;
  def thread_trace_dump_instructions_show_events
      : Option<"events", "e">,
        Group<1>,
        Desc<"Dump the events that happened during the execution of the "
             "target.">;
  def thread_trace_dump_instruction_only_events
      : Option<"only-events", "E">,
        Group<1>,
        Desc<"Dump only the events that happened during the execution of the "
             "target. No instructions are dumped.">;
  def thread_trace_dump_instructions_continue
      : Option<"continue", "C">,
        Group<1>,
        Desc<
            "Continue dumping instructions right where the previous invocation "
            "of "
            "this command was left, or from the beginning if this is the first "
            "invocation. The --skip argument is discarded and the other "
            "arguments are "
            "preserved from the previous invocation when possible.">;
}

let Command = "thread trace dump info" in {
  def thread_trace_dump_info_verbose
      : Option<"verbose", "v">,
        Group<1>,
        Desc<"show verbose thread trace dump info">;
  def thread_trace_dump_info_json : Option<"json", "j">,
                                    Group<1>,
                                    Desc<"Dump in JSON format.">;
}

let Command = "type summary add" in {
  def type_summary_add_category
      : Option<"category", "w">,
        Arg<"Name">,
        Desc<"Add this to the given category instead of the default one.">;
  def type_summary_add_cascade
      : Option<"cascade", "C">,
        Arg<"Boolean">,
        Desc<"If true, cascade through typedef chains.">;
  def type_summary_add_no_value
      : Option<"no-value", "v">,
        Desc<"Don't show the value, just show the summary, for this type.">;
  def type_summary_add_skip_pointers
      : Option<"skip-pointers", "p">,
        Desc<"Don't use this format for pointers-to-type objects.">;
  def type_summary_add_pointer_match_depth
      : Option<"pointer-match-depth", "d">,
        Arg<"UnsignedInteger">,
        Desc<"Specify the maximum pointer depth that this format can be apply "
             "to "
             "(default to 1). It's only effective when --skip-pointers is not "
             "set.">;
  def type_summary_add_skip_references
      : Option<"skip-references", "r">,
        Desc<"Don't use this format for references-to-type objects.">;
  def type_summary_add_regex
      : Option<"regex", "x">,
        Desc<"Type names are actually regular expressions.">;
  def type_summary_add_recognizer_function
      : Option<"recognizer-function", "\\x01">,
        Desc<"The names in the argument list are actually the names of python "
             "functions that decide whether to use this summary for any given "
             "type. "
             "Cannot be specified at the same time as --regex (-x).">;
  def type_summary_add_inline_children
      : Option<"inline-children", "c">,
        Group<1>,
        Required,
        Desc<"If true, inline all child values into summary string.">;
  def type_summary_add_omit_names
      : Option<"omit-names", "O">,
        Group<1>,
        Desc<"If true, omit value names in the summary display.">;
  def type_summary_add_summary_string
      : Option<"summary-string", "s">,
        Group<2>,
        Arg<"SummaryString">,
        Required,
        Desc<"Summary string used to display text and object contents.">;
  def type_summary_add_python_script
      : Option<"python-script", "o">,
        Group<3>,
        Arg<"PythonScript">,
        Desc<"Give a one-liner Python script as part of the command.">;
  def type_summary_add_python_function
      : Option<"python-function", "F">,
        Group<3>,
        Arg<"PythonFunction">,
        Desc<"Give the name of a Python function to use for this type.">;
  def type_summary_add_input_python
      : Option<"input-python", "P">,
        Group<3>,
        Desc<"Input Python code to use for this type manually.">;
  def type_summary_add_expand
      : Option<"expand", "e">,
        Groups<[2, 3]>,
        Desc<"Expand aggregate data types to show children on separate lines.">;
  def type_summary_add_hide_empty
      : Option<"hide-empty", "h">,
        Groups<[2, 3]>,
        Desc<"Do not expand aggregate data types with no children.">;
  def type_summary_add_name : Option<"name", "n">,
                              Groups<[2, 3]>,
                              Arg<"Name">,
                              Desc<"A name for this summary string.">;
}

let Command = "type synth add" in {
  def type_synth_add_cascade : Option<"cascade", "C">,
                               Arg<"Boolean">,
                               Desc<"If true, cascade through typedef chains.">;
  def type_synth_add_wants_deref
      : Option<"requires-dereference", "D">,
        Arg<"Boolean">,
        Desc<"If true, when this synthetic provider matches a pointer or "
             "reference type, it will receive the dereferenced value object "
             "instead of the raw pointer or reference.">;
  def type_synth_add_skip_pointers
      : Option<"skip-pointers", "p">,
        Desc<"Don't use this format for pointers-to-type objects.">;
  def type_synth_add_skip_references
      : Option<"skip-references", "r">,
        Desc<"Don't use this format for references-to-type objects.">;
  def type_synth_add_category
      : Option<"category", "w">,
        Arg<"Name">,
        Desc<"Add this to the given category instead of the default one.">;
  def type_synth_add_python_class
      : Option<"python-class", "l">,
        Group<2>,
        Arg<"PythonClass">,
        Desc<"Use this Python class to produce synthetic children.">;
  def type_synth_add_input_python
      : Option<"input-python", "P">,
        Group<3>,
        Desc<"Type Python code to generate a class that provides synthetic "
             "children.">;
  def type_synth_add_regex
      : Option<"regex", "x">,
        Desc<"Type names are actually regular expressions.">;
  def type_synth_add_recognizer_function
      : Option<"recognizer-function", "\\x01">,
        Desc<"The names in the argument list are actually the names of python "
             "functions that decide whether to use this summary for any given "
             "type. "
             "Cannot be specified at the same time as --regex (-x).">;
}

let Command = "type format add" in {
  def type_format_add_category
      : Option<"category", "w">,
        Arg<"Name">,
        Desc<"Add this to the given category instead of the default one.">;
  def type_format_add_cascade
      : Option<"cascade", "C">,
        Arg<"Boolean">,
        Desc<"If true, cascade through typedef chains.">;
  def type_format_add_skip_pointers
      : Option<"skip-pointers", "p">,
        Desc<"Don't use this format for pointers-to-type objects.">;
  def type_format_add_skip_references
      : Option<"skip-references", "r">,
        Desc<"Don't use this format for references-to-type objects.">;
  def type_format_add_regex
      : Option<"regex", "x">,
        Desc<"Type names are actually regular expressions.">;
  def type_format_add_type
      : Option<"type", "t">,
        Group<2>,
        Arg<"Name">,
        Desc<"Format variables as if they were of this type.">;
}

let Command = "type formatter delete" in {
  def type_formatter_delete_all : Option<"all", "a">,
                                  Group<1>,
                                  Desc<"Delete from every category.">;
  def type_formatter_delete_category : Option<"category", "w">,
                                       Group<2>,
                                       Arg<"Name">,
                                       Desc<"Delete from given category.">;
  def type_formatter_delete_language
      : Option<"language", "l">,
        Group<3>,
        Arg<"Language">,
        Desc<"Delete from given language's category.">;
}

let Command = "type formatter clear" in {
  def type_formatter_clear_all : Option<"all", "a">,
                                 Desc<"Clear every category.">;
}

let Command = "type formatter list" in {
  def type_formatter_list_category_regex
      : Option<"category-regex", "w">,
        Group<1>,
        Arg<"Name">,
        Desc<"Only show categories matching this filter.">;
  def type_formatter_list_language
      : Option<"language", "l">,
        Group<2>,
        Arg<"Language">,
        Desc<"Only show the category for a specific language.">;
}

let Command = "type category define" in {
  def type_category_define_enabled
      : Option<"enabled", "e">,
        Desc<"If specified, this category will be created enabled.">;
  def type_category_define_language
      : Option<"language", "l">,
        Arg<"Language">,
        Desc<"Specify the language that this category is supported for.">;
}

let Command = "type category enable" in {
  def type_category_enable_language
      : Option<"language", "l">,
        Arg<"Language">,
        Desc<"Enable the category for this language.">;
}

let Command = "type category disable" in {
  def type_category_disable_language
      : Option<"language", "l">,
        Arg<"Language">,
        Desc<"Disable the category for this language.">;
}

let Command = "type filter add" in {
  def type_filter_add_cascade
      : Option<"cascade", "C">,
        Arg<"Boolean">,
        Desc<"If true, cascade through typedef chains.">;
  def type_filter_add_skip_pointers
      : Option<"skip-pointers", "p">,
        Desc<"Don't use this format for pointers-to-type objects.">;
  def type_filter_add_skip_references
      : Option<"skip-references", "r">,
        Desc<"Don't use this format for references-to-type objects.">;
  def type_filter_add_category
      : Option<"category", "w">,
        Arg<"Name">,
        Desc<"Add this to the given category instead of the default one.">;
  def type_filter_add_child
      : Option<"child", "c">,
        Arg<"ExpressionPath">,
        Desc<"Include this expression path in the synthetic view.">;
  def type_filter_add_regex
      : Option<"regex", "x">,
        Desc<"Type names are actually regular expressions.">;
}

let Command = "type lookup" in {
  def type_lookup_show_help : Option<"show-help", "h">,
                              Desc<"Display available help for types">;
  def type_lookup_language
      : Option<"language", "l">,
        Arg<"Language">,
        Desc<"Which language's types should the search scope be">;
}

let Command = "watchpoint list" in {
  def watchpoint_list_brief
      : Option<"brief", "b">,
        Group<1>,
        Desc<"Give a "
             "brief description of the watchpoint (no location info).">;
  def watchpoint_list_full
      : Option<"full", "f">,
        Group<2>,
        Desc<"Give a full "
             "description of the watchpoint and its locations.">;
  def watchpoint_list_verbose : Option<"verbose", "v">,
                                Group<3>,
                                Desc<"Explain "
                                     "everything we know about the watchpoint "
                                     "(for debugging debugger bugs).">;
}

let Command = "watchpoint ignore" in {
  def watchpoint_ignore_ignore_count
      : Option<"ignore-count", "i">,
        Arg<"Count">,
        Required,
        Desc<"Set the number of times this watchpoint is"
             " skipped before stopping.">;
}

let Command = "watchpoint modify" in {
  def watchpoint_modify_condition
      : Option<"condition", "c">,
        Arg<"Expression">,
        Desc<"The watchpoint stops only if this condition expression evaluates "
             "to true.">;
}

let Command = "watchpoint command add" in {
  def watchpoint_command_add_one_liner
      : Option<"one-liner", "o">,
        Group<1>,
        Arg<"OneLiner">,
        Desc<"Specify a one-line watchpoint command inline. Be "
             "sure to surround it with quotes.">;
  def watchpoint_command_add_stop_on_error
      : Option<"stop-on-error", "e">,
        Arg<"Boolean">,
        Desc<"Specify whether watchpoint command execution should "
             "terminate on error.">;
  def watchpoint_command_add_script_type
      : Option<"script-type", "s">,
        EnumArg<"ScriptLang">,
        Desc<"Specify the language for the"
             " commands - if none is specified, the lldb command interpreter "
             "will be "
             "used.">;
  def watchpoint_command_add_python_function
      : Option<"python-function", "F">,
        Group<2>,
        Arg<"PythonFunction">,
        Desc<"Give the name of a Python function "
             "to run as command for this watchpoint. Be sure to give a module "
             "name if "
             "appropriate.">;
}

let Command = "watchpoint delete" in {
  def watchpoint_delete_force
      : Option<"force", "f">,
        Group<1>,
        Desc<"Delete all watchpoints without querying for confirmation.">;
}

let Command = "trace load" in {
  def trace_load_verbose
      : Option<"verbose", "v">,
        Group<1>,
        Desc<"Show verbose trace load logging for debugging the plug-in "
             "implementation.">;
}

let Command = "trace save" in {
  def trace_save_compact
      : Option<"compact", "c">,
        Group<1>,
        Desc<"Try not to save to disk information irrelevant to the traced "
             "processes. Each trace plug-in implements this in a different "
             "fashion.">;
}

let Command = "trace dump" in {
  def trace_dump_verbose : Option<"verbose", "v">,
                           Group<1>,
                           Desc<"Show verbose trace information.">;
}

let Command = "trace schema" in {
  def trace_schema_verbose
      : Option<"verbose", "v">,
        Group<1>,
        Desc<"Show verbose trace schema logging for debugging the plug-in.">;
}

let Command = "statistics dump" in {
  def statistics_dump_all : Option<"all-targets", "a">,
                            Group<1>,
                            Desc<"Include statistics for all targets.">;
  def statistics_dump_summary
      : Option<"summary", "s">,
        Group<1>,
        Desc<"Dump only high-level summary statistics. Exclude targets, "
             "modules, breakpoints etc... details.">;
  def statistics_dump_force
      : Option<"load-all-debug-info", "f">,
        Group<1>,
        Desc<"Dump the total possible debug info statistics. Force loading all "
             "the debug information if not yet loaded, and collect statistics "
             "with those.">;
  def statistics_dump_targets
      : Option<"targets", "r">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Dump statistics for the targets, including breakpoints, "
             "expression evaluations, frame variables, etc. Defaults to true "
             "in both default mode and summary mode. In default mode, if both "
             "'--targets' and '--modules' are 'true', a list of module "
             "identifiers will be added to the 'targets' section.">;
  def statistics_dump_modules
      : Option<"modules", "m">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Dump statistics for the modules, including time and size of "
             "various aspects of the module and debug information, type "
             "system, path, etc. Defaults to true, unless the '--summary' mode "
             "is enabled, in which case this is turned off unless specified. "
             "In default mode, if both '--targets' and '--modules' are 'true', "
             "a list of module identifiers will be added to the 'targets' "
             "section.">;
  def statistics_dump_transcript
      : Option<"transcript", "t">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"If the setting interpreter.save-transcript is enabled and this "
             "option is 'true', include a JSON array with all commands the "
             "user and/or scripts executed during a debug session. Defaults to "
             "false. ">;
  def statistics_dump_plugins
      : Option<"plugins", "p">,
        Group<1>,
        Arg<"Boolean">,
        Desc<"Dump statistics for known plugins including name, order, and "
             "enabled state. Defaults to true for both summary and default "
             "mode.">;
}

let Command = "version" in {
  def version_verbose : Option<"verbose", "v">,
                        Desc<"Include build configuration in version output.">;
}