lldb/source/Commands/Options.td

   1 include "OptionsBase.td"
   2
   3 let Command = "target modules dump symtab" in {
   4   def tm_sort : Option<"sort", "s">, Group<1>,
   5     Desc<"Supply a sort order when dumping the symbol table.">,
   6     EnumArg<"SortOrder">;
   7   def tm_smn : Option<"show-mangled-names", "m">, Group<1>,
   8     Desc<"Do not demangle symbol names before showing them.">;
   9 }
  10
  11 let Command = "target modules dump separate debug info" in {
  12   def tm_json : Option<"json", "j">, Group<1>,
  13     Desc<"Output the details in JSON format.">;
  14   def tm_errors_only : Option<"errors-only", "e">, Group<1>,
  15     Desc<"Filter to show only debug info files with errors.">;
  16 }
  17
  18 let Command = "help" in {
  19   def help_hide_aliases : Option<"hide-aliases", "a">,
  20     Desc<"Hide aliases in the command list.">;
  21   def help_hide_user : Option<"hide-user-commands", "u">,
  22     Desc<"Hide user-defined commands from the list.">;
  23   def help_show_hidden : Option<"show-hidden-commands", "h">,
  24     Desc<"Include commands prefixed with an underscore.">;
  25 }
  26
  27 let Command = "settings set" in {
  28   def setset_global : Option<"global", "g">,
  29     Desc<"Apply the new value to the global default value.">;
  30   def setset_force : Option<"force", "f">,
  31     Desc<"Force an empty value to be accepted as the default.">;
  32   def setset_exists : Option<"exists", "e">,
  33     Desc<"Set the setting if it exists, but do not cause the command to raise "
  34     "an error if it does not exist.">;
  35 }
  36
  37 let Command = "settings write" in {
  38   def setwrite_file : Option<"file", "f">, Required, Arg<"Filename">,
  39     Completion<"DiskFile">,
  40     Desc<"The file into which to write the settings.">;
  41   def setwrite_append : Option<"append", "a">,
  42     Desc<"Append to saved settings file if it exists.">;
  43 }
  44
  45 let Command = "settings read" in {
  46   def setread_file : Option<"file", "f">, Required, Arg<"Filename">,
  47     Completion<"DiskFile">,
  48     Desc<"The file from which to read the settings.">;
  49 }
  50
  51 let Command = "settings clear" in {
  52   def setclear_all : Option<"all", "a">,
  53     Desc<"Clear all settings.">;
  54 }
  55
  56 let Command = "breakpoint list" in {
  57   // FIXME: We need to add an "internal" command, and then add this sort of
  58   // thing to it. But I need to see it for now, and don't want to wait.
  59   def blist_internal : Option<"internal", "i">,
  60     Desc<"Show debugger internal breakpoints">;
  61   def blist_brief : Option<"brief", "b">, Group<1>,
  62     Desc<"Give a brief description of the breakpoint (no location info).">;
  63   def blist_full : Option<"full", "f">, Group<2>,
  64     Desc<"Give a full description of the breakpoint and its locations.">;
  65   def blist_verbose : Option<"verbose", "v">, Group<3>,
  66     Desc<"Explain everything we know about the breakpoint (for debugging "
  67     "debugger bugs).">;
  68   def blist_dummy_bp : Option<"dummy-breakpoints", "D">,
  69     Desc<"List Dummy breakpoints - i.e. breakpoints set before a file is "
  70     "provided, which prime new targets.">;
  71 }
  72
  73 let Command = "breakpoint modify" in {
  74   def breakpoint_modify_ignore_count : Option<"ignore-count", "i">, Group<1>,
  75     Arg<"Count">,
  76     Desc<"Set the number of times this breakpoint is skipped before stopping.">;
  77   def breakpoint_modify_one_shot : Option<"one-shot", "o">, Group<1>,
  78     Arg<"Boolean">,
  79     Desc<"The breakpoint is deleted the first time it stop causes a stop.">;
  80   def breakpoint_modify_thread_index : Option<"thread-index", "x">, Group<1>,
  81     Arg<"ThreadIndex">, Desc<"The breakpoint stops only for the thread whose "
  82     "index matches this argument.">;
  83   def breakpoint_modify_thread_id : Option<"thread-id", "t">, Group<1>,
  84     Arg<"ThreadID">, Desc<"The breakpoint stops only for the thread whose TID "
  85     "matches this argument.  The token 'current' resolves to the current thread's ID.">;
  86   def breakpoint_modify_thread_name : Option<"thread-name", "T">, Group<1>,
  87     Arg<"ThreadName">, Desc<"The breakpoint stops only for the thread whose "
  88     "thread name matches this argument.">;
  89   def breakpoint_modify_queue_name : Option<"queue-name", "q">, Group<1>,
  90     Arg<"QueueName">, Desc<"The breakpoint stops only for threads in the queue "
  91     "whose name is given by this argument.">;
  92   def breakpoint_modify_condition : Option<"condition", "c">, Group<1>,
  93     Arg<"Expression">, Desc<"The breakpoint stops only if this condition "
  94     "expression evaluates to true.">;
  95   def breakpoint_modify_auto_continue : Option<"auto-continue", "G">, Group<1>,
  96     Arg<"Boolean">,
  97     Desc<"The breakpoint will auto-continue after running its commands.">;
  98   def breakpoint_modify_enable : Option<"enable", "e">, Group<2>,
  99     Desc<"Enable the breakpoint.">;
 100   def breakpoint_modify_disable : Option<"disable", "d">, Group<3>,
 101     Desc<"Disable the breakpoint.">;
 102   def breakpoint_modify_command : Option<"command", "C">, Group<4>,
 103     Arg<"Command">,
 104     Desc<"A command to run when the breakpoint is hit, can be provided more "
 105     "than once, the commands will be run in left-to-right order.">;
 106 }
 107
 108 let Command = "breakpoint dummy" in {
 109   def breakpoint_dummy_options_dummy_breakpoints :
 110     Option<"dummy-breakpoints", "D">, Group<1>,
 111     Desc<"Act on Dummy breakpoints - i.e. breakpoints set before a file is "
 112     "provided, which prime new targets.">;
 113 }
 114
 115 let Command = "breakpoint set" in {
 116   def breakpoint_set_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
 117     Completion<"Module">, Groups<[1,2,3,4,5,6,7,8,9,11,12]>, // *not* in group 10
 118     Desc<"Set the breakpoint only in this shared library.  Can repeat this "
 119     "option multiple times to specify multiple shared libraries.">;
 120   def breakpoint_set_hardware : Option<"hardware", "H">,
 121     Desc<"Require the breakpoint to use hardware breakpoints.">;
 122   def breakpoint_set_file : Option<"file", "f">, Arg<"Filename">,
 123     Completion<"SourceFile">, Groups<[1,3,4,5,6,7,8,9,11]>,
 124     Desc<"Specifies the source file in which to set this breakpoint.  Note, by "
 125     "default lldb only looks for files that are #included if they use the "
 126     "standard include file extensions.  To set breakpoints on .c/.cpp/.m/.mm "
 127     "files that are #included, set target.inline-breakpoint-strategy to "
 128     "\"always\".">;
 129   def breakpoint_set_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
 130     Required,
 131     Desc<"Specifies the line number on which to set this breakpoint.">;
 132   def breakpoint_set_column : Option<"column", "u">, Group<1>, Arg<"ColumnNum">,
 133     Desc<"Specifies the column number on which to set this breakpoint.">;
 134   def breakpoint_set_address : Option<"address", "a">, Group<2>,
 135     Arg<"AddressOrExpression">, Required,
 136     Desc<"Set the breakpoint at the specified address.  If the address maps "
 137     "uniquely to a particular binary, then the address will be converted to "
 138     "a \"file\"address, so that the breakpoint will track that binary+offset "
 139     "no matter where the binary eventually loads.  Alternately, if you also "
 140     "specify the module - with the -s option - then the address will be "
 141     "treated as a file address in that module, and resolved accordingly.  "
 142     "Again, this will allow lldb to track that offset on subsequent reloads.  "
 143     "The module need not have been loaded at the time you specify this "
 144     "breakpoint, and will get resolved when the module is loaded.">;
 145   def breakpoint_set_name : Option<"name", "n">, Group<3>, Arg<"FunctionName">,
 146     Completion<"Symbol">, Required,
 147     Desc<"Set the breakpoint by function name.  Can be repeated multiple times "
 148     "to make one breakpoint for multiple names.">;
 149   def breakpoint_set_source_regexp_function :
 150     Option<"source-regexp-function", "X">, Group<9>, Arg<"FunctionName">,
 151     Completion<"Symbol">,
 152     Desc<"When used with '-p' limits the source regex to source contained in "
 153     "the named functions.  Can be repeated multiple times.">;
 154   def breakpoint_set_fullname : Option<"fullname", "F">, Group<4>,
 155     Arg<"FullName">, Required, Completion<"Symbol">,
 156     Desc<"Set the breakpoint by fully qualified function names. For C++ this "
 157     "means namespaces and all arguments, and for Objective-C this means a full "
 158     "function prototype with class and selector.  Can be repeated multiple times"
 159     " to make one breakpoint for multiple names.">;
 160   def breakpoint_set_selector : Option<"selector", "S">, Group<5>,
 161     Arg<"Selector">, Required,
 162     Desc<"Set the breakpoint by Objective-C selector name.  Can be repeated "
 163     "multiple times to make one breakpoint for multiple Selectors.">;
 164   def breakpoint_set_method : Option<"method", "M">, Group<6>, Arg<"Method">,
 165     Required, Desc<"Set the breakpoint by C++ method names.  Can be repeated "
 166     "multiple times to make one breakpoint for multiple methods.">;
 167   def breakpoint_set_func_regex : Option<"func-regex", "r">, Group<7>,
 168     Arg<"RegularExpression">, Required, Desc<"Set the breakpoint by function "
 169     "name, evaluating a regular-expression to find the function name(s).">;
 170   def breakpoint_set_basename : Option<"basename", "b">, Group<8>,
 171     Arg<"FunctionName">, Required, Completion<"Symbol">,
 172     Desc<"Set the breakpoint by function basename (C++ namespaces and arguments"
 173     " will be ignored).  Can be repeated multiple times to make one breakpoint "
 174     "for multiple symbols.">;
 175   def breakpoint_set_source_pattern_regexp :
 176     Option<"source-pattern-regexp", "p">, Group<9>, Arg<"RegularExpression">,
 177     Required, Desc<"Set the breakpoint by specifying a regular expression which"
 178     " is matched against the source text in a source file or files specified "
 179     "with the -f can be specified more than once.  If no source files "
 180     "are specified, uses the current \"default source file\".  If you want to "
 181     "match against all source files, pass the \"--all-files\" option.">;
 182   def breakpoint_set_all_files : Option<"all-files", "A">, Group<9>,
 183     Desc<"All files are searched for source pattern matches.">;
 184   def breakpoint_set_language_exception : Option<"language-exception", "E">,
 185     Group<10>, Arg<"Language">, Required,
 186     Desc<"Set the breakpoint on exceptions thrown by the specified language "
 187     "(without options, on throw but not catch.)">;
 188   def breakpoint_set_on_throw : Option<"on-throw", "w">, Group<10>,
 189     Arg<"Boolean">, Desc<"Set the breakpoint on exception throW.">;
 190   def breakpoint_set_on_catch : Option<"on-catch", "h">, Group<10>,
 191     Arg<"Boolean">, Desc<"Set the breakpoint on exception catcH.">;
 192   def breakpoint_set_language : Option<"language", "L">, GroupRange<3, 8>,
 193     Arg<"Language">,
 194     Desc<"Specifies the Language to use when interpreting the breakpoint's "
 195     "expression (note: currently only implemented for setting breakpoints on "
 196     "identifiers). If not set the target.language setting is used.">;
 197   def breakpoint_set_skip_prologue : Option<"skip-prologue", "K">,
 198     Arg<"Boolean">, Groups<[1,3,4,5,6,7,8,12]>,
 199     Desc<"sKip the prologue if the breakpoint is at the beginning of a "
 200     "function. If not set the target.skip-prologue setting is used.">;
 201   def breakpoint_set_breakpoint_name : Option<"breakpoint-name", "N">,
 202     Arg<"BreakpointName">,
 203     Desc<"Adds this to the list of names for this breakpoint.">;
 204   def breakpoint_set_address_slide : Option<"address-slide", "R">,
 205     Arg<"Address">, Groups<[1,3,4,5,6,7,8,12]>,
 206     Desc<"Add the specified offset to whatever address(es) the breakpoint "
 207     "resolves to. At present this applies the offset directly as given, and "
 208     "doesn't try to align it to instruction boundaries.">;
 209   def breakpoint_set_move_to_nearest_code : Option<"move-to-nearest-code", "m">,
 210     Groups<[1,9,12]>, Arg<"Boolean">,
 211     Desc<"Move breakpoints to nearest code. If not set the "
 212     "target.move-to-nearest-code setting is used.">;
 213   def breakpoint_set_file_colon_line : Option<"joint-specifier", "y">, Group<12>, Arg<"FileLineColumn">,
 214     Required, Completion<"SourceFile">,
 215     Desc<"A specifier in the form filename:line[:column] for setting file & line breakpoints.">;
 216   /* Don't add this option till it actually does something useful...
 217   def breakpoint_set_exception_typename : Option<"exception-typename", "O">,
 218     Arg<"TypeName">, Desc<"The breakpoint will only stop if an "
 219     "exception Object of this type is thrown.  Can be repeated multiple times "
 220     "to stop for multiple object types">;
 221    */
 222 }
 223
 224 let Command = "breakpoint clear" in {
 225   def breakpoint_clear_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
 226     Completion<"SourceFile">,
 227     Desc<"Specify the breakpoint by source location in this particular file.">;
 228   def breakpoint_clear_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
 229     Required,
 230     Desc<"Specify the breakpoint by source location at this particular line.">;
 231 }
 232
 233 let Command = "breakpoint delete" in {
 234   def breakpoint_delete_force : Option<"force", "f">, Group<1>,
 235     Desc<"Delete all breakpoints without querying for confirmation.">;
 236   def breakpoint_delete_dummy_breakpoints : Option<"dummy-breakpoints", "D">,
 237     Group<1>, Desc<"Delete Dummy breakpoints - i.e. breakpoints set before a "
 238     "file is provided, which prime new targets.">;
 239   def breakpoint_delete_disabled : Option<"disabled", "d">, Group<1>,
 240     Desc<"Delete all breakpoints which are currently disabled.  When using the disabled option "
 241     "any breakpoints listed on the command line are EXCLUDED from deletion.">;
 242 }
 243
 244 let Command = "breakpoint name" in {
 245   def breakpoint_name_name : Option<"name", "N">, Group<1>,
 246     Arg<"BreakpointName">, Desc<"Specifies a breakpoint name to use.">;
 247   def breakpoint_name_breakpoint_id : Option<"breakpoint-id", "B">, Group<2>,
 248     Arg<"BreakpointID">, Desc<"Specify a breakpoint ID to use.">;
 249   def breakpoint_name_dummy_breakpoints : Option<"dummy-breakpoints", "D">,
 250     Group<3>, Desc<"Operate on Dummy breakpoints - i.e. breakpoints set before "
 251     "a file is provided, which prime new targets.">;
 252   def breakpoint_name_help_string : Option<"help-string", "H">, Group<4>,
 253     Arg<"None">, Desc<"A help string describing the purpose of this name.">;
 254 }
 255
 256 let Command = "breakpoint access" in {
 257   def breakpoint_access_allow_list : Option<"allow-list", "L">, Group<1>,
 258     Arg<"Boolean">, Desc<"Determines whether the breakpoint will show up in "
 259     "break list if not referred to explicitly.">;
 260   def breakpoint_access_allow_disable : Option<"allow-disable", "A">, Group<2>,
 261     Arg<"Boolean">, Desc<"Determines whether the breakpoint can be disabled by "
 262     "name or when all breakpoints are disabled.">;
 263   def breakpoint_access_allow_delete : Option<"allow-delete", "D">, Group<3>,
 264     Arg<"Boolean">, Desc<"Determines whether the breakpoint can be deleted by "
 265     "name or when all breakpoints are deleted.">;
 266 }
 267
 268 let Command = "breakpoint read" in {
 269   def breakpoint_read_file : Option<"file", "f">, Arg<"Filename">, Required,
 270     Completion<"DiskFile">,
 271     Desc<"The file from which to read the breakpoints.">;
 272   def breakpoint_read_breakpoint_name : Option<"breakpoint-name", "N">,
 273     Arg<"BreakpointName">, Desc<"Only read in breakpoints with this name.">;
 274 }
 275
 276 let Command = "breakpoint write" in {
 277   def breakpoint_write_file : Option<"file", "f">, Arg<"Filename">, Required,
 278     Completion<"DiskFile">,
 279     Desc<"The file into which to write the breakpoints.">;
 280   def breakpoint_write_append : Option<"append", "a">,
 281     Desc<"Append to saved breakpoints file if it exists.">;
 282 }
 283
 284 let Command = "breakpoint command add" in {
 285   def breakpoint_add_one_liner : Option<"one-liner", "o">, Group<1>,
 286     Arg<"OneLiner">, Desc<"Specify a one-line breakpoint command inline. Be "
 287     "sure to surround it with quotes.">;
 288   def breakpoint_add_stop_on_error : Option<"stop-on-error", "e">,
 289     Arg<"Boolean">, Desc<"Specify whether breakpoint command execution should "
 290     "terminate on error.">;
 291   def breakpoint_add_script_type : Option<"script-type", "s">,
 292     EnumArg<"ScriptLang">,
 293     Desc<"Specify the language for the commands - if none is specified, the "
 294     "lldb command interpreter will be used.">;
 295   def breakpoint_add_dummy_breakpoints : Option<"dummy-breakpoints", "D">,
 296     Desc<"Sets Dummy breakpoints - i.e. breakpoints set before a file is "
 297     "provided, which prime new targets.">;
 298 }
 299
 300 let Command = "breakpoint command delete" in {
 301   def breakpoint_command_delete_dummy_breakpoints :
 302     Option<"dummy-breakpoints", "D">, Group<1>,
 303     Desc<"Delete commands from Dummy breakpoints - i.e. breakpoints set before "
 304     "a file is provided, which prime new targets.">;
 305 }
 306
 307 let Command = "disassemble" in {
 308   def disassemble_options_bytes : Option<"bytes", "b">,
 309     Desc<"Show opcode bytes when disassembling.">;
 310   def disassemble_options_kind : Option<"kind", "k">,
 311     Desc<"Show instruction control flow kind. Refer to the enum "
 312     "`InstructionControlFlowKind` for a list of control flow kind. "
 313     "As an important note, far jumps, far calls and far returns often indicate "
 314     "calls to and from kernel.">;
 315   def disassemble_options_context : Option<"context", "C">, Arg<"NumLines">,
 316     Desc<"Number of context lines of source to show.">;
 317   def disassemble_options_mixed : Option<"mixed", "m">,
 318     Desc<"Enable mixed source and assembly display.">;
 319   def disassemble_options_raw : Option<"raw", "r">,
 320     Desc<"Print raw disassembly with no symbol information.">;
 321   def disassemble_options_plugin : Option<"plugin", "P">, Arg<"Plugin">,
 322     Desc<"Name of the disassembler plugin you want to use.">;
 323   def disassemble_options_flavor : Option<"flavor", "F">,
 324     Arg<"DisassemblyFlavor">, Desc<"Name of the disassembly flavor you want to "
 325     "use. Currently the only valid options are default, and for Intel "
 326     "architectures, att and intel.">;
 327   def disassemble_options_cpu : Option<"cpu", "X">, Arg<"CPUName">,
 328     Desc<"Override the CPU for disassembling.">;
 329   def disassemble_options_features : Option<"features", "Y">, Arg<"CPUFeatures">,
 330     Desc<"Specify additional CPU features for disassembling.">;
 331   def disassemble_options_arch : Option<"arch", "A">, Arg<"Architecture">,
 332     Desc<"Specify the architecture to use from cross disassembly.">;
 333   def disassemble_options_start_address : Option<"start-address", "s">,
 334     Groups<[1,2]>, Arg<"AddressOrExpression">, Required,
 335     Desc<"Address at which to start disassembling.">;
 336   def disassemble_options_end_address : Option<"end-address", "e">, Group<1>,
 337     Arg<"AddressOrExpression">, Desc<"Address at which to end disassembling.">;
 338   def disassemble_options_count : Option<"count", "c">, Groups<[2,3,4,5,7]>,
 339     Arg<"NumLines">, Desc<"Number of instructions to display.">;
 340   def disassemble_options_name : Option<"name", "n">, Group<3>,
 341     Arg<"FunctionName">, Completion<"Symbol">,
 342     Desc<"Disassemble entire contents of the given function name.">;
 343   def disassemble_options_frame : Option<"frame", "f">, Group<4>,
 344     Desc<"Disassemble from the start of the current frame's function.">;
 345   def disassemble_options_pc : Option<"pc", "p">, Group<5>,
 346     Desc<"Disassemble around the current pc.">;
 347   def disassemble_options_line : Option<"line", "l">, Group<6>,
 348     Desc<"Disassemble the current frame's current source line instructions if "
 349     "there is debug line table information, else disassemble around the pc.">;
 350   def disassemble_options_address : Option<"address", "a">, Group<7>,
 351     Arg<"AddressOrExpression">,
 352     Desc<"Disassemble function containing this address.">;
 353   def disassemble_options_force : Option<"force", "\\x01">, Groups<[2,3,4,5,7]>,
 354     Desc<"Force disassembly of large functions.">;
 355 }
 356
 357 let Command = "diagnostics dump" in {
 358   def diagnostics_dump_directory : Option<"directory", "d">, Group<1>,
 359     Arg<"Path">, Desc<"Dump the diagnostics to the given directory.">;
 360 }
 361
 362 let Command = "expression" in {
 363   def expression_options_all_threads : Option<"all-threads", "a">,
 364     Groups<[1,2]>, Arg<"Boolean">, Desc<"Should we run all threads if the "
 365     "execution doesn't complete on one thread.">;
 366   def expression_options_ignore_breakpoints : Option<"ignore-breakpoints", "i">,
 367     Groups<[1,2]>, Arg<"Boolean">,
 368     Desc<"Ignore breakpoint hits while running expressions">;
 369   def expression_options_timeout : Option<"timeout", "t">, Groups<[1,2]>,
 370     Arg<"UnsignedInteger">,
 371     Desc<"Timeout value (in microseconds) for running the expression.">;
 372   def expression_options_unwind_on_error : Option<"unwind-on-error", "u">,
 373     Groups<[1,2]>, Arg<"Boolean">,
 374     Desc<"Clean up program state if the expression causes a crash, or raises a "
 375     "signal. Note, unlike gdb hitting a breakpoint is controlled by another "
 376     "option (-i).">;
 377   def expression_options_debug : Option<"debug", "g">, Groups<[1,2]>,
 378     Desc<"When specified, debug the JIT code by setting a breakpoint on the "
 379     "first instruction and forcing breakpoints to not be ignored (-i0) and no "
 380     "unwinding to happen on error (-u0).">;
 381   def expression_options_language : Option<"language", "l">, Groups<[1,2,3]>,
 382     Arg<"Language">, Desc<"Specifies the Language to use when parsing the "
 383     "expression.  If not set the target.language setting is used.">;
 384   def expression_options_apply_fixits : Option<"apply-fixits", "X">,
 385     Groups<[1,2]>, Arg<"Boolean">, Desc<"If true, simple fix-it hints will be "
 386     "automatically applied to the expression.">;
 387   def expression_options_description_verbosity :
 388     Option<"description-verbosity", "v">, Group<1>,
 389     OptionalEnumArg<"DescriptionVerbosity">,
 390     Desc<"How verbose should the output of this expression be, if the object "
 391     "description is asked for.">;
 392   def expression_options_top_level : Option<"top-level", "p">, Groups<[1,2]>,
 393     Desc<"Interpret the expression as a complete translation unit, without "
 394     "injecting it into the local context.  Allows declaration of persistent, "
 395     "top-level entities without a $ prefix.">;
 396   def expression_options_allow_jit : Option<"allow-jit", "j">, Groups<[1,2]>,
 397     Arg<"Boolean">,
 398     Desc<"Controls whether the expression can fall back to being JITted if it's "
 399     "not supported by the interpreter (defaults to true).">;
 400   def persistent_result : Option<"persistent-result", "\\x01">, Groups<[1,2]>,
 401     Arg<"Boolean">,
 402     Desc<"Persist expression result in a variable for subsequent use. "
 403     "Expression results will be labeled with $-prefixed variables, e.g. $0, "
 404     "$1, etc.">;
 405 }
 406
 407 let Command = "frame diag" in {
 408   def frame_diag_register : Option<"register", "r">, Group<1>,
 409     Arg<"RegisterName">, Desc<"A register to diagnose.">;
 410   def frame_diag_address : Option<"address", "a">, Group<1>, Arg<"Address">,
 411     Desc<"An address to diagnose.">;
 412   def frame_diag_offset : Option<"offset", "o">, Group<1>, Arg<"Offset">,
 413     Desc<"An optional offset.  Requires --register.">;
 414 }
 415
 416 let Command = "frame select" in {
 417   def frame_select_relative : Option<"relative", "r">, Group<1>, Arg<"Offset">,
 418     Desc<"A relative frame index offset from the current frame index.">;
 419 }
 420
 421 let Command = "frame recognizer add" in {
 422   def frame_recognizer_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
 423     Completion<"Module">,
 424     Desc<"Name of the module or shared library that this recognizer applies "
 425     "to.">;
 426   def frame_recognizer_function : Option<"function", "n">, Arg<"Name">,
 427     Completion<"Symbol">,
 428     Desc<"Name of the function that this recognizer applies to. "
 429          "Can be specified more than once except if -x|--regex is provided.">;
 430   def frame_recognizer_python_class : Option<"python-class", "l">, Group<2>,
 431     Arg<"PythonClass">,
 432     Desc<"Give the name of a Python class to use for this frame recognizer.">;
 433   def frame_recognizer_regex : Option<"regex", "x">,
 434     Desc<"Function name and module name are actually regular expressions.">;
 435   def frame_recognizer_first_instruction_only : Option<"first-instruction-only", "f">, Arg<"Boolean">,
 436     Desc<"If true, only apply this recognizer to frames whose PC currently points to the "
 437     "first instruction of the specified function. If false, the recognizer "
 438     "will always be applied, regardless of the current position within the specified function. The "
 439     "implementer should keep in mind that some features, e.g. accessing function argument "
 440     "values via $arg<N>, are not guaranteed to work reliably in this case, so extra care must "
 441     "be taken to make the recognizer operate correctly. Defaults to true.">;
 442 }
 443
 444 let Command = "history" in {
 445   def history_count : Option<"count", "c">, Group<1>, Arg<"UnsignedInteger">,
 446     Desc<"How many history commands to print.">;
 447   def history_start_index : Option<"start-index", "s">, Group<1>,
 448     Arg<"UnsignedInteger">, Desc<"Index at which to start printing history "
 449     "commands (or end to mean tail mode).">;
 450   def history_end_index : Option<"end-index", "e">, Group<1>,
 451     Arg<"UnsignedInteger">,
 452     Desc<"Index at which to stop printing history commands.">;
 453   def history_clear : Option<"clear", "C">, Group<2>,
 454     Desc<"Clears the current command history.">;
 455 }
 456
 457 let Command = "log enable" in {
 458   def log_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
 459     Desc<"Set the destination file to log to.">;
 460   def log_handler : Option<"log-handler", "h">, Group<1>,
 461     EnumArg<"LogHandler">, Desc<"Specify a log handler which determines where log messages are written.">;
 462   def log_buffer_size : Option<"buffer", "b">, Group<1>, Arg<"UnsignedInteger">,
 463     Desc<"Set the log to be buffered, using the specified buffer size, if supported by the log handler.">;
 464   def log_verbose : Option<"verbose", "v">, Group<1>,
 465     Desc<"Enable verbose logging.">;
 466   def log_sequence : Option<"sequence", "s">, Group<1>,
 467     Desc<"Prepend all log lines with an increasing integer sequence id.">;
 468   def log_timestamp : Option<"timestamp", "T">, Group<1>,
 469     Desc<"Prepend all log lines with a timestamp.">;
 470   def log_pid_tid : Option<"pid-tid", "p">, Group<1>,
 471     Desc<"Prepend all log lines with the process and thread ID that generates "
 472     "the log line.">;
 473   def log_thread_name : Option<"thread-name", "n">, Group<1>,
 474     Desc<"Prepend all log lines with the thread name for the thread that "
 475     "generates the log line.">;
 476
 477   def log_stack : Option<"stack", "S">, Group<1>,
 478     Desc<"Append a stack backtrace to each log line.">;
 479   def log_append : Option<"append", "a">, Group<1>,
 480     Desc<"Append to the log file instead of overwriting.">;
 481   def log_file_function : Option<"file-function", "F">, Group<1>,
 482     Desc<"Prepend the names of files and function that generate the logs.">;
 483 }
 484
 485 let Command = "log dump" in {
 486   def log_dump_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
 487     Desc<"Set the destination file to dump to.">;
 488 }
 489
 490 let Command = "memory read" in {
 491   def memory_read_num_per_line : Option<"num-per-line", "l">, Group<1>,
 492     Arg<"NumberPerLine">, Desc<"The number of items per line to display.">;
 493   def memory_read_binary : Option<"binary", "b">, Group<2>,
 494     Desc<"If true, memory will be saved as binary. If false, the memory is "
 495     "saved save as an ASCII dump that uses the format, size, count and number "
 496     "per line settings.">;
 497   def memory_read_type : Option<"type", "t">, Groups<[3,4]>, Arg<"Name">,
 498     Required, Desc<"The name of a type to view memory as.">;
 499   def memory_read_language : Option<"language", "x">, Group<4>, Arg<"Language">,
 500     Desc<"The language of the type to view memory as.">;
 501   def memory_read_offset : Option<"offset", "E">, Group<3>, Arg<"Count">,
 502     Desc<"How many elements of the specified type to skip before starting to "
 503     "display data.">;
 504   def memory_read_force : Option<"force", "r">, Groups<[1,2,3]>,
 505     Desc<"Necessary if reading over target.max-memory-read-size bytes.">;
 506 }
 507
 508 let Command = "memory find" in {
 509   def memory_find_expression : Option<"expression", "e">, Group<1>,
 510     Arg<"Expression">, Required,
 511     Desc<"Evaluate an expression to obtain a byte pattern.">;
 512   def memory_find_string : Option<"string", "s">, Group<2>, Arg<"Name">,
 513     Required, Desc<"Use text to find a byte pattern.">;
 514   def memory_find_count : Option<"count", "c">, Arg<"Count">,
 515     Desc<"How many times to perform the search.">;
 516   def memory_find_dump_offset : Option<"dump-offset", "o">, Arg<"Offset">,
 517     Desc<"When dumping memory for a match, an offset from the match location to"
 518     " start dumping from.">;
 519 }
 520
 521 let Command = "memory write" in {
 522   def memory_write_infile : Option<"infile", "i">, Group<1>, Arg<"Filename">,
 523     Required, Desc<"Write memory using the contents of a file.">;
 524   def memory_write_offset : Option<"offset", "o">, Group<1>, Arg<"Offset">,
 525     Desc<"Start writing bytes from an offset within the input file.">;
 526 }
 527
 528 let Command = "memory region" in {
 529   def memory_region_all : Option<"all", "a">, Group<2>, Required,
 530     Desc<"Show all memory regions. This is equivalent to starting from address "
 531          "0 and repeating the command. Unmapped areas are included.">;
 532 }
 533
 534 let Command = "memory tag write" in {
 535   def memory_write_end_addr : Option<"end-addr", "e">, Group<1>,
 536   Arg<"AddressOrExpression">, Desc<
 537     "Set tags for start address to end-addr, repeating tags as needed"
 538     " to cover the range. (instead of calculating the range from the"
 539     " number of tags given)">;
 540 }
 541
 542 let Command = "register read" in {
 543   def register_read_alternate : Option<"alternate", "A">,
 544     Desc<"Display register names using the alternate register name if there "
 545     "is one.">;
 546   def register_read_set : Option<"set", "s">, Group<1>, Arg<"Index">,
 547     Desc<"Specify which register sets to dump by index.">;
 548   def register_read_all : Option<"all", "a">, Group<2>,
 549     Desc<"Show all register sets.">;
 550 }
 551
 552 let Command = "source" in {
 553   def source_stop_on_error : Option<"stop-on-error", "e">, Arg<"Boolean">,
 554     Desc<"If true, stop executing commands on error.">;
 555   def source_stop_on_continue : Option<"stop-on-continue", "c">, Arg<"Boolean">,
 556     Desc<"If true, stop executing commands on continue.">;
 557   def source_silent_run : Option<"silent-run", "s">, Arg<"Boolean">,
 558     Desc<"If true don't echo commands while executing.">;
 559   def cmd_relative_to_command_file : Option<"relative-to-command-file", "C">,
 560     Desc<"Resolve non-absolute paths relative to the location of the "
 561     "current command file. This argument can only be used when the command is "
 562     "being sourced from a file.">;
 563 }
 564
 565 let Command = "alias" in {
 566   def alias_help : Option<"help", "h">, Arg<"HelpText">,
 567     Desc<"Help text for this command">;
 568   def alias_long_help : Option<"long-help", "H">, Arg<"HelpText">,
 569     Desc<"Long help text for this command">;
 570 }
 571
 572 let Command = "regex" in {
 573   def regex_help : Option<"help", "h">, Group<1>, Arg<"None">,
 574     Desc<"The help text to display for this command.">;
 575   def regex_syntax : Option<"syntax", "s">, Group<1>, Arg<"None">,
 576     Desc<"A syntax string showing the typical usage syntax.">;
 577 }
 578
 579 let Command = "permissions" in {
 580   def permissions_permissions_value : Option<"permissions-value", "v">,
 581     Arg<"PermissionsNumber">,
 582     Desc<"Give out the numeric value for permissions (e.g. 757)">;
 583   def permissions_permissions_string : Option<"permissions-string", "s">,
 584     Arg<"PermissionsString">,
 585     Desc<"Give out the string value for permissions (e.g. rwxr-xr--).">;
 586   def permissions_user_read : Option<"user-read", "r">,
 587     Desc<"Allow user to read.">;
 588   def permissions_user_write : Option<"user-write", "w">,
 589     Desc<"Allow user to write.">;
 590   def permissions_user_exec : Option<"user-exec", "x">,
 591     Desc<"Allow user to execute.">;
 592   def permissions_group_read : Option<"group-read", "R">,
 593     Desc<"Allow group to read.">;
 594   def permissions_group_write : Option<"group-write", "W">,
 595     Desc<"Allow group to write.">;
 596   def permissions_group_exec : Option<"group-exec", "X">,
 597     Desc<"Allow group to execute.">;
 598   def permissions_world_read : Option<"world-read", "d">,
 599     Desc<"Allow world to read.">;
 600   def permissions_world_write : Option<"world-write", "t">,
 601     Desc<"Allow world to write.">;
 602   def permissions_world_exec : Option<"world-exec", "e">,
 603     Desc<"Allow world to execute.">;
 604 }
 605
 606 let Command = "platform fread" in {
 607   def platform_fread_offset : Option<"offset", "o">, Group<1>, Arg<"Index">,
 608     Desc<"Offset into the file at which to start reading.">;
 609   def platform_fread_count : Option<"count", "c">, Group<1>, Arg<"Count">,
 610     Desc<"Number of bytes to read from the file.">;
 611 }
 612
 613 let Command = "platform fwrite" in {
 614   def platform_fwrite_offset : Option<"offset", "o">, Group<1>, Arg<"Index">,
 615     Desc<"Offset into the file at which to start reading.">;
 616   def platform_fwrite_data : Option<"data", "d">, Group<1>, Arg<"Value">,
 617     Desc<"Text to write to the file.">;
 618 }
 619
 620 let Command = "platform process list" in {
 621   def platform_process_list_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
 622     Desc<"List the process info for a specific process ID.">;
 623   def platform_process_list_name : Option<"name", "n">, Group<2>,
 624     Arg<"ProcessName">, Required,
 625     Desc<"Find processes with executable basenames that match a string.">;
 626   def platform_process_list_ends_with : Option<"ends-with", "e">, Group<3>,
 627   Arg<"ProcessName">, Required,
 628     Desc<"Find processes with executable basenames that end with a string.">;
 629   def platform_process_list_starts_with : Option<"starts-with", "s">, Group<4>,
 630     Arg<"ProcessName">, Required,
 631     Desc<"Find processes with executable basenames that start with a string.">;
 632   def platform_process_list_contains : Option<"contains", "c">, Group<5>,
 633     Arg<"ProcessName">, Required,
 634     Desc<"Find processes with executable basenames that contain a string.">;
 635   def platform_process_list_regex : Option<"regex", "r">, Group<6>,
 636     Arg<"RegularExpression">, Required,
 637     Desc<"Find processes with executable basenames that match a regular "
 638     "expression.">;
 639   def platform_process_list_parent : Option<"parent", "P">, GroupRange<2, 6>,
 640     Arg<"Pid">, Desc<"Find processes that have a matching parent process ID.">;
 641   def platform_process_list_uid : Option<"uid", "u">, GroupRange<2, 6>,
 642     Arg<"UnsignedInteger">, Validator<"&posix_validator">,
 643     Desc<"Find processes that have a matching user ID.">;
 644   def platform_process_list_euid : Option<"euid", "U">, GroupRange<2, 6>,
 645     Arg<"UnsignedInteger">, Validator<"&posix_validator">,
 646     Desc<"Find processes that have a matching effective user ID.">;
 647   def platform_process_list_gid : Option<"gid", "g">, GroupRange<2, 6>,
 648     Arg<"UnsignedInteger">, Validator<"&posix_validator">,
 649     Desc<"Find processes that have a matching group ID.">;
 650   def platform_process_list_egid : Option<"egid", "G">, GroupRange<2, 6>,
 651     Arg<"UnsignedInteger">, Validator<"&posix_validator">,
 652     Desc<"Find processes that have a matching effective group ID.">;
 653   def platform_process_list_arch : Option<"arch", "a">, GroupRange<2, 6>,
 654     Arg<"Architecture">,
 655     Desc<"Find processes that have a matching architecture.">;
 656   def platform_process_list_show_args : Option<"show-args", "A">,
 657     GroupRange<1, 6>,
 658     Desc<"Show process arguments instead of the process executable basename.">;
 659   def platform_process_list_all_users: Option<"all-users", "x">,
 660     GroupRange<1,6>,
 661     Desc<"Show processes matching all user IDs.">;
 662   def platform_process_list_verbose : Option<"verbose", "v">, GroupRange<1, 6>,
 663     Desc<"Enable verbose output.">;
 664 }
 665
 666 let Command = "platform process attach" in {
 667   def platform_process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">,
 668     Desc<"Name of the process plugin you want to use.">;
 669   def platform_process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
 670     Desc<"The process ID of an existing process to attach to.">;
 671   def platform_process_attach_name : Option<"name", "n">, Group<2>,
 672     Arg<"ProcessName">, Desc<"The name of the process to attach to.">;
 673   def platform_process_attach_waitfor : Option<"waitfor", "w">, Group<2>,
 674     Desc<"Wait for the process with <process-name> to launch.">;
 675 }
 676
 677 let Command = "platform shell" in {
 678   def platform_shell_host : Option<"host", "h">,
 679     Desc<"Run the commands on the host shell when enabled.">;
 680   def platform_shell_timeout : Option<"timeout", "t">, Arg<"Value">,
 681     Desc<"Seconds to wait for the remote host to finish running the command.">;
 682   def platform_shell_interpreter : Option<"shell", "s">, Arg<"Path">,
 683     Desc<"Shell interpreter path. This is the binary used to run the command.">;
 684 }
 685
 686 let Command = "process launch" in {
 687   def process_launch_stop_at_entry : Option<"stop-at-entry", "s">,
 688     Desc<"Stop at the entry point of the program when launching a process.">;
 689   def process_launch_stop_at_user_entry : Option<"stop-at-user-entry", "m">,
 690     Desc<"Stop at the user entry point when launching a process. For C based "
 691     "languages this will be the 'main' function, but this might differ for "
 692     "other languages.">;
 693   def process_launch_disable_aslr : Option<"disable-aslr", "A">, Arg<"Boolean">,
 694     Desc<"Set whether to disable address space layout randomization when launching a process.">;
 695   def process_launch_plugin : Option<"plugin", "P">, Arg<"Plugin">,
 696     Desc<"Name of the process plugin you want to use.">;
 697   def process_launch_working_dir : Option<"working-dir", "w">, Arg<"DirectoryName">,
 698     Desc<"Set the current working directory to <path> when running the inferior. This option "
 699          "applies only to the current `process launch` invocation. If "
 700          "`target.launch-working-dir` is set and this option is given, the value of this "
 701          "option will be used instead of the setting.">;
 702   def process_launch_arch : Option<"arch", "a">, Arg<"Architecture">,
 703     Desc<"Set the architecture for the process to launch when ambiguous.">;
 704   def process_launch_environment : Option<"environment", "E">,
 705     Arg<"None">, Desc<"Specify an environment variable name/value string "
 706     "(--environment NAME=VALUE). Can be specified multiple times for subsequent "
 707     "environment entries.">;
 708   def process_launch_shell : Option<"shell", "c">, GroupRange<1,3>,
 709     OptionalArg<"Filename">, Desc<"Run the process in a shell (not supported on all platforms).">;
 710   def process_launch_stdin : Option<"stdin", "i">, Group<1>,
 711     Arg<"Filename">, Desc<"Redirect stdin for the process to <filename>.">;
 712   def process_launch_stdout : Option<"stdout", "o">, Group<1>,
 713     Arg<"Filename">, Desc<"Redirect stdout for the process to <filename>.">;
 714   def process_launch_stderr : Option<"stderr", "e">, Group<1>,
 715     Arg<"Filename">, Desc<"Redirect stderr for the process to <filename>.">;
 716   def process_launch_tty : Option<"tty", "t">, Group<2>,
 717     Desc<"Start the process in a terminal (not supported on all platforms).">;
 718   def process_launch_no_stdio : Option<"no-stdio", "n">, Group<3>,
 719     Desc<"Do not set up for terminal I/O to go to running process.">;
 720   def process_launch_shell_expand_args : Option<"shell-expand-args", "X">, Group<4>,
 721     Arg<"Boolean">, Desc<"Set whether to shell expand arguments to the process when launching.">;
 722 }
 723
 724 let Command = "process attach" in {
 725   def process_attach_continue : Option<"continue", "c">,
 726     Desc<"Immediately continue the process once attached.">;
 727   def process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">,
 728     Desc<"Name of the process plugin you want to use.">;
 729   def process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
 730     Desc<"The process ID of an existing process to attach to.">;
 731   def process_attach_name : Option<"name", "n">, Group<2>, Arg<"ProcessName">,
 732     Desc<"The name of the process to attach to.">;
 733   def process_attach_include_existing : Option<"include-existing", "i">,
 734     Group<2>, Desc<"Include existing processes when doing attach -w.">;
 735   def process_attach_waitfor : Option<"waitfor", "w">, Group<2>,
 736     Desc<"Wait for the process with <process-name> to launch.">;
 737 }
 738
 739 let Command = "process continue" in {
 740   def process_continue_ignore_count : Option<"ignore-count", "i">, Group<1>,
 741     Arg<"UnsignedInteger">, Desc<"Ignore <N> crossings of the breakpoint (if it"
 742     " exists) for the currently selected thread.">;
 743   def process_continue_run_to_bkpt : Option<"continue-to-bkpt", "b">, Group<2>,
 744     Arg<"BreakpointIDRange">, Desc<"Specify a breakpoint to continue to, temporarily "
 745     "ignoring other breakpoints.  Can be specified more than once.  "
 746     "The continue action will be done synchronously if this option is specified.">;
 747 }
 748
 749 let Command = "process detach" in {
 750   def process_detach_keep_stopped : Option<"keep-stopped", "s">, Group<1>,
 751     Arg<"Boolean">, Desc<"Whether or not the process should be kept stopped on"
 752     " detach (if possible).">;
 753 }
 754
 755 let Command = "process connect" in {
 756   def process_connect_plugin : Option<"plugin", "p">, Arg<"Plugin">,
 757     Desc<"Name of the process plugin you want to use.">;
 758 }
 759
 760 let Command = "process load" in {
 761   def process_load_install : Option<"install", "i">, OptionalArg<"Path">,
 762     Desc<"Install the shared library to the target. If specified without an "
 763     "argument then the library will installed in the current working "
 764     "directory.">;
 765 }
 766
 767 let Command = "process handle" in {
 768   def process_handle_clear : Option<"clear", "c">, Group<2>,
 769     Desc<"Removes the signals listed from the Target signal handlers">;
 770   def process_handle_stop : Option<"stop", "s">, Group<1>, Arg<"Boolean">,
 771     Desc<"Whether or not the process should be stopped if the signal is "
 772     "received.">;
 773   def process_handle_notify : Option<"notify", "n">, Group<1>, Arg<"Boolean">,
 774     Desc<"Whether or not the debugger should notify the user if the signal is "
 775     "received.">;
 776   def process_handle_pass : Option<"pass", "p">, Group<1>, Arg<"Boolean">,
 777     Desc<"Whether or not the signal should be passed to the process.">;
 778   def process_handle_only_target : Option<"target", "t">, Group<1>,
 779     Desc<"Show only the signals with behaviors modified in this target">;
 780   def process_handle_dummy : Option<"dummy", "d">, Group<2>,
 781     Desc<"Also clear the values in the dummy target so they won't be inherited by new targets.">;
 782 }
 783
 784 let Command = "process status" in {
 785   def process_status_verbose : Option<"verbose", "v">, Group<1>,
 786     Desc<"Show verbose process status including extended crash information.">;
 787 }
 788
 789 let Command = "process save_core" in {
 790   def process_save_core_style : Option<"style", "s">, Group<1>,
 791     EnumArg<"SaveCoreStyle">, Desc<"Request a specific style "
 792     "of corefile to be saved.">;
 793   def process_save_core_plugin_name : Option<"plugin-name", "p">,
 794     OptionalArg<"Plugin">, Desc<"Specify a plugin name to create the core file. "
 795     "This allows core files to be saved in different formats.">;
 796 }
 797
 798 let Command = "script import" in {
 799   def script_import_allow_reload : Option<"allow-reload", "r">, Group<1>,
 800     Desc<"Allow the script to be loaded even if it was already loaded before. "
 801     "This argument exists for backwards compatibility, but reloading is always "
 802     "allowed, whether you specify it or not.">;
 803   def relative_to_command_file : Option<"relative-to-command-file", "c">,
 804     Group<1>, Desc<"Resolve non-absolute paths relative to the location of the "
 805     "current command file. This argument can only be used when the command is "
 806     "being sourced from a file.">;
 807   def silent : Option<"silent", "s">, Group<1>,
 808     Desc<"If true don't print any script output while importing.">;
 809 }
 810
 811 let Command = "script add" in {
 812   def script_add_function : Option<"function", "f">, Group<1>,
 813     Arg<"PythonFunction">,
 814     Desc<"Name of the Python function to bind to this command name.">;
 815   def script_add_class : Option<"class", "c">, Groups<[2,3]>,
 816     Arg<"PythonClass">,
 817     Desc<"Name of the Python class to bind to this command name.">;
 818   def script_add_help : Option<"help", "h">, Group<1>, Arg<"HelpText">,
 819     Desc<"The help text to display for this command.">;
 820     def script_add_overwrite : Option<"overwrite", "o">,
 821     Desc<"Overwrite an existing command at this node.">;
 822   def script_add_synchronicity : Option<"synchronicity", "s">,
 823     EnumArg<"ScriptedCommandSynchronicity">,
 824     Desc<"Set the synchronicity of this command's executions with regard to "
 825     "LLDB event system.">;
 826   def script_add_completion_type : Option<"completion-type", "C">,
 827     Groups<[1,2]>, EnumArg<"CompletionType">,
 828     Desc<"Specify which completion type the command should use - if none is "
 829     "specified, the command won't use auto-completion.">;
 830   def script_add_parsed_command : Option<"parsed", "p">, Group<3>,
 831     Desc<"Make a parsed command. The command class will provide the command "
 832     "definition by implementing get_options and get_arguments.">;
 833
 834 }
 835
 836 let Command = "container add" in {
 837   def container_add_help : Option<"help", "h">, Arg<"HelpText">,
 838     Desc<"Help text for this command">;
 839   def container_add_long_help : Option<"long-help", "H">, Arg<"HelpText">,
 840     Desc<"Long help text for this command">;
 841   def container_add_overwrite : Option<"overwrite", "o">, Group<1>,
 842   Desc<"Overwrite an existing command at this node.">;
 843 }
 844
 845 let Command = "scripting run" in {
 846   def script_language : Option<"language", "l">,
 847     EnumArg<"ScriptLang">, Desc<"Specify the scripting "
 848     " language. If none is specific the default scripting language is used.">;
 849 }
 850
 851 let Command = "scripting extension list" in {
 852   def scripting_extension_list_language : Option<"language", "l">,
 853     EnumArg<"ScriptLang">, Desc<"Specify the scripting "
 854     " language. If none is specified the default scripting language is used.">;
 855 }
 856
 857 let Command = "source info" in {
 858   def source_info_count : Option<"count", "c">, Arg<"Count">,
 859     Desc<"The number of line entries to display.">;
 860   def source_info_shlib : Option<"shlib", "s">, Groups<[1,2]>, Arg<"ShlibName">,
 861     Completion<"Module">, Desc<"Look up the source in the given module or "
 862     "shared library (can be specified more than once).">;
 863   def source_info_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
 864     Completion<"SourceFile">, Desc<"The file from which to display source.">;
 865   def source_info_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
 866     Desc<"The line number at which to start the displaying lines.">;
 867   def source_info_end_line : Option<"end-line", "e">, Group<1>, Arg<"LineNum">,
 868     Desc<"The line number at which to stop displaying lines.">;
 869   def source_info_name : Option<"name", "n">, Group<2>, Arg<"Symbol">,
 870     Completion<"Symbol">,
 871     Desc<"The name of a function whose source to display.">;
 872   def source_info_address : Option<"address", "a">, Group<3>,
 873     Arg<"AddressOrExpression">, Desc<"Lookup the address and display the source"
 874     " information for the corresponding file and line.">;
 875 }
 876
 877 let Command = "source list" in {
 878   def source_list_count : Option<"count", "c">, Arg<"Count">,
 879     Desc<"The number of source lines to display.">;
 880   def source_list_shlib : Option<"shlib", "s">, Groups<[1,2,5]>, Arg<"ShlibName">,
 881     Completion<"Module">,
 882     Desc<"Look up the source file in the given shared library.">;
 883   def source_list_show_breakpoints : Option<"show-breakpoints", "b">,
 884     Desc<"Show the line table locations from the debug information that "
 885     "indicate valid places to set source level breakpoints.">;
 886   def source_list_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
 887     Completion<"SourceFile">, Desc<"The file from which to display source.">;
 888   def source_list_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
 889     Desc<"The line number at which to start the display source.">;
 890   def source_list_name : Option<"name", "n">, Group<2>, Arg<"Symbol">,
 891     Completion<"Symbol">,
 892     Desc<"The name of a function whose source to display.">;
 893   def source_list_address : Option<"address", "a">, Group<3>,
 894     Arg<"AddressOrExpression">, Desc<"Lookup the address and display the source"
 895     " information for the corresponding file and line.">;
 896   def source_list_reverse : Option<"reverse", "r">, Group<4>, Desc<"Reverse the"
 897     " listing to look backwards from the last displayed block of source.">;
 898   def source_list_file_colon_line : Option<"joint-specifier", "y">, Group<5>,
 899     Arg<"FileLineColumn">, Completion<"SourceFile">,
 900     Desc<"A specifier in the form filename:line[:column] from which to display"
 901          " source.">;
 902 }
 903
 904 let Command = "target dependents" in {
 905   def dependents_no_dependents : Option<"no-dependents", "d">, Group<1>,
 906     OptionalEnumArg<"Value">,
 907     Desc<"Whether or not to load dependents when creating a target. If the "
 908          "option is not specified, the value is implicitly 'default'. If the "
 909          "option is specified but without a value, the value is implicitly "
 910          "'true'.">;
 911 }
 912
 913 let Command = "target modules dump" in {
 914   def target_modules_dump_verbose : Option<"verbose", "v">,
 915     Desc<"Enable verbose dump.">;
 916 }
 917
 918 let Command = "target modules list" in {
 919   def target_modules_list_address : Option<"address", "a">, Group<1>,
 920     Arg<"AddressOrExpression">, Desc<"Display the image at this address.">;
 921   def target_modules_list_arch : Option<"arch", "A">, Group<1>,
 922     OptionalArg<"Width">, Desc<"Display the architecture when listing images.">;
 923   def target_modules_list_triple : Option<"triple", "t">, Group<1>,
 924     OptionalArg<"Width">, Desc<"Display the triple when listing images.">;
 925   def target_modules_list_header : Option<"header", "h">, Group<1>,
 926     Desc<"Display the image base address as a load address if debugging, a file"
 927     " address otherwise.">;
 928   def target_modules_list_offset : Option<"offset", "o">, Group<1>,
 929     Desc<"Display the image load address offset from the base file address "
 930     "(the slide amount).">;
 931   def target_modules_list_uuid : Option<"uuid", "u">, Group<1>,
 932     Desc<"Display the UUID when listing images.">;
 933   def target_modules_list_fullpath : Option<"fullpath", "f">, Group<1>,
 934     OptionalArg<"Width">,
 935     Desc<"Display the fullpath to the image object file.">;
 936   def target_modules_list_directory : Option<"directory", "d">, Group<1>,
 937     OptionalArg<"Width">, Desc<"Display the directory with optional width for "
 938     "the image object file.">;
 939   def target_modules_list_basename : Option<"basename", "b">, Group<1>,
 940     OptionalArg<"Width">, Desc<"Display the basename with optional width for "
 941     "the image object file.">;
 942   def target_modules_list_symfile : Option<"symfile", "s">, Group<1>,
 943     OptionalArg<"Width">, Desc<"Display the fullpath to the image symbol file "
 944     "with optional width.">;
 945   def target_modules_list_symfile_unique : Option<"symfile-unique", "S">,
 946     Group<1>, OptionalArg<"Width">, Desc<"Display the symbol file with optional"
 947     " width only if it is different from the executable object file.">;
 948   def target_modules_list_mod_time : Option<"mod-time", "m">, Group<1>,
 949     OptionalArg<"Width">, Desc<"Display the modification time with optional "
 950     "width of the module.">;
 951   def target_modules_list_ref_count : Option<"ref-count", "r">, Group<1>,
 952     OptionalArg<"Width">, Desc<"Display whether the module is still in the "
 953     "the shared module cache (Y/N), and its shared pointer use_count.">;
 954   def target_modules_list_pointer : Option<"pointer", "p">, Group<1>,
 955     OptionalArg<"None">, Desc<"Display the module pointer.">;
 956   def target_modules_list_global : Option<"global", "g">, Group<1>,
 957     Desc<"Display the modules from the global module list, not just the "
 958     "current target.">;
 959 }
 960
 961 let Command = "target modules show unwind" in {
 962   def target_modules_show_unwind_name : Option<"name", "n">, Group<1>,
 963     Arg<"FunctionName">,
 964     Desc<"Show unwind instructions for a function or symbol name.">;
 965   def target_modules_show_unwind_address : Option<"address", "a">, Group<2>,
 966     Arg<"AddressOrExpression">, Desc<"Show unwind instructions for a function "
 967     "or symbol containing an address">;
 968 }
 969
 970 let Command = "target modules lookup" in {
 971   def target_modules_lookup_address : Option<"address", "a">, Group<1>,
 972     Arg<"AddressOrExpression">, Required, Desc<"Lookup an address in one or "
 973     "more target modules.">;
 974   def target_modules_lookup_offset : Option<"offset", "o">, Group<1>,
 975     Arg<"Offset">, Desc<"When looking up an address subtract <offset> from any "
 976     "addresses before doing the lookup.">;
 977   // FIXME: re-enable regex for types when the LookupTypeInModule actually uses
 978   // the regex option by adding to group 6.
 979   def target_modules_lookup_regex : Option<"regex", "r">, Groups<[2,4,5]>,
 980     Desc<"The <name> argument for name lookups are regular expressions.">;
 981   def target_modules_lookup_symbol : Option<"symbol", "s">, Group<2>,
 982     Arg<"Symbol">, Required, Desc<"Lookup a symbol by name in the symbol tables"
 983     " in one or more target modules.">;
 984   def target_modules_lookup_file : Option<"file", "f">, Group<3>,
 985     Arg<"Filename">, Required, Desc<"Lookup a file by fullpath or basename in "
 986     "one or more target modules.">;
 987   def target_modules_lookup_line : Option<"line", "l">, Group<3>,
 988     Arg<"LineNum">, Desc<"Lookup a line number in a file (must be used in "
 989     "conjunction with --file).">;
 990   def target_modules_lookup_no_inlines : Option<"no-inlines", "i">,
 991     GroupRange<3,5>,
 992     Desc<"Ignore inline entries (must be used in conjunction with --file or "
 993     "--function).">;
 994   def target_modules_lookup_function : Option<"function", "F">, Group<4>,
 995     Arg<"FunctionName">, Required, Desc<"Lookup a function by name in the debug"
 996     " symbols in one or more target modules.">;
 997   def target_modules_lookup_name : Option<"name", "n">, Group<5>,
 998     Arg<"FunctionOrSymbol">, Required, Desc<"Lookup a function or symbol by "
 999     "name in one or more target modules.">;
1000   def target_modules_lookup_type : Option<"type", "t">, Group<6>, Arg<"Name">,
1001     Required, Desc<"Lookup a type by name in the debug symbols in one or more "
1002     "target modules.">;
1003   def target_modules_lookup_variables_ranges : Option<"show-variable-ranges",
1004     "\\x01">, GroupRange<1, 6>, Desc<"Dump valid ranges of variables (must be "
1005     "used in conjunction with --verbose">;
1006   def target_modules_lookup_verbose : Option<"verbose", "v">,
1007     Desc<"Enable verbose lookup information.">;
1008   def target_modules_lookup_all : Option<"all", "A">, Desc<"Print all matches, "
1009     "not just the best match, if a best match is available.">;
1010 }
1011
1012 let Command = "target stop hook add" in {
1013   def target_stop_hook_add_one_liner : Option<"one-liner", "o">, GroupRange<1,3>,
1014     Arg<"OneLiner">, Desc<"Add a command for the stop hook.  Can be specified "
1015     "more than once, and commands will be run in the order they appear.">;
1016   def target_stop_hook_add_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
1017     Completion<"Module">,
1018     Desc<"Set the module within which the stop-hook is to be run.">;
1019   def target_stop_hook_add_thread_index : Option<"thread-index", "x">,
1020     Arg<"ThreadIndex">, Desc<"The stop hook is run only for the thread whose "
1021     "index matches this argument.">;
1022   def target_stop_hook_add_thread_id : Option<"thread-id", "t">,
1023     Arg<"ThreadID">, Desc<"The stop hook is run only for the thread whose TID "
1024     "matches this argument.">;
1025   def target_stop_hook_add_thread_name : Option<"thread-name", "T">,
1026     Arg<"ThreadName">, Desc<"The stop hook is run only for the thread whose "
1027     "thread name matches this argument.">;
1028   def target_stop_hook_add_queue_name : Option<"queue-name", "q">,
1029     Arg<"QueueName">, Desc<"The stop hook is run only for threads in the queue "
1030     "whose name is given by this argument.">;
1031   def target_stop_hook_add_file : Option<"file", "f">, Groups<[1,4]>,
1032     Arg<"Filename">, Desc<"Specify the source file within which the stop-hook "
1033     "is to be run.">, Completion<"SourceFile">;
1034   def target_stop_hook_add_start_line : Option<"start-line", "l">, Groups<[1,4]>,
1035     Arg<"LineNum">, Desc<"Set the start of the line range for which the "
1036     "stop-hook is to be run.">;
1037   def target_stop_hook_add_end_line : Option<"end-line", "e">, Groups<[1,4]>,
1038     Arg<"LineNum">, Desc<"Set the end of the line range for which the stop-hook"
1039     " is to be run.">;
1040   def target_stop_hook_add_classname : Option<"classname", "c">, Groups<[2,5]>,
1041     Arg<"ClassName">,
1042     Desc<"Specify the class within which the stop-hook is to be run.">;
1043   def target_stop_hook_add_name : Option<"name", "n">, Groups<[3,6]>,
1044     Arg<"FunctionName">, Desc<"Set the function name within which the stop hook"
1045     " will be run.">, Completion<"Symbol">;
1046   def target_stop_hook_add_auto_continue : Option<"auto-continue", "G">,
1047     Arg<"Boolean">, Desc<"The breakpoint will auto-continue after running its"
1048     " commands.">;
1049 }
1050
1051 let Command = "thread backtrace" in {
1052   def thread_backtrace_count : Option<"count", "c">, Group<1>, Arg<"Count">,
1053   Desc<"How many frames to display (0 for all)">;
1054   def thread_backtrace_start : Option<"start", "s">, Group<1>,
1055   Arg<"FrameIndex">, Desc<"Frame in which to start the backtrace">;
1056   def thread_backtrace_extended : Option<"extended", "e">, Group<1>,
1057   Arg<"Boolean">, Desc<"Show the extended backtrace, if available">;
1058   def thread_backtrace_unfiltered : Option<"unfiltered", "u">, Group<1>,
1059   Desc<"Do not filter out frames according to installed frame recognizers">;
1060 }
1061
1062 let Command = "thread step scope" in {
1063   def thread_step_scope_step_in_avoids_no_debug :
1064     Option<"step-in-avoids-no-debug", "a">, Group<1>, Arg<"Boolean">,
1065     Desc<"A boolean value that sets whether stepping into functions will step "
1066     "over functions with no debug information.">;
1067   def thread_step_scope_step_out_avoids_no_debug :
1068     Option<"step-out-avoids-no-debug", "A">, Group<1>, Arg<"Boolean">,
1069     Desc<"A boolean value, if true stepping out of functions will continue to"
1070     " step out till it hits a function with debug information.">;
1071   def thread_step_scope_count : Option<"count", "c">, Group<1>, Arg<"Count">,
1072     Desc<"How many times to perform the stepping operation - currently only "
1073     "supported for step-inst and next-inst.">;
1074   def thread_step_scope_end_linenumber : Option<"end-linenumber", "e">,
1075     Group<1>, Arg<"LineNum">, Desc<"The line at which to stop stepping - "
1076       "defaults to the next line and only supported for step-in and step-over."
1077       "  You can also pass the string 'block' to step to the end of the current"
1078       " block.  This is particularly use  in conjunction with --step-target to"
1079       " step through a complex calling sequence.">;
1080   def thread_step_scope_run_mode : Option<"run-mode", "m">, Group<1>,
1081     EnumArg<"RunMode">, Desc<"Determine how to run other "
1082     "threads while stepping the current thread.">;
1083   def thread_step_scope_step_over_regexp : Option<"step-over-regexp", "r">,
1084     Group<1>, Arg<"RegularExpression">, Desc<"A regular expression that defines "
1085     "function names to not to stop at when stepping in.">;
1086   def thread_step_scope_step_in_target : Option<"step-in-target", "t">,
1087     Group<1>, Arg<"FunctionName">, Desc<"The name of the directly called "
1088     "function step in should stop at when stepping into.">;
1089 }
1090
1091 let Command = "thread until" in {
1092   def thread_until_frame : Option<"frame", "f">, Group<1>, Arg<"FrameIndex">,
1093     Desc<"Frame index for until operation - defaults to 0">;
1094   def thread_until_thread : Option<"thread", "t">, Group<1>, Arg<"ThreadIndex">,
1095     Desc<"Thread index for the thread for until operation">;
1096   def thread_until_run_mode : Option<"run-mode", "m">, Group<1>,
1097     EnumArg<"RunMode">, Desc<"Determine how to run other "
1098     "threads while stepping this one">;
1099   def thread_until_address : Option<"address", "a">, Group<1>,
1100     Arg<"AddressOrExpression">, Desc<"Run until we reach the specified address, "
1101     "or leave the function - can be specified multiple times.">;
1102 }
1103
1104 let Command = "thread info" in {
1105   def thread_info_json : Option<"json", "j">, Desc<"Display the thread info in"
1106     " JSON format.">;
1107   def thread_info_stop_info : Option<"stop-info", "s">, Desc<"Display the "
1108     "extended stop info in JSON format.">;
1109 }
1110
1111 let Command = "thread return" in {
1112   def thread_return_from_expression : Option<"from-expression", "x">,
1113     Desc<"Return from the innermost expression evaluation.">;
1114 }
1115
1116 let Command = "thread jump" in {
1117   def thread_jump_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
1118     Completion<"SourceFile">, Desc<"Specifies the source file to jump to.">;
1119   def thread_jump_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
1120     Required, Desc<"Specifies the line number to jump to.">;
1121   def thread_jump_by : Option<"by", "b">, Group<2>, Arg<"Offset">, Required,
1122     Desc<"Jumps by a relative line offset from the current line.">;
1123   def thread_jump_address : Option<"address", "a">, Group<3>,
1124     Arg<"AddressOrExpression">, Required, Desc<"Jumps to a specific address.">;
1125   def thread_jump_force : Option<"force", "r">, Groups<[1,2,3]>,
1126     Desc<"Allows the PC to leave the current function.">;
1127 }
1128
1129 let Command = "thread plan list" in {
1130   def thread_plan_list_verbose : Option<"verbose", "v">, Group<1>,
1131     Desc<"Display more information about the thread plans">;
1132   def thread_plan_list_internal : Option<"internal", "i">, Group<1>,
1133     Desc<"Display internal as well as user thread plans">;
1134   def thread_plan_list_thread_id : Option<"thread-id", "t">, Group<1>,
1135     Arg<"ThreadID">, Desc<"List the thread plans for this TID, can be "
1136     "specified more than once.">;
1137   def thread_plan_list_unreported : Option<"unreported", "u">, Group<1>,
1138     Desc<"Display thread plans for unreported threads">;
1139 }
1140
1141 let Command = "thread select" in {
1142   def thread_select_thread_id : Option<"thread-id", "t">, Group<2>,
1143     Arg<"ThreadID">, Completion<"ThreadID">,
1144     Desc<"Provide a thread ID instead of a thread index.">;
1145 }
1146
1147 let Command = "thread trace dump function calls" in {
1148   def thread_trace_dump_function_calls_file : Option<"file", "F">, Group<1>,
1149     Arg<"Filename">,
1150     Desc<"Dump the function calls to a file instead of the standard output.">;
1151   def thread_trace_dump_function_calls_json: Option<"json", "j">,
1152     Group<1>,
1153     Desc<"Dump in simple JSON format.">;
1154   def thread_trace_dump_function_calls_pretty_json: Option<"pretty-json", "J">,
1155     Group<1>,
1156     Desc<"Dump in JSON format but pretty printing the output for easier "
1157     "readability.">;
1158 }
1159
1160 let Command = "thread trace dump instructions" in {
1161   def thread_trace_dump_instructions_forwards: Option<"forwards", "f">,
1162     Group<1>,
1163     Desc<"If specified, the trace is traversed forwards chronologically "
1164     "starting at the oldest instruction. Otherwise, it starts at the most "
1165     "recent one and the traversal is backwards.">;
1166   def thread_trace_dump_instructions_count : Option<"count", "c">, Group<1>,
1167     Arg<"Count">,
1168     Desc<"The number of instructions to display starting at the most recent "
1169     "instruction, or the oldest if --forwards is provided.">;
1170   def thread_trace_dump_instructions_all : Option<"all", "a">, Group<1>,
1171     Desc<"From the starting point of the trace, dump all instructions "
1172     "available.">;
1173   def thread_trace_dump_instructions_id: Option<"id", "i">, Group<1>,
1174     Arg<"Index">,
1175     Desc<"Custom starting instruction id from where to start traversing. This "
1176     "id can be provided in decimal or hexadecimal representation.">;
1177   def thread_trace_dump_instructions_skip: Option<"skip", "s">, Group<1>,
1178     Arg<"Index">,
1179     Desc<"How many trace items (instructions, errors and events) to skip from "
1180     "the starting position of the trace before starting the traversal.">;
1181   def thread_trace_dump_instructions_raw : Option<"raw", "r">, Group<1>,
1182     Desc<"Dump only instruction address without disassembly nor symbol "
1183     "information.">;
1184   def thread_trace_dump_instructions_file : Option<"file", "F">, Group<1>,
1185     Arg<"Filename">,
1186     Desc<"Dump the instruction to a file instead of the standard output.">;
1187   def thread_trace_dump_instructions_json: Option<"json", "j">,
1188     Group<1>,
1189     Desc<"Dump in simple JSON format.">;
1190   def thread_trace_dump_instructions_pretty_print: Option<"pretty-json", "J">,
1191     Group<1>,
1192     Desc<"Dump in JSON format but pretty printing the output for easier "
1193     "readability.">;
1194   def thread_trace_dump_instructions_show_kind : Option<"kind", "k">, Group<1>,
1195     Desc<"Show instruction control flow kind. Refer to the enum "
1196     "`InstructionControlFlowKind` for a list of control flow kind. "
1197     "As an important note, far jumps, far calls and far returns often indicate "
1198     "calls to and from kernel.">;
1199   def thread_trace_dump_instructions_show_timestamps: Option<"time", "t">,
1200     Group<1>,
1201     Desc<"For each trace item, print the corresponding wall clock timestamp "
1202     "if available.">;
1203   def thread_trace_dump_instructions_show_events : Option<"events", "e">,
1204     Group<1>,
1205     Desc<"Dump the events that happened during the execution of the target.">;
1206   def thread_trace_dump_instruction_only_events : Option<"only-events", "E">,
1207     Group<1>,
1208     Desc<"Dump only the events that happened during the execution of the "
1209     "target. No instructions are dumped.">;
1210   def thread_trace_dump_instructions_continue: Option<"continue", "C">,
1211     Group<1>,
1212     Desc<"Continue dumping instructions right where the previous invocation of "
1213     "this command was left, or from the beginning if this is the first "
1214     "invocation. The --skip argument is discarded and the other arguments are "
1215     "preserved from the previous invocation when possible.">;
1216 }
1217
1218 let Command = "thread trace dump info" in {
1219   def thread_trace_dump_info_verbose : Option<"verbose", "v">, Group<1>,
1220     Desc<"show verbose thread trace dump info">;
1221   def thread_trace_dump_info_json: Option<"json", "j">, Group<1>,
1222     Desc<"Dump in JSON format.">;
1223 }
1224
1225 let Command = "type summary add" in {
1226   def type_summary_add_category : Option<"category", "w">, Arg<"Name">,
1227     Desc<"Add this to the given category instead of the default one.">;
1228   def type_summary_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1229     Desc<"If true, cascade through typedef chains.">;
1230   def type_summary_add_no_value : Option<"no-value", "v">,
1231     Desc<"Don't show the value, just show the summary, for this type.">;
1232   def type_summary_add_skip_pointers : Option<"skip-pointers", "p">,
1233     Desc<"Don't use this format for pointers-to-type objects.">;
1234   def type_summary_add_skip_references : Option<"skip-references", "r">,
1235     Desc<"Don't use this format for references-to-type objects.">;
1236   def type_summary_add_regex : Option<"regex", "x">,
1237     Desc<"Type names are actually regular expressions.">;
1238   def type_summary_add_recognizer_function :
1239     Option<"recognizer-function", "\\x01">,
1240     Desc<"The names in the argument list are actually the names of python "
1241     "functions that decide whether to use this summary for any given type. "
1242     "Cannot be specified at the same time as --regex (-x).">;
1243   def type_summary_add_inline_children : Option<"inline-children", "c">,
1244     Group<1>, Required,
1245     Desc<"If true, inline all child values into summary string.">;
1246   def type_summary_add_omit_names : Option<"omit-names", "O">, Group<1>,
1247     Desc<"If true, omit value names in the summary display.">;
1248   def type_summary_add_summary_string : Option<"summary-string", "s">, Group<2>,
1249     Arg<"SummaryString">, Required,
1250     Desc<"Summary string used to display text and object contents.">;
1251   def type_summary_add_python_script : Option<"python-script", "o">, Group<3>,
1252     Arg<"PythonScript">,
1253     Desc<"Give a one-liner Python script as part of the command.">;
1254   def type_summary_add_python_function : Option<"python-function", "F">,
1255     Group<3>, Arg<"PythonFunction">,
1256     Desc<"Give the name of a Python function to use for this type.">;
1257   def type_summary_add_input_python : Option<"input-python", "P">, Group<3>,
1258     Desc<"Input Python code to use for this type manually.">;
1259   def type_summary_add_expand : Option<"expand", "e">, Groups<[2,3]>,
1260     Desc<"Expand aggregate data types to show children on separate lines.">;
1261   def type_summary_add_hide_empty : Option<"hide-empty", "h">, Groups<[2,3]>,
1262     Desc<"Do not expand aggregate data types with no children.">;
1263   def type_summary_add_name : Option<"name", "n">, Groups<[2,3]>, Arg<"Name">,
1264     Desc<"A name for this summary string.">;
1265 }
1266
1267 let Command = "type synth add" in {
1268   def type_synth_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1269     Desc<"If true, cascade through typedef chains.">;
1270   def type_synth_add_skip_pointers : Option<"skip-pointers", "p">,
1271     Desc<"Don't use this format for pointers-to-type objects.">;
1272   def type_synth_add_skip_references : Option<"skip-references", "r">,
1273     Desc<"Don't use this format for references-to-type objects.">;
1274   def type_synth_add_category : Option<"category", "w">, Arg<"Name">,
1275     Desc<"Add this to the given category instead of the default one.">;
1276   def type_synth_add_python_class : Option<"python-class", "l">, Group<2>,
1277     Arg<"PythonClass">,
1278     Desc<"Use this Python class to produce synthetic children.">;
1279   def type_synth_add_input_python : Option<"input-python", "P">, Group<3>,
1280     Desc<"Type Python code to generate a class that provides synthetic "
1281     "children.">;
1282   def type_synth_add_regex : Option<"regex", "x">,
1283     Desc<"Type names are actually regular expressions.">;
1284   def type_synth_add_recognizer_function :
1285     Option<"recognizer-function", "\\x01">,
1286     Desc<"The names in the argument list are actually the names of python "
1287     "functions that decide whether to use this summary for any given type. "
1288     "Cannot be specified at the same time as --regex (-x).">;
1289 }
1290
1291 let Command = "type format add" in {
1292   def type_format_add_category : Option<"category", "w">, Arg<"Name">,
1293     Desc<"Add this to the given category instead of the default one.">;
1294   def type_format_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1295     Desc<"If true, cascade through typedef chains.">;
1296   def type_format_add_skip_pointers : Option<"skip-pointers", "p">,
1297     Desc<"Don't use this format for pointers-to-type objects.">;
1298   def type_format_add_skip_references : Option<"skip-references", "r">,
1299     Desc<"Don't use this format for references-to-type objects.">;
1300   def type_format_add_regex : Option<"regex", "x">,
1301     Desc<"Type names are actually regular expressions.">;
1302   def type_format_add_type : Option<"type", "t">, Group<2>, Arg<"Name">,
1303     Desc<"Format variables as if they were of this type.">;
1304 }
1305
1306 let Command = "type formatter delete" in {
1307   def type_formatter_delete_all : Option<"all", "a">, Group<1>,
1308     Desc<"Delete from every category.">;
1309   def type_formatter_delete_category : Option<"category", "w">, Group<2>,
1310     Arg<"Name">, Desc<"Delete from given category.">;
1311   def type_formatter_delete_language : Option<"language", "l">, Group<3>,
1312     Arg<"Language">, Desc<"Delete from given language's category.">;
1313 }
1314
1315 let Command = "type formatter clear" in {
1316   def type_formatter_clear_all : Option<"all", "a">,
1317     Desc<"Clear every category.">;
1318 }
1319
1320 let Command = "type formatter list" in {
1321   def type_formatter_list_category_regex : Option<"category-regex", "w">,
1322     Group<1>, Arg<"Name">, Desc<"Only show categories matching this filter.">;
1323   def type_formatter_list_language : Option<"language", "l">, Group<2>,
1324     Arg<"Language">, Desc<"Only show the category for a specific language.">;
1325 }
1326
1327 let Command = "type category define" in {
1328   def type_category_define_enabled : Option<"enabled", "e">,
1329     Desc<"If specified, this category will be created enabled.">;
1330   def type_category_define_language : Option<"language", "l">, Arg<"Language">,
1331     Desc<"Specify the language that this category is supported for.">;
1332 }
1333
1334 let Command = "type category enable" in {
1335   def type_category_enable_language : Option<"language", "l">, Arg<"Language">,
1336     Desc<"Enable the category for this language.">;
1337 }
1338
1339 let Command = "type category disable" in {
1340   def type_category_disable_language : Option<"language", "l">, Arg<"Language">,
1341     Desc<"Enable the category for this language.">;
1342 }
1343
1344 let Command = "type filter add" in {
1345   def type_filter_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1346     Desc<"If true, cascade through typedef chains.">;
1347   def type_filter_add_skip_pointers : Option<"skip-pointers", "p">,
1348     Desc<"Don't use this format for pointers-to-type objects.">;
1349   def type_filter_add_skip_references : Option<"skip-references", "r">,
1350     Desc<"Don't use this format for references-to-type objects.">;
1351   def type_filter_add_category : Option<"category", "w">, Arg<"Name">,
1352     Desc<"Add this to the given category instead of the default one.">;
1353   def type_filter_add_child : Option<"child", "c">, Arg<"ExpressionPath">,
1354     Desc<"Include this expression path in the synthetic view.">;
1355   def type_filter_add_regex : Option<"regex", "x">,
1356     Desc<"Type names are actually regular expressions.">;
1357 }
1358
1359 let Command = "type lookup" in {
1360   def type_lookup_show_help : Option<"show-help", "h">,
1361     Desc<"Display available help for types">;
1362   def type_lookup_language : Option<"language", "l">, Arg<"Language">,
1363     Desc<"Which language's types should the search scope be">;
1364 }
1365
1366 let Command = "watchpoint list" in {
1367   def watchpoint_list_brief : Option<"brief", "b">, Group<1>, Desc<"Give a "
1368     "brief description of the watchpoint (no location info).">;
1369   def watchpoint_list_full : Option<"full", "f">, Group<2>, Desc<"Give a full "
1370     "description of the watchpoint and its locations.">;
1371   def watchpoint_list_verbose : Option<"verbose", "v">, Group<3>, Desc<"Explain "
1372     "everything we know about the watchpoint (for debugging debugger bugs).">;
1373 }
1374
1375 let Command = "watchpoint ignore" in {
1376   def watchpoint_ignore_ignore_count : Option<"ignore-count", "i">,
1377     Arg<"Count">, Required, Desc<"Set the number of times this watchpoint is"
1378     " skipped before stopping.">;
1379 }
1380
1381 let Command = "watchpoint modify" in {
1382   def watchpoint_modify_condition : Option<"condition", "c">, Arg<"Expression">,
1383     Desc<"The watchpoint stops only if this condition expression evaluates "
1384     "to true.">;
1385 }
1386
1387 let Command = "watchpoint command add" in {
1388   def watchpoint_command_add_one_liner : Option<"one-liner", "o">, Group<1>,
1389     Arg<"OneLiner">, Desc<"Specify a one-line watchpoint command inline. Be "
1390     "sure to surround it with quotes.">;
1391   def watchpoint_command_add_stop_on_error : Option<"stop-on-error", "e">,
1392     Arg<"Boolean">, Desc<"Specify whether watchpoint command execution should "
1393     "terminate on error.">;
1394   def watchpoint_command_add_script_type : Option<"script-type", "s">,
1395     EnumArg<"ScriptLang">, Desc<"Specify the language for the"
1396     " commands - if none is specified, the lldb command interpreter will be "
1397     "used.">;
1398   def watchpoint_command_add_python_function : Option<"python-function", "F">,
1399     Group<2>, Arg<"PythonFunction">, Desc<"Give the name of a Python function "
1400     "to run as command for this watchpoint. Be sure to give a module name if "
1401     "appropriate.">;
1402 }
1403
1404 let Command = "watchpoint delete" in {
1405   def watchpoint_delete_force : Option<"force", "f">, Group<1>,
1406     Desc<"Delete all watchpoints without querying for confirmation.">;
1407 }
1408
1409 let Command = "trace load" in {
1410   def trace_load_verbose : Option<"verbose", "v">, Group<1>,
1411     Desc<"Show verbose trace load logging for debugging the plug-in "
1412     "implementation.">;
1413 }
1414
1415 let Command = "trace save" in {
1416   def trace_save_compact: Option<"compact", "c">,
1417     Group<1>,
1418     Desc<"Try not to save to disk information irrelevant to the traced "
1419         "processes. Each trace plug-in implements this in a different "
1420         "fashion.">;
1421 }
1422
1423 let Command = "trace dump" in {
1424   def trace_dump_verbose : Option<"verbose", "v">, Group<1>,
1425     Desc<"Show verbose trace information.">;
1426 }
1427
1428 let Command = "trace schema" in {
1429   def trace_schema_verbose : Option<"verbose", "v">, Group<1>,
1430     Desc<"Show verbose trace schema logging for debugging the plug-in.">;
1431 }
1432
1433 let Command = "statistics dump" in {
1434   def statistics_dump_all: Option<"all-targets", "a">, Group<1>,
1435     Desc<"Include statistics for all targets.">;
1436   def statistics_dump_summary: Option<"summary", "s">, Group<1>,
1437     Desc<"Dump only high-level summary statistics. "
1438          "Exclude targets, modules, breakpoints etc... details.">;
1439   def statistics_dump_force: Option<"load-all-debug-info", "f">, Group<1>,
1440     Desc<"Dump the total possible debug info statistics. "
1441     "Force loading all the debug information if not yet loaded, and collect "
1442     "statistics with those.">;
1443   def statistics_dump_targets: Option<"targets", "r">, Group<1>,
1444     Arg<"Boolean">,
1445     Desc<"Dump statistics for the targets, including breakpoints, expression "
1446     "evaluations, frame variables, etc. "
1447     "Defaults to true in both default mode and summary mode. "
1448     "In default mode, if both '--targets' and '--modules' are 'true', a list "
1449     "of module identifiers will be added to the 'targets' section.">;
1450   def statistics_dump_modules: Option<"modules", "m">, Group<1>,
1451     Arg<"Boolean">,
1452     Desc<"Dump statistics for the modules, including time and size of various "
1453     "aspects of the module and debug information, type system, path, etc. "
1454     "Defaults to true, unless the '--summary' mode is enabled, in which case "
1455     "this is turned off unless specified. "
1456     "In default mode, if both '--targets' and '--modules' are 'true', a list "
1457     "of module identifiers will be added to the 'targets' section.">;
1458   def statistics_dump_transcript: Option<"transcript", "t">, Group<1>,
1459     Arg<"Boolean">,
1460     Desc<"If the setting interpreter.save-transcript is enabled and this "
1461     "option is 'true', include a JSON array with all commands the user and/or "
1462     "scripts executed during a debug session. "
1463     "Defaults to true, unless the '--summary' mode is enabled, in which case "
1464     "this is turned off unless specified.">;
1465
1466 }