diff options
Diffstat (limited to 'lldb/source/Commands/Options.td')
| -rw-r--r-- | lldb/source/Commands/Options.td | 3240 |
1 files changed, 2074 insertions, 1166 deletions
diff --git a/lldb/source/Commands/Options.td b/lldb/source/Commands/Options.td index 17d72cdcad12..595b3d08abec 100644 --- a/lldb/source/Commands/Options.td +++ b/lldb/source/Commands/Options.td @@ -1,232 +1,354 @@ include "OptionsBase.td" let Command = "target modules dump symtab" in { - def tm_sort : Option<"sort", "s">, Group<1>, - Desc<"Supply a sort order when dumping the symbol table.">, - EnumArg<"SortOrder">; - def tm_smn : Option<"show-mangled-names", "m">, Group<1>, - Desc<"Do not demangle symbol names before showing them.">; + 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 JSON format.">; - def tm_errors_only : Option<"errors-only", "e">, Group<1>, - Desc<"Filter to show only debug info files with errors.">; - def tm_force_load_all_debug_info : Option<"force-load-all-debug-info", "f">, - Group<1>, - Desc<"Load all debug info files.">; + 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 aliases in the command list.">; + Desc<"Hide ${a}liases in the command list.">; def help_hide_user : Option<"hide-user-commands", "u">, - Desc<"Hide user-defined commands from the list.">; + 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.">; + 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 global default value.">; - def setset_force : Option<"force", "f">, - Desc<"Force an empty value to be accepted as the default.">; - def setset_exists : Option<"exists", "e">, - Desc<"Set the setting if it exists, but do not cause the command to raise " - "an error if it does not exist.">; + 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 file into which to write the settings.">; + 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<"Append to saved settings file if it exists.">; + 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 file from which to read the settings.">; + 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 all settings.">; + def setclear_all : Option<"all", "a">, Desc<"Clear ${a}ll settings.">; } let Command = "settings show" in { def setshow_defaults : Option<"defaults", "d">, - Desc<"Include default values if defined.">; + 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 internal breakpoints">; - def blist_brief : Option<"brief", "b">, Group<1>, - Desc<"Give a brief description of the breakpoint (no location info).">; - def blist_full : Option<"full", "f">, Group<2>, - Desc<"Give a full 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 Dummy breakpoints - i.e. breakpoints set before a file is " - "provided, which prime new targets.">; + 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 stop 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 " - "index matches this argument.">; - def breakpoint_modify_thread_id : Option<"thread-id", "t">, Group<1>, - Arg<"ThreadID">, Desc<"The breakpoint stops only for the thread 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 thread 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 queue " - "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 condition " - "expression evaluates to true.">; + 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<"Enable the breakpoint.">; - def breakpoint_modify_disable : Option<"disable", "d">, Group<3>, - Desc<"Disable the breakpoint.">; - def breakpoint_modify_command : Option<"command", "C">, Group<4>, - Arg<"Command">, - Desc<"A command to run when the breakpoint is hit, can be provided more " - "than once, the commands will be run in left-to-right order.">; + 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 Dummy breakpoints - i.e. breakpoints set before a file is " - "provided, which prime new targets.">; + 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 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<"Set 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 hardware 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 file 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 line number on which to set this breakpoint.">; - def breakpoint_set_column : Option<"column", "u">, Group<1>, Arg<"ColumnNum">, - Desc<"Specifies the column 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 address. 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 name. 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 fully 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 selector 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++ method 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 regular-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 basename (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, pass the \"--all-files\" option.">; - def breakpoint_set_all_files : Option<"all-files", "A">, Group<9>, - Desc<"All 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 exceptions 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 throW.">; - def breakpoint_set_on_catch : Option<"on-catch", "h">, Group<10>, - Arg<"Boolean">, Desc<"Set the breakpoint on exception catcH.">; - def breakpoint_set_language : Option<"language", "L">, GroupRange<3, 8>, - Arg<"Language">, - Desc<"Specifies the Language 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<"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_set_breakpoint_name : Option<"breakpoint-name", "N">, - Arg<"BreakpointName">, - Desc<"Adds this to the list of names 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 " - "resolves 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<"Move 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.">; + 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 " @@ -236,465 +358,743 @@ let Command = "breakpoint set" in { } 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 file.">; - def breakpoint_clear_line : Option<"line", "l">, Group<1>, Arg<"LineNum">, - Required, - Desc<"Specify the breakpoint by source location at this particular line.">; + 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<"Delete all breakpoints which are currently disabled. When using the disabled option " - "any breakpoints listed on the command line are EXCLUDED from deletion.">; + 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.">; + 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.">; + 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 file 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.">; + 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 file into which to write the breakpoints.">; - def breakpoint_write_append : Option<"append", "a">, - Desc<"Append to saved breakpoints file if it exists.">; + 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 one-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.">; + 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.">; + 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 bytes when disassembling.">; - def disassemble_options_kind : Option<"kind", "k">, - 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 disassemble_options_context : Option<"context", "C">, Arg<"NumLines">, - Desc<"Number of context lines of source to show.">; - def disassemble_options_mixed : Option<"mixed", "m">, - Desc<"Enable mixed source and assembly display.">; - def disassemble_options_raw : Option<"raw", "r">, - Desc<"Print raw disassembly with no symbol information.">; - def disassemble_options_plugin : Option<"plugin", "P">, Arg<"Plugin">, - Desc<"Name of the disassembler plugin you want to use.">; - def disassemble_options_flavor : Option<"flavor", "F">, - Arg<"DisassemblyFlavor">, Desc<"Name of the disassembly flavor 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 architecture to use from cross disassembly.">; - def disassemble_options_start_address : Option<"start-address", "s">, - Groups<[1,2]>, Arg<"AddressOrExpression">, Required, - Desc<"Address at which to start disassembling.">; - def disassemble_options_end_address : Option<"end-address", "e">, Group<1>, - Arg<"AddressOrExpression">, Desc<"Address at which to end 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 name.">; - 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 pc.">; - def disassemble_options_line : Option<"line", "l">, Group<6>, - Desc<"Disassemble the current frame's current source line 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 address.">; - def disassemble_options_force : Option<"force", "\\x01">, Groups<[2,3,4,5,7]>, - Desc<"Force disassembly of large functions.">; + 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.">; + 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 all 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<"Ignore breakpoint hits while running expressions">; - def expression_options_timeout : Option<"timeout", "t">, Groups<[1,2]>, - Arg<"UnsignedInteger">, - Desc<"Timeout 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 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.">; } 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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 save 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.">; + 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 save 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.">; + 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.">; + 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.">; + 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)">; + 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.">; + 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.">; + 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">; + 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.">; + 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_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.">; + Desc<"Allow user to read.">; def permissions_user_write : Option<"user-write", "w">, - Desc<"Allow user to write.">; + Desc<"Allow user to write.">; def permissions_user_exec : Option<"user-exec", "x">, - Desc<"Allow user to execute.">; + Desc<"Allow user to execute.">; def permissions_group_read : Option<"group-read", "R">, - Desc<"Allow group to read.">; + Desc<"Allow group to read.">; def permissions_group_write : Option<"group-write", "W">, - Desc<"Allow group to write.">; + Desc<"Allow group to write.">; def permissions_group_exec : Option<"group-exec", "X">, - Desc<"Allow group to execute.">; + Desc<"Allow group to execute.">; def permissions_world_read : Option<"world-read", "d">, - Desc<"Allow world to read.">; + Desc<"Allow world to read.">; def permissions_world_write : Option<"world-write", "t">, - Desc<"Allow world to write.">; + Desc<"Allow world to write.">; def permissions_world_exec : Option<"world-exec", "e">, - Desc<"Allow world to execute.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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 { @@ -703,808 +1103,1316 @@ let Command = "plugin list" in { } 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_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.">; } let Command = "process attach" in { - def process_attach_continue : Option<"continue", "c">, - Desc<"Immediately continue the process once attached.">; - def process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">, - Desc<"Name of the process plugin you want to use.">; - def process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">, - Desc<"The process ID of an existing process to attach to.">; - def process_attach_name : Option<"name", "n">, Group<2>, Arg<"ProcessName">, - Desc<"The name of the process to attach to.">; - def process_attach_include_existing : Option<"include-existing", "i">, - Group<2>, Desc<"Include existing processes when doing attach -w.">; - def process_attach_waitfor : Option<"waitfor", "w">, Group<2>, - Desc<"Wait for the process with <process-name> to launch.">; + 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.">; + 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).">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; - + 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.">; + 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.">; + 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.">; + 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.">; + 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 the display 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.">; + 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'.">; + 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.">; + 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.">; + 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">; + 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.">; + 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.">; + 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 queue " - "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 file 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 line 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 end 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 class 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 function 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 " - "initially 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.">; + 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 = "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 start the backtrace">; - def thread_backtrace_extended : Option<"extended", "e">, Group<1>, - Arg<"Boolean">, Desc<"Show the extended 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_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">; } 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 use 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 regular 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.">; + 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.">; + 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_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.">; + 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.">; + 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.">; + 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">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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_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).">; + def type_synth_add_cascade : Option<"cascade", "C">, + Arg<"Boolean">, + Desc<"If true, cascade through typedef chains.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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<"Enable the category for this language.">; + 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.">; + 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">; + 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).">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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.">; + 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_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. ">; + "user and/or scripts executed during a debug session. Defaults to " + "false. ">; def statistics_dump_plugins : Option<"plugins", "p">, Group<1>, |